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,