class Predictor: def __init__(self, ckpt_path): super().__init__() self.transform = transforms.Compose([ transforms.ToPILImage(), transforms.Resize(256), transforms.ToTensor() ]) self.checkpoint = torch.load(ckpt_path) self.model = CNN() self.model.load_state_dict(state_dict=self.checkpoint['state_dict']) self.use_cuda = False self.model.eval() if torch.cuda.is_available(): self.model.cuda() self.use_cuda = True def run(self, path): img = self.transform(io.imread(path)) img.unsqueeze_(0) if self.use_cuda: img = img.cuda() with torch.no_grad(): pred = self.model(img) return pred.item()
def bilstm_train(self, numEpochs, batch_size, save_file, lr): print('training .....') # set up loss function -- 'SVM Loss' a.k.a ''Cross-Entropy Loss loss_func = nn.CrossEntropyLoss() net = CNN(embed_dim=100) # net.load_state_dict(torch.load('model_50.pth')) # SGD used for optimization, momentum update used as parameter update optimization = torch.optim.SGD(net.parameters(), lr=lr, momentum=0.9) net.cuda() loss_func.cuda() train_losses = [] test_losses = [] for epoch in range(0,numEpochs): # training set -- perform model training epoch_training_loss = 0.0 num_batches = 0 pbar = tqdm(range(0, len(self.train_seqs), batch_size)) for batch_num in pbar: # 'enumerate' is a super helpful function # split training data into inputs and labels if batch_num+batch_size>len(self.train_seqs): end = len(self.action_seqs) else: end = batch_num+batch_size raw_inputs, labels_ = self.train_seqs[batch_num:end], self.train_labels[batch_num:end] # 'training_batch' is a list inputs_ = self.get_embedding(raw_inputs) inputs = torch.from_numpy(inputs_).float().cuda() labels = torch.from_numpy(labels_).cuda() # wrap data in 'Variable' inputs, labels = torch.autograd.Variable(inputs), torch.autograd.Variable(labels) # Make gradients zero for parameters 'W', 'b' optimization.zero_grad() # forward, backward pass with parameter update forward_output = net(inputs) loss = loss_func(forward_output, labels) loss.backward() optimization.step() # calculating loss epoch_training_loss += loss.data.item() num_batches += 1 # print(loss.data.item()) pbar.set_description("processing batch %s" % str(batch_num)) print("epoch: ", epoch, ", loss: ", epoch_training_loss / num_batches) # train_loss = self.test(net, batch_size=256, test_data=self.train_seqs, test_label=self.train_labels) test_loss = self.test(net, batch_size=256, test_data=self.test_seqs, test_label=self.test_labels) # train_losses.append(train_loss) test_losses.append(test_loss) # if epoch%10 == 0: # save_path = save_file+'model3_' +str(epoch)+'.pth' # torch.save(net.state_dict(), save_path) # with open('train_loss_1.p','wb') as fin: # pickle.dump(train_losses,fin) # fin.close() with open('test_loss_1.p','wb') as fin: pickle.dump(test_losses,fin) fin.close()
def predict(img_dir='./data/test'): transforms = Compose([Resize(height, weight), ToTensor()]) dataset = CaptchaData(img_dir, transform=transforms) cnn = CNN() if torch.cuda.is_available(): cnn = cnn.cuda() cnn.eval() cnn.load_state_dict(torch.load(model_path)) for k, (img, target) in enumerate(dataset): img = img.view(1, 3, height, weight).cuda() target = target.view(1, 4 * 36).cuda() output = cnn(img) output = output.view(-1, 36) target = target.view(-1, 36) output = nn.functional.softmax(output, dim=1) output = torch.argmax(output, dim=1) target = torch.argmax(target, dim=1) output = output.view(-1, 4)[0] target = target.view(-1, 4)[0] print('pred: ' + ''.join([alphabet[i] for i in output.cpu().numpy()])) print('true: ' + ''.join([alphabet[i] for i in target.cpu().numpy()])) plot.imshow(img.permute((0, 2, 3, 1))[0].cpu().numpy()) plot.show() if k >= 10: break
def post_predict(): text = "failure" if request.method == 'POST': file = request.get_data() img = Image.open(BytesIO(file)).convert('RGB') print('宽:%d,高:%d' % (img.size[0], img.size[1])) width = img.size[0] height = img.size[1] transform = Compose([Resize(height, width), ToTensor()]) img = transform(img) cnn = CNN() if torch.cuda.is_available(): cnn = cnn.cuda() cnn.eval() cnn.load_state_dict(torch.load(model_path, map_location='cpu')) img = img.view(1, 3, height, width).cuda() output = cnn(img) output = output.view(-1, 36) output = nn.functional.softmax(output, dim=1) output = torch.argmax(output, dim=1) output = output.view(-1, 4)[0] text = ''.join([alphabet[i] for i in output.cpu().numpy()]) # print('pred: '+text) # plot.imshow(img.permute((0, 2, 3, 1))[0].cpu().numpy()) # plot.show() return text
def load_net(): global model_net model_net = CNN(num_class=len(alphabet), num_char=int(numchar), width=width, height=height) if use_gpu: model_net = model_net.cuda() model_net.eval() model_net.load_state_dict(torch.load(model_path)) else: model_net.eval() model_net.load_state_dict(torch.load(model_path, map_location='cpu'))
def predict(img_dir=Path('./captcha')): transforms = Compose([ToTensor()]) for i in img_dir.glob("*png"): print(i.name) img = img_loader('./captcha/%s' % i.name) img = transforms(img) cnn = CNN() if torch.cuda.is_available(): cnn = cnn.cuda() cnn.load_state_dict(torch.load(model_path)) img = img.view(1, 3, 36, 120).cuda() output = cnn(img) output = output.view(-1, 36) output = nn.functional.softmax(output, dim=1) output = torch.argmax(output, dim=1) output = output.view(-1, num_class)[0] pred = ''.join([alphabet[i] for i in output.cpu().numpy()]) print(pred)
def init_model(nfm=32, res_blocks=1, in_frames=2, batch_size=2, epoch_to_load=None): resnet = ResNet(nfm*2, res_blocks) if torch.cuda.is_available(): resnet=resnet.cuda() my_unet = U_Net(nfm, resnet, 1, 1) discriminator = CNN((in_frames+1)*3, nfm, 512) if epoch_to_load != None: my_unet = torch.load('unet_epoch_{}'.format(epoch_to_load)) discriminator = torch.load('D_epoch_{}'.format(epoch_to_load)) if torch.cuda.is_available(): my_unet, discriminator = my_unet.cuda(), discriminator.cuda() Unet_optim = torch.optim.Adam(my_unet.parameters(), lr=0.002) D_optim = torch.optim.Adam(discriminator.parameters(), lr=0.002) return {'Unet': my_unet, 'Discriminator': discriminator, 'Unet_optimizer': Unet_optim, 'Discriminator_optimizer': D_optim}
batch_size = 100 writer.add_scalar("Batch_Size", batch_size) num_epochs = 2 writer.add_scalar("Number_of_Epochs", num_epochs) train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True) test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False) model = CNN() if torch.cuda.is_available(): model.cuda() criterion = nn.CrossEntropyLoss() learning_rate = 0.1 writer.add_scalar("Learning_Rate", learning_rate) optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate) train(train_loader, test_loader, model, optimizer, criterion) # torch.save(model, "./CNN.pt") # model2 = torch.load("./CNN.pt") # torch.save(model.state_dict(), "./CNN_State.pt") # model2 = CNN() # model2.load_state_dict(torch.load("./CNN_State.pt")) # torch.save({
def main(args): # hyperparameters batch_size = args.batch_size num_workers = 1 # Image Preprocessing transform = transforms.Compose([ transforms.Resize((224, 224)), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)), ]) # load COCOs dataset IMAGES_PATH = 'data/train2014' CAPTION_FILE_PATH = 'data/annotations/captions_train2014.json' vocab = load_vocab() train_loader = get_coco_data_loader(path=IMAGES_PATH, json=CAPTION_FILE_PATH, vocab=vocab, transform=transform, batch_size=batch_size, shuffle=True, num_workers=num_workers) IMAGES_PATH = 'data/val2014' CAPTION_FILE_PATH = 'data/annotations/captions_val2014.json' val_loader = get_coco_data_loader(path=IMAGES_PATH, json=CAPTION_FILE_PATH, vocab=vocab, transform=transform, batch_size=batch_size, shuffle=True, num_workers=num_workers) losses_val = [] losses_train = [] # Build the models ngpu = 1 initial_step = initial_epoch = 0 embed_size = args.embed_size num_hiddens = args.num_hidden learning_rate = 1e-3 num_epochs = 3 log_step = args.log_step save_step = 500 checkpoint_dir = args.checkpoint_dir encoder = CNN(embed_size) decoder = RNN(embed_size, num_hiddens, len(vocab), 1, rec_unit=args.rec_unit) # Loss criterion = nn.CrossEntropyLoss() if args.checkpoint_file: encoder_state_dict, decoder_state_dict, optimizer, *meta = utils.load_models( args.checkpoint_file, args.sample) initial_step, initial_epoch, losses_train, losses_val = meta encoder.load_state_dict(encoder_state_dict) decoder.load_state_dict(decoder_state_dict) else: params = list(decoder.parameters()) + list( encoder.linear.parameters()) + list(encoder.batchnorm.parameters()) optimizer = torch.optim.Adam(params, lr=learning_rate) if torch.cuda.is_available(): encoder.cuda() decoder.cuda() if args.sample: return utils.sample(encoder, decoder, vocab, val_loader) # Train the Models total_step = len(train_loader) try: for epoch in range(initial_epoch, num_epochs): for step, (images, captions, lengths) in enumerate(train_loader, start=initial_step): # Set mini-batch dataset images = utils.to_var(images, volatile=True) captions = utils.to_var(captions) targets = pack_padded_sequence(captions, lengths, batch_first=True)[0] # Forward, Backward and Optimize decoder.zero_grad() encoder.zero_grad() if ngpu > 1: # run on multiple GPU features = nn.parallel.data_parallel( encoder, images, range(ngpu)) outputs = nn.parallel.data_parallel( decoder, features, range(ngpu)) else: # run on single GPU features = encoder(images) outputs = decoder(features, captions, lengths) train_loss = criterion(outputs, targets) losses_train.append(train_loss.data[0]) train_loss.backward() optimizer.step() # Run validation set and predict if step % log_step == 0: encoder.batchnorm.eval() # run validation set batch_loss_val = [] for val_step, (images, captions, lengths) in enumerate(val_loader): images = utils.to_var(images, volatile=True) captions = utils.to_var(captions, volatile=True) targets = pack_padded_sequence(captions, lengths, batch_first=True)[0] features = encoder(images) outputs = decoder(features, captions, lengths) val_loss = criterion(outputs, targets) batch_loss_val.append(val_loss.data[0]) losses_val.append(np.mean(batch_loss_val)) # predict sampled_ids = decoder.sample(features) sampled_ids = sampled_ids.cpu().data.numpy()[0] sentence = utils.convert_back_to_text(sampled_ids, vocab) print('Sample:', sentence) true_ids = captions.cpu().data.numpy()[0] sentence = utils.convert_back_to_text(true_ids, vocab) print('Target:', sentence) print( 'Epoch: {} - Step: {} - Train Loss: {} - Eval Loss: {}' .format(epoch, step, losses_train[-1], losses_val[-1])) encoder.batchnorm.train() # Save the models if (step + 1) % save_step == 0: utils.save_models(encoder, decoder, optimizer, step, epoch, losses_train, losses_val, checkpoint_dir) utils.dump_losses( losses_train, losses_val, os.path.join(checkpoint_dir, 'losses.pkl')) except KeyboardInterrupt: pass finally: # Do final save utils.save_models(encoder, decoder, optimizer, step, epoch, losses_train, losses_val, checkpoint_dir) utils.dump_losses(losses_train, losses_val, os.path.join(checkpoint_dir, 'losses.pkl'))
def train(): transforms = Compose([Resize((height, width)), ToTensor()]) train_dataset = CaptchaData(train_data_path, num_class=len(alphabet), num_char=int(numchar), transform=transforms, alphabet=alphabet) train_data_loader = DataLoader(train_dataset, batch_size=batch_size, num_workers=num_workers, shuffle=True, drop_last=True) test_data = CaptchaData(test_data_path, num_class=len(alphabet), num_char=int(numchar), transform=transforms, alphabet=alphabet) test_data_loader = DataLoader(test_data, batch_size=batch_size, num_workers=num_workers, shuffle=True, drop_last=True) cnn = CNN(num_class=len(alphabet), num_char=int(numchar), width=width, height=height) if use_gpu: cnn.cuda() optimizer = torch.optim.Adam(cnn.parameters(), lr=base_lr) criterion = nn.MultiLabelSoftMarginLoss() for epoch in range(max_epoch): start_ = time.time() loss_history = [] acc_history = [] cnn.train() for img, target in train_data_loader: img = Variable(img) target = Variable(target) if use_gpu: img = img.cuda() target = target.cuda() output = cnn(img) loss = criterion(output, target) optimizer.zero_grad() loss.backward() optimizer.step() acc = calculat_acc(output, target) acc_history.append(float(acc)) loss_history.append(float(loss)) print('epoch:{},train_loss: {:.4}|train_acc: {:.4}'.format( epoch, torch.mean(torch.Tensor(loss_history)), torch.mean(torch.Tensor(acc_history)), )) loss_history = [] acc_history = [] cnn.eval() for img, target in test_data_loader: img = Variable(img) target = Variable(target) if torch.cuda.is_available(): img = img.cuda() target = target.cuda() output = cnn(img) acc = calculat_acc(output, target) acc_history.append(float(acc)) loss_history.append(float(loss)) print('test_loss: {:.4}|test_acc: {:.4}'.format( torch.mean(torch.Tensor(loss_history)), torch.mean(torch.Tensor(acc_history)), )) print('epoch: {}|time: {:.4f}'.format(epoch, time.time() - start_)) torch.save(cnn.state_dict(), os.path.join(model_path, "model_{}.path".format(epoch)))
def main(args): # hyperparameters batch_size = args.batch_size num_workers = 2 # Image Preprocessing transform = transforms.Compose([ transforms.Resize((224, 224)), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)), ]) vocab = load_vocab() loader = get_basic_loader(dir_path=os.path.join(args.image_path), transform=transform, batch_size=batch_size, shuffle=False, num_workers=num_workers) # Build the models embed_size = args.embed_size num_hiddens = args.num_hidden checkpoint_path = 'checkpoints' encoder = CNN(embed_size) decoder = RNN(embed_size, num_hiddens, len(vocab), 1, rec_unit=args.rec_unit) encoder_state_dict, decoder_state_dict, optimizer, *meta = utils.load_models( args.checkpoint_file) encoder.load_state_dict(encoder_state_dict) decoder.load_state_dict(decoder_state_dict) if torch.cuda.is_available(): encoder.cuda() decoder.cuda() # Train the Models try: results = [] with torch.no_grad(): for step, (images, image_ids) in enumerate(tqdm(loader)): images = utils.to_var(images) features = encoder(images) captions = beam_sample(decoder, features) # captions = decoder.sample(features) captions = captions.cpu().data.numpy() captions = [ utils.convert_back_to_text(cap, vocab) for cap in captions ] captions_formatted = [{ 'image_id': int(img_id), 'caption': cap } for img_id, cap in zip(image_ids, captions)] results.extend(captions_formatted) print('Sample:', captions_formatted[0]) except KeyboardInterrupt: print('Ok bye!') finally: import json file_name = 'captions_model.json' with open(file_name, 'w') as f: json.dump(results, f)
from models import CNN from datasets import img_loader from torchvision.transforms import Compose, ToTensor from train import num_class from pathlib import Path model_path = './checkpoints/model.pth' source = [str(i) for i in range(0, 10)] source += [chr(i) for i in range(97, 97 + 26)] alphabet = ''.join(source) transforms = Compose([ToTensor()]) img = img_loader('captcha_test/captcha_crop.png') img = transforms(img) cnn = CNN() if torch.cuda.is_available(): cnn = cnn.cuda() cnn.load_state_dict(torch.load(model_path)) print("---------") img = img.view(1, 3, 36, 120).cuda() output = cnn(img) output = output.view(-1, 36) output = nn.functional.softmax(output, dim=1) output = torch.argmax(output, dim=1) output = output.view(-1, num_class)[0] pred = ''.join([alphabet[i] for i in output.cpu().numpy()]) print(pred)
# ============================================================================= # SET TRAINING PARAMETER # ============================================================================= n_epochs = 5000 batch_size_train = 32 batch_size_test = 1000 learning_rate = 0.01 momentum = 0.5 weight_decay = .001 random_seed = 1 torch.backends.cudnn.enabled = True torch.manual_seed(random_seed) network = CNN() network.cuda() gpu_available = "GPU available?: " + str(torch.cuda.is_available()) using_cuda = "Network using cuda?: " + str(next(network.parameters()).is_cuda) print(gpu_available) print(using_cuda) logging.info("\n\n------------------------------------------------------") logging.info(gpu_available) logging.info(using_cuda) logging.info(\ f"""\n\nNetwork Details: n_epochs = {n_epochs} batch_size_train = {batch_size_train}
fname = "models/gsCNN_" + args.data + str(args.kernelg) + "_" + str( args.kernels) + "_" + str(args.num_filters) + "_" + str( args.batch_size) + "_" + str(args.rate) + ".model" elif args.model == "gmsCNN": model = gmsCNN(kernelg=args.kernelg, kernels=args.kernels, kernel=args.kernel, num_filters=args.num_filters, rate=args.rate) fname = "models/gmsCNN_" + args.data + str(args.kernel) + "_" + str( args.kernelg) + "_" + str(args.kernels) + "_" + str( args.num_filters) + "_" + str(args.batch_size) + "_" + str( args.rate) + ".model" if args.gpu: model = model.cuda() # Training setup L = t.nn.CrossEntropyLoss() optimizer = t.optim.Adam(model.parameters(), lr=args.learn_rate) if not os.path.exists("models"): os.makedirs("models") # load to continue with pre-existing model if os.path.exists(fname): model.load_state_dict(t.load(fname)) print("Successfully loaded previous model " + str(fname)) # start with a model defined on 0 # train_mix, test, train_data, train_labels = dataFetch()
params = {'LR': LR, 'VOCAB_SIZE': VOCAB_SIZE, 'NO_WORD_EMBEDDINGS': NO_WORD_EMBEDDINGS, 'HIDDEN_SIZE': HIDDEN_SIZE, 'BATCH_SIZE': BATCH_SIZE, 'NUM_LAYERS': NUM_LAYERS, 'train_imagepaths_and_captions': train_imagepaths_and_captions, 'val_imagepaths_and_captions': val_imagepaths_and_captions, 'pretrained_cnn_dir': pretrained_cnn_dir, 'pretrained_word_embeddings_file': pretrained_word_embeddings_file, 'transform_train': transform_train, 'transform_val': transform_val, 'WEIGHT_DECAY': WEIGHT_DECAY, 'ADAM_FLAG': ADAM_FLAG, 'RNN_DROPOUT':RNN_DROPOUT, 'CNN_DROPOUT': CNN_DROPOUT, 'GRAD_CLIP': GRAD_CLIP} print('Initializing models...') encoder = CNN(NO_WORD_EMBEDDINGS, pretrained_cnn_dir, freeze=True, dropout_prob=CNN_DROPOUT, model_name='resnet152') decoder = RNN(VOCAB_SIZE, NO_WORD_EMBEDDINGS, hidden_size=HIDDEN_SIZE, num_layers=NUM_LAYERS, pre_trained_file=pretrained_word_embeddings_file, freeze=False, dropout_prob=RNN_DROPOUT) params['encoder'] = encoder params['decoder'] = decoder encoder.cuda() decoder.cuda() print('Initializing optimizer...') model_paras = list(encoder.parameters()) + list(decoder.parameters()) optimizer = optim.Adam(model_paras, lr=LR, weight_decay=WEIGHT_DECAY) params['optimizer'] = optimizer pickle.dump(params, open(init_params_file, 'wb')) # initialize accumulators. current_epoch = 1 batch_step_count = 1 time_used_global = 0.0
def train(): transforms = Compose([ToTensor()]) train_dataset = CaptchaData('./data/train', transform=transforms) train_data_loader = DataLoader(train_dataset, batch_size=batch_size, num_workers=0, shuffle=True, drop_last=True) test_data = CaptchaData('./data/test', transform=transforms) test_data_loader = DataLoader(test_data, batch_size=batch_size, num_workers=0, shuffle=True, drop_last=True) cnn = CNN() if torch.cuda.is_available(): cnn.cuda() if restor: cnn.load_state_dict(torch.load(model_path)) # freezing_layers = list(cnn.named_parameters())[:10] # for param in freezing_layers: # param[1].requires_grad = False # print('freezing layer:', param[0]) optimizer = torch.optim.Adam(cnn.parameters(), lr=base_lr) criterion = nn.MultiLabelSoftMarginLoss() for epoch in range(max_epoch): start_ = time.time() loss_history = [] acc_history = [] cnn.train() for img, target in train_data_loader: img = Variable(img) target = Variable(target) if torch.cuda.is_available(): img = img.cuda() target = target.cuda() output = cnn(img) loss = criterion(output, target) optimizer.zero_grad() loss.backward() optimizer.step() acc = calculat_acc(output, target) acc_history.append(acc) loss_history.append(loss) print('train_loss: {:.4}|train_acc: {:.4}'.format( torch.mean(torch.Tensor(loss_history)), torch.mean(torch.Tensor(acc_history)), )) loss_history = [] acc_history = [] cnn.eval() for img, target in test_data_loader: img = Variable(img) target = Variable(target) if torch.cuda.is_available(): img = img.cuda() target = target.cuda() output = cnn(img) acc = calculat_acc(output, target) acc_history.append(acc) loss_history.append(float(loss)) print('test_loss: {:.4}|test_acc: {:.4}'.format( torch.mean(torch.Tensor(loss_history)), torch.mean(torch.Tensor(acc_history)), )) print('epoch: {}|time: {:.4f}'.format(epoch, time.time() - start_)) torch.save(cnn.state_dict(), model_path)
class TextClassifier: def __init__(self, paths, batch_size=6, iterations=50, initial_lr=0.003, hidden_size=256, dropout=0.2, kernel_sz=3): self.use_cuda = torch.cuda.is_available() self.device = torch.device('cuda:0' if self.use_cuda else 'cpu') self.data = DataReader(paths) self.data.set_training_data(batch_size, ('cuda:0' if self.use_cuda else 'cpu')) self.train_batch_loader = BatchGenerator(self.data.train_data, 'Sentence', 'Label') self.val_batch_loader = BatchGenerator(self.data.val_data, 'Sentence', 'Label') self.test_batch_loader = BatchGenerator(self.data.test_data, 'Sentence', 'Label') # Store hyperparameters self.batch_size = batch_size self.iterations = iterations self.initial_lr = initial_lr self.kernel_sz = kernel_sz # Create Model emb_size, emb_dim = self.data.TEXT.vocab.vectors.size() self.cnn_model = CNN(emb_size=emb_size, emb_dimension=emb_dim, n_out=len(self.data.LABEL.vocab), dropout=dropout, kernel_sz=kernel_sz, stride=1, padding=0, out_filters=hidden_size, pretrained_emb=self.data.TEXT.vocab.vectors) if self.use_cuda: self.cnn_model.cuda() def train(self): train_loss_hist = [] val_loss_hist = [] train_acc_hist = [] val_acc_hist = [] test_acc_hist = [] loss = 0.0 best_model = 0.0 for itr in range(self.iterations): print("\nIteration: " + str(itr + 1)) optimizer = optim.SGD(self.cnn_model.parameters(), lr=self.initial_lr) self.cnn_model.train() total_loss = 0.0 total_acc = 0.0 steps = 0 data_iter = iter(self.train_batch_loader) # For some reason using for loop on iterator (next) is missing the target variable (y) # Have to loop over the length and retrieve the batch_data inside the loop for i in range(len(self.train_batch_loader)): ((x_batch, x_len_batch), y_batch) = next(data_iter) # if torch.min(x_len_batch) > self.kernel_sz: optimizer.zero_grad() loss, logits = self.cnn_model.forward(x_batch, y_batch) acc = torch.sum(torch.argmax(logits, dim=1) == y_batch) total_loss += loss.item() total_acc += acc.item() steps += 1 loss.backward() optimizer.step() train_loss_hist.append(total_loss / steps) train_acc_hist.append(total_acc / len(self.data.trainds)) val_loss, val_acc = self.eval_model(self.val_batch_loader, len(self.data.valds)) val_loss_hist.append(val_loss) val_acc_hist.append(val_acc) if best_model < val_acc: best_model = val_acc test_loss, test_acc = self.eval_model(self.test_batch_loader, len(self.data.testds)) print("Train: {Loss: " + str(total_loss / steps) + ", Acc: " + str(total_acc / len(self.data.trainds)) + " }") print("Val: {Loss: " + str(val_loss) + ", Acc: " + str(val_acc) + " }") # test_loss, test_acc = self.eval_model(self.test_batch_loader, len(self.data.testds) ) test_acc_hist.append(test_acc) return train_loss_hist, train_acc_hist, val_loss_hist, val_acc_hist, test_acc def eval_model(self, batch_loader, N): self.cnn_model.eval() total_loss = 0.0 total_acc = 0.0 steps = 0 batch_iter = iter(batch_loader) with torch.no_grad(): for i in range(len(batch_loader)): ((x_batch, x_len_batch), y_batch) = next(batch_iter) loss, logits = self.cnn_model(x_batch, y_batch) acc = torch.sum(torch.argmax(logits, dim=1) == y_batch) total_loss += loss.item() total_acc += acc.item() steps += 1 return (total_loss / steps), (total_acc / N)