PML/test.py at main · amrayach/PML · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
import os
from data_loader import load_data, MyDataset
from model import CharacterLevelCNN
from torch.utils.data import DataLoader
import torch
from sklearn.metrics import classification_report, f1_score, plot_confusion_matrix
from tensorboardX import SummaryWriter
from tqdm import tqdm
from torch import nn


import configparser
import utils

if __name__ == '__main__':

    args = configparser.ConfigParser()
    args.read('argsConfig.ini')
    log_dir = args.get('Test', 'model_log_dir')
    writer = SummaryWriter(log_dir)
    log_file = log_dir + 'log.txt'

    with open(log_file, 'a') as f:
        f.write('=' * 50)
        f.write('Testing')
        f.write('=' * 50)

    # load testing data
    print("\nLoading testing data...")
    texts, labels, number_of_classes, sample_weights = load_data(args, 'test')

    test_dataset = MyDataset(texts, labels, args)
    print("Transferring testing data to iterator...")
    testing_params = {"batch_size": args.getint('Train', 'batch_size'),
                       "shuffle": False,
                       "num_workers": args.getint('Train', 'workers'),
                       "drop_last": True}
    test_generator = DataLoader(test_dataset, **testing_params)

    print('\nNumber of testing samples: '+str(test_dataset.__len__()))
    with open(log_file, 'a') as f:
        f.write('\nNumber of testing samples: '+str(test_dataset.__len__())+'\n')

    model = CharacterLevelCNN(number_of_classes, args)

    print("=> loading weights from '{}'".format(args.get('Test', 'model_to_test')))
    #assert os.path.isfile(args.get('Test', 'model_to_test')), "=> no checkpoint found at '{}'".format(args.get('Test', 'model_to_test'))
    with open(log_file, 'a') as f:
        f.write("\n=> loading weights from '{}'".format(args.get('Test', 'model_to_test')))
    checkpoint = torch.load(args.get('Test', 'model_to_test'))
    model.load_state_dict(checkpoint['state_dict'])

    # using GPU
    if args.getboolean('Device', 'enable_gpu'):
        model = torch.nn.DataParallel(model).cuda()

    model.eval()
    losses = utils.AverageMeter()
    accuracies = utils.AverageMeter()
    num_iter_per_epoch = len(test_generator)
    if args.get('Train', 'criterion') == 'nllloss':
        criterion = nn.NLLLoss()

    y_true = []
    y_pred = []

    for n_iter, batch in tqdm(enumerate(test_generator), total=num_iter_per_epoch):
        features, labels = batch
        labels.sub_(1)
        if torch.cuda.is_available():
            features = features.cuda()
            labels = labels.cuda()
        with torch.no_grad():
            predictions = model(features)
        loss = criterion(predictions, labels)

        y_true += labels.cpu().numpy().tolist()
        y_pred += torch.max(predictions, 1)[1].cpu().numpy().tolist()

        validation_metrics = utils.get_evaluation(labels.cpu().numpy(),
                                                  predictions.cpu().detach().numpy(),
                                                  list_metrics=["accuracy", "f1_weighted", "f1_micro", "f1_macro"])
        accuracy = validation_metrics['accuracy']
        f1_weighted = validation_metrics['f1_weighted']
        f1_micro = validation_metrics['f1_micro']
        f1_macro = validation_metrics["f1_macro"]

        losses.update(loss.data, features.size(0))
        accuracies.update(validation_metrics["accuracy"], features.size(0))

        writer.add_scalar('Test/Loss',
                          loss.item(),
                          n_iter)

        writer.add_scalar('Test/Accuracy',
                          accuracy,
                          n_iter)

        writer.add_scalar('Test/f1-weighted',
                          f1_weighted,
                          n_iter)

        writer.add_scalar('Test/f1-micro',
                          f1_micro,
                          n_iter)

        writer.add_scalar('Test/f1-macro',
                          f1_macro,
                          n_iter)

    f1_test_weighted = f1_score(y_true, y_pred, average='weighted')
    f1_test_micro = f1_score(y_true, y_pred, average='micro')
    f1_test_macro = f1_score(y_true, y_pred, average='macro')

    report = classification_report(y_true, y_pred)
    cnf_matrix_plot = plot_confusion_matrix()

    print(report)

    with open(log_file, 'a') as f:
        f.write(f'Average loss: {losses.avg.item()} \n')
        f.write(f'Average accuracy: {accuracies.avg.item()} \n')
        f.write(f'F1 Weighted score {f1_test_weighted} \n\n')
        f.write(f'F1 Micro score {f1_test_micro} \n\n')
        f.write(f'F1 Macro score {f1_test_macro} \n\n')
        f.write(report)
        f.write('=' * 50)
        f.write('\n')