Beispiel #1
0
def main():
    cuda = torch.cuda.is_available()
    if cuda:
        print('Device: {}'.format(torch.cuda.get_device_name(0)))

    json_params_file = sys.argv[1]
    with open(json_params_file, "r") as json_file:
        params = json.load(json_file)
        print(params)

        if HYPERPARAM_MODE == params['mode']:
            hyperparam_log_file = open('cnn_hyperparam_optimization.txt', 'w')
            hyperparam_log_file.write(
                'batch_size,dims,lr,best_epoch,best_f1,last_f1\n')
            best_model_params = None
            best_model_f1 = -1
            base_params = params.copy()
            del base_params['mode']
            param_grid = ParameterGrid(base_params)
            for search_params in param_grid:
                print('Fitting model with params:', search_params)
                siamese_model = CNNModel(search_params, cuda)
                siamese_model.fit()
                hyperparam_log_file.write('{},{},{},{},{},{}\n'.format(
                    search_params['batch_size'], search_params['dims'],
                    search_params['lr'], siamese_model.best_epoch,
                    siamese_model.best_f1, siamese_model.current_f1))
                if siamese_model.best_f1 > best_model_f1:
                    best_model_f1 = siamese_model.best_f1
                    best_model_params = search_params
                    print('Best model params! F1:{}'.format(best_model_f1),
                          best_model_params)
            hyperparam_log_file.close()
        elif params['mode'] == 'EVAL_MODE':
            siamese_model = CNNModel(params, cuda)
            siamese_model.eval()
        else:
            siamese_model = CNNModel(params, cuda)
            siamese_model.fit()
Beispiel #2
0
            loss = loss_func(logits, labels)

            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

            total_loss += loss.data.item()

        print("\tEpoch %d, total loss: %f" % (epoch, total_loss))

    train_finish_time = time.time()
    train_overall_time = train_finish_time - start_time

    # Evaluate
    print("Evaluating ...")
    model.eval()
    predicts = []
    golds = []
    with torch.no_grad():
        for idx, batch in enumerate(tqdm(test_iter, desc="Iteration")):
            inputs, labels = batch.sent, batch.label
            inputs = inputs.to(device)

            logits = model(inputs)
            predict = torch.argmax(logits, dim=1).data.cpu().numpy()
            predicts += list(predict)
            golds += list(labels.data.cpu().numpy())

    precision, recall, f1 = F1(predicts, golds)
    print("Precision: %f, Recall: %f, F1: %f" % (precision, recall, f1))