def run_cnn(config): headlines_list, labels = create_data_list(config.input_path) bert_embedder = BertEmbedder(headlines_list, labels, config) embeddings, labels = bert_embedder.get_sentence_embeddings() embeddings = embeddings.unsqueeze(0).permute(1, 0, 2) x_train, x_test, y_train, y_test = train_test_split( embeddings, labels, test_size=config.test_size) train_dataset = TensorDataset(x_train, y_train) test_dataset = TensorDataset(x_test, y_test) train_dataloader = DataLoader(train_dataset, sampler=RandomSampler(train_dataset), batch_size=config.batch_size) test_dataloader = DataLoader(test_dataset, sampler=SequentialSampler(test_dataset), batch_size=config.batch_size) # dataset = TensorDataset(embeddings, labels) model = CNNModel(config, checkpoint_file=CNN_CLASSIFIER) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model.to(device) # train_dataloader, test_dataloader = get_dataloader(dataset, config.test_size, config.batch_size) loss_fn = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=config.lr) fit_result = model.fit(train_dataloader, test_dataloader, loss_fn, optimizer)
from flask import Flask, request from cnn import CNNModel import json import tensorflow as tf from flask_cors import CORS tf.enable_eager_execution() app = Flask(__name__) model = CNNModel() CORS(app) @app.route("/predict", methods=['POST']) def predict(): data = json.loads(request.data) response = model.predict(data['image']) print('Response sent as: ', response) return response if __name__ == "__main__": app.run()
top_p = np.append(top_p, topi.cpu().squeeze(1).data.numpy(), axis=1) prediction = torch.cat((prediction, topi.data.cpu())) #print(topi.squeeze(1).size()) prev_in = topi.squeeze().detach() #print(prev_in) num_correct = float( (prediction.view(-1) == target_tens.view(-1).long()).sum()) accuracy = (num_correct / operator.mul(*target_tens.shape)) * 100. print('Number correct: {}, Accuracy: {}'.format(num_correct, accuracy)) return top_p if __name__ == '__main__': conv = CNNModel().cuda() #self, batch_size, inputs_size, img_w, hidden_size, num_layers enc = EncoderLSTM(batch_size, 512, 46, enc_hidden_size, enc_layers, gpu=True).cuda().eval() #self, batch_size, inputs_size, vocab_size, hidden_size, max_decoder_l, dropout_p=0.01 dec = ATTNDecoder(batch_size, enc_hidden_size, 1, vocab_size, dec_hidden_size, gpu=True).cuda().eval() conv.load_state_dict(
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()
def cnn_cross_validation_model(config, n_splits): scores = {} kf = KFold(n_splits=n_splits) params_grid = {'l_r': [3e-5, 5e-5, 1e-4, 1e-3], 'batch_size': [32, 64]} headlines_list, labels = create_data_list(config.input_path) bert_embedder = BertEmbedder(headlines_list, labels, config) print("started embedding") embeddings, labels = bert_embedder.get_sentence_embeddings() print("finished embedding") embeddings = embeddings.unsqueeze(0).permute(1, 0, 2) x_train, x_test, y_train, y_test = train_test_split( embeddings, labels, test_size=config.test_size) max_acc = -numpy.inf for index, params in enumerate(list( ParameterGrid(param_grid=params_grid))): device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') print( "-----------------------------------------------------------------" ) print(f"current params are {params}") print(f" index is: {index}") curr_acc = 0 for train_idx, valid_idx in kf.split(x_train): cnn = CNNModel(config, checkpoint_file=CNN_CLASSIFIER) cnn.to(device) cnn.batch_size = params['batch_size'] loss_fn = nn.CrossEntropyLoss() optimizer = optim.Adam(cnn.parameters(), lr=params["l_r"]) train_x, train_y = x_train[train_idx], y_train[train_idx] train_set = TensorDataset(train_x, train_y) valid_x, valid_y = x_train[valid_idx], y_train[valid_idx] valid_set = TensorDataset(valid_x, valid_y) train_dataloader = DataLoader(train_set, sampler=RandomSampler(train_set), batch_size=cnn.batch_size) valid_dataloader = DataLoader(valid_set, sampler=SequentialSampler(valid_set), batch_size=cnn.batch_size) fit_result = cnn.fit(train_dataloader, valid_dataloader, loss_fn, optimizer) curr_acc += max(fit_result.test_acc) mean = curr_acc / n_splits scores[f"{params}"] = mean if mean > max_acc: max_acc = mean best_params = params scores[index] = {"params": params, "acc": mean} print(f"all scores: {scores}") print(f"max accuracy achieved is {max_acc}") print(f"best params are {best_params}") train_dataset = TensorDataset(x_train, y_train) test_dataset = TensorDataset(x_test, y_test) train_dataloader = DataLoader(train_dataset, sampler=RandomSampler(train_dataset), batch_size=best_params['batch_size']) test_dataloader = DataLoader(test_dataset, sampler=SequentialSampler(test_dataset), batch_size=best_params['batch_size']) best_model = CNNModel(config, checkpoint_file=CNN_CLASSIFIER) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') best_model.to(device) best_model.batch_size = best_params['batch_size'] loss_fn = nn.CrossEntropyLoss() optimizer = optim.Adam(best_model.parameters(), lr=best_params["l_r"]) fit_result = best_model.fit(train_dataloader, test_dataloader, loss_fn, optimizer)
# Load data print("Loading data ...") train_iter, test_iter, vocab_size, vocab_weights = load_data( args.dataset, args.batch_size, args.max_seq_length, glove=args.glove, emb_size=args.emb_size) # Initialize model assert args.model in ["CNN", "LSTM", "BILSTM"], "Only support CNN, LSTM or BILSTM." if args.model == "CNN": model = CNNModel(vocab_size, args.emb_size, args.max_seq_length, weights=vocab_weights, fix_emb_weight=args.fix_emb) elif args.model == "LSTM": model = LSTMModel(vocab_size, args.emb_size, args.max_seq_length, weights=vocab_weights, fix_emb_weight=args.fix_emb) else: model = BILSTMModel(vocab_size, args.emb_size, args.max_seq_length, weights=vocab_weights, fix_emb_weight=args.fix_emb)
# print('dec output=',dec_output.squeeze(1).shape) # print('target =', target_tensor[i,:].shape) # print('dec output') # print(dec_output.squeeze(1)) # print('target') # print(target_tensor[i,:].long()) num_correct = float(( prediction.view(-1) == target_tensor.cpu().view(-1).long().data).sum()) accuracy = (num_correct / operator.mul(*target_tensor.shape)) * 100. print('Number correct: {}, Accuracy: {}'.format(num_correct, accuracy)) # return top_p if __name__ == '__main__': conv = CNNModel().cuda() #self, batch_size, inputs_size, img_w, hidden_size, num_layers enc = EncoderLSTM(BATCH_SIZE, 512, enc_hidden_size, enc_layers, gpu=True).cuda().eval() #self, batch_size, inputs_size, vocab_size, hidden_size, max_decoder_l, dropout_p=0.01 dec = ATTNDecoder(BATCH_SIZE, enc_hidden_size, vocab_size, dec_hidden_size, gpu=True).cuda().eval() conv.load_state_dict( torch.load( '/scratch2/sophiat/chem-ie-TJS_omrPY/omrPY/im_smiles/src/model/model_conv' )) enc.load_state_dict( torch.load(
BASE_DIR + 'omrPY/im_smiles/src/model/model_enc') torch.save( decoder.state_dict(), BASE_DIR + 'omrPY/im_smiles/src/model/model_dec') if iters % plot_every == 0: plot_loss_avg = plot_loss_total / plot_every plot_losses.append(plot_loss_avg) plot_loss_total = 0 batch_num += 1 if __name__ == '__main__': gpu = True if gpu: conv = CNNModel().cuda() enc = EncoderLSTM(batch_size, 512, enc_hidden_size, enc_layers, gpu=True).cuda() dec = ATTNDecoder(batch_size, enc_hidden_size, vocab_size, dec_hidden_size, dropout_p=0.01, gpu=True).cuda() trainIters(conv, enc, dec, 1,