def main(params): model = Task5Model(params) train_dataset = TaskDataset(params, 'data/task6_train_sequence.csv', 'data/task6_train_label.csv') test_dataset = TaskDataset(params, 'data/task6_test_sequence.csv', 'data/task6_test_label.csv') train_dataloader = DataLoader(train_dataset, batch_size=params['batch_size'], shuffle=True) test_dataloader = DataLoader(test_dataset, batch_size=params['batch_size'], shuffle=False) loss_fn = torch.nn.BCEWithLogitsLoss() # loss_fn = torch.nn.CrossEntropyLoss() optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=params['lr']) model = torcheras.Model(model, 'log/') model.compile(loss_fn, optimizer, metrics=['binary_acc']) writer = SummaryWriter() result = [] def callback(epoch, i_batch, metrics_result): result.append(metrics_result['binary_acc']) model.fit(train_dataloader, test_dataloader, epochs=10, batch_callback=callback)
def evaluate_model(params, dtype='test', model_folder='', model_epoch=''): test_dataset = QANetDataset('data', dtype) test_dataloader = DataLoader(test_dataset, batch_size=32, shuffle=True) test_eval = pickle.load(open('data/' + dtype + '_eval.pkl', 'rb')) word_emb_mat = np.array(pickle.load( open(os.path.join(params['target_dir'], 'word_emb_mat.pkl'), 'rb')), dtype=np.float32) char_emb_mat = np.array(pickle.load( open(os.path.join(params['target_dir'], 'char_emb_mat.pkl'), 'rb')), dtype=np.float32) qanet = QANet(params, word_emb_mat, char_emb_mat).to(device) qanet = torcheras.Model(qanet, 'log/qanet') qanet.load_model(model_folder, epoch=model_epoch, ema=True) qanet = qanet.model qanet.eval() all_scores = {'em': 0, 'f1': 0} with torch.no_grad(): for i_batch, sample_batched in enumerate(test_dataloader): x, y_true = variable_data(sample_batched, device) y_pred = qanet(x) metrics = evaluate_scores(y_true, y_pred, test_eval) print(metrics) all_scores['em'] += metrics['exact_match'] all_scores['f1'] += metrics['f1'] print('em', all_scores['em'] / i_batch, 'f1', all_scores['f1'] / i_batch)
def main(params): model = Task3Model() dataset = TestDataset(params, 'data/task3_passage.csv', 'data/task3_query.csv', 'data/task3_label.csv') dataloader = DataLoader(dataset, batch_size=params['batch_size'], shuffle=True) loss_fn = torch.nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=params['lr']) print(model) model = torcheras.Model(model, 'log/') model.compile(loss_fn, optimizer, metrics=['categorical_acc']) writer = SummaryWriter() result = [] def callback(epoch, i_batch, metrics_result): # print(i_batch, metrics_result) for metric, value in metrics_result.items(): writer.add_scalar('data/' + metric, value, i_batch) result.append(metrics_result['categorical_acc']) model.fit(dataloader, epochs=1, batch_callback=callback) # writer.export_scalars_to_json("./all_scalars.json") writer.close() print(sum(result[-100:]))
def main(params): device = torch.device('cuda:0') model = TaskModel(params) train_dataset = TaskDataset(params, 'data/blob_train_image_data/', 'data/train_sym.txt') # test_dataset = train_dataset[int(len(train_dataset)*0.8):] # train_dataset = train_dataset[:int(len(train_dataset)*0.8)] train_dataloader = DataLoader(train_dataset, batch_size=params['batch_size'], shuffle=True) # test_dataloader = DataLoader(test_dataset, batch_size=params['batch_size'], shuffle=False) loss_fn = torch.nn.BCEWithLogitsLoss() optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=params['lr']) model = torcheras.Model(model, 'log/') model.compile(loss_fn, optimizer, metrics=['binary_acc'], device=device) writer = SummaryWriter() result = [] def callback(epoch, i_batch, metrics_result): result.append(metrics_result['binary_acc']) model.fit(train_dataloader, epochs=10, batch_callback=callback)
def main(params): model = Test2Model(params['in_channels'], params['out_channels']) dataset = TestDataset(params, 'data/task2_data.csv', 'data/task2_label.csv') dataloader = DataLoader(dataset, batch_size=params['batch_size'], shuffle=True) loss_fn = torch.nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=params['lr']) model = torcheras.Model(model, 'log/') model.compile(loss_fn, optimizer, metrics=['categorical_acc']) writer = SummaryWriter() def callback(epoch, i_batch, metrics_result): print(i_batch, metrics_result) for metric, value in metrics_result.items(): writer.add_scalar('data/' + metric, value, i_batch) model.fit(dataloader, epochs=1, batch_callback=callback) writer.export_scalars_to_json("./all_scalars.json") writer.close()
def main(params): model = Task5Model(params) dataset = TaskDataset(params, 'data/task5_2_train_paragraph1.csv', 'data/task5_2_train_paragraph2.csv', 'data/task5_2_train_label.csv') dataloader = DataLoader(dataset, batch_size=params['batch_size'], shuffle=True) loss_fn = torch.nn.BCEWithLogitsLoss() optimizer = torch.optim.Adam(model.parameters(), lr=params['lr']) model = torcheras.Model(model, 'log/') model.compile(loss_fn, optimizer, metrics=['binary_acc']) writer = SummaryWriter() result = [] def callback(epoch, i_batch, metrics_result): result.append(metrics_result['binary_acc']) model.fit(dataloader, epochs=1, batch_callback=callback) print(sum(result[-100:])) p1 = np.array(pd.read_csv('data/task5_2_test_paragraph1.csv', header=None), dtype=np.int) p2 = np.array(pd.read_csv('data/task5_2_test_paragraph2.csv', header=None), dtype=np.int) results = [] for i in range(p1.shape[0]): result = model.model.forward( (torch.LongTensor([p1[i]]), torch.LongTensor([p2[i]]))) if result > 0.5: results.append(1) else: results.append(0) print(results)
def train(params, description): train_dataset = QANetDataset('data', 'train') dev_dataset = QANetDataset('data', 'dev') train_eval = pickle.load(open('data/train_eval.pkl', 'rb')) dev_eval = pickle.load(open('data/dev_eval.pkl', 'rb')) def evaluate_em(y_true, y_pred): qa_id = y_true[1] c_mask, q_mask = y_pred[2:] y_p1 = F.softmax(y_pred[0], dim=-1) y_p2 = F.softmax(y_pred[1], dim=-1) p1 = [] p2 = [] p_matrix = torch.bmm(y_p1.unsqueeze(2), y_p2.unsqueeze(1)) for i in range(p_matrix.shape[0]): p = torch.triu(p_matrix[i]) indexes = torch.argmax(p).item() p1.append(indexes // p.shape[0]) p2.append(indexes % p.shape[0]) if y_pred[0].requires_grad: answer_dict, _ = convert_tokens(train_eval, qa_id.tolist(), p1, p2) metrics = evaluate(train_eval, answer_dict) else: answer_dict, _ = convert_tokens(dev_eval, qa_id.tolist(), p1, p2) metrics = evaluate(dev_eval, answer_dict) return torch.Tensor([metrics['exact_match']]) train_loader = DataLoader(train_dataset, batch_size=params['batch_size'], shuffle=True) dev_loader = DataLoader(dev_dataset, batch_size=params['batch_size'], shuffle=True) word_emb_mat = np.array(pickle.load( open(os.path.join(params['target_dir'], 'word_emb_mat.pkl'), 'rb')), dtype=np.float32) char_emb_mat = np.array(pickle.load( open(os.path.join(params['target_dir'], 'char_emb_mat.pkl'), 'rb')), dtype=np.float32) qanet = QANet(params, word_emb_mat, char_emb_mat).to(device) optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad, qanet.parameters()), lr=params['learning_rate'], betas=(params['beta1'], params['beta2']), weight_decay=params['weight_decay']) crit = 1 / math.log(1000) scheduler = torch.optim.lr_scheduler.LambdaLR( optimizer, lr_lambda=lambda ee: crit * math.log(ee + 1) if (ee + 1) <= 1000 else 1) qanet = torcheras.Model(qanet, 'log/qanet') print(description) qanet.set_description(description) custom_objects = {'em': evaluate_em} qanet.compile(loss_function, scheduler, metrics=['em'], device=device, custom_objects=custom_objects) qanet.fit(train_loader, dev_loader, ema_decay=0.9999, grad_clip=5)
import torch import torcheras from torch.utils.data import DataLoader import torch.nn.functional as F import os from PIL import Image device = torch.device('cuda:0') if torch.cuda.is_available() else torch.device( 'cpu:0') model = TaskModel(params).to(device) test_img_path = 'data/blob_test_image_data/' model = torcheras.Model(model, 'log') model.load_model('', epoch=5) model = model.model model.eval() with torch.no_grad(): for img_path in os.listdir(test_img_path): img = np.array(Image.open(test_img_path + img_path), dtype=np.float32) / 255. img = torch.Tensor(img).to(device) y_pred = model(img) y_pred = F.sigmoid(y_pred) print(y_pred)