print('LR --> 0.0000001, WD = 0.0. Resume fine-tuning CNN.') criterion = nn.CrossEntropyLoss() print('Loading dataset...') trainset = MSCOCO(VOCAB_SIZE, train_imagepaths_and_captions, transform_train) trainloader = torch.utils.data.DataLoader(dataset=trainset, batch_size=BATCH_SIZE, collate_fn=collate_fn, shuffle=True, drop_last=False, num_workers=NUM_WORKERS) valset = MSCOCO_VAL(VOCAB_SIZE, val_imagepaths_and_captions, transform_val) valloader = torch.utils.data.DataLoader(dataset=valset, batch_size=BATCH_SIZE, collate_fn=collate_fn_val, shuffle=False, drop_last=False, num_workers=NUM_WORKERS) writer = SummaryWriter(log_dir) for epoch in range(current_epoch, EPOCHS+1): start_time_epoch = time.time() encoder.train() decoder.train() print('[%d] epoch starts training...'%epoch) trainloss = 0.0 for batch_idx, (images, captions, lengths) in enumerate(trainloader, 1): images = images.cuda() captions = captions.cuda() lengths = lengths.cuda() # when doing forward propagation, we do not input end word key; when calculating loss, we do not count start word key. lengths -= 1 # throw out the start word key when calculating loss. targets = rnn_utils.pack_padded_sequence(captions[:, 1:], lengths, batch_first=True)[0] encoder.zero_grad()
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 Solver(object): def __init__(self, config, data_loader): self.config = config self.data_loader = data_loader def build(self, is_train): self.model = CNN(self.config) self.loss_fn = self.config.loss_fn() if is_train: self.model.train() self.optimizer = self.config.optimizer(self.model.parameters(), lr=self.config.lr) else: self.model.eval() def train(self): for epoch in tqdm(range(self.config.epochs)): loss_history = [] for batch_i, batch in enumerate(tqdm(self.data_loader)): # text: [max_seq_len, batch_size] # label: [batch_size] text, label = batch.text, batch.label # [batch_size, max_seq_len] text.data.t_() # [batch_size, 2] logit = self.model(text) # Calculate loss average_batch_loss = self.loss_fn(logit, label) # [1] loss_history.append( average_batch_loss.data[0]) # Variable -> Tensor # Flush out remaining gradient self.optimizer.zero_grad() # Backpropagation average_batch_loss.backward() # Gradient descent self.optimizer.step() # Log intermediate loss if (epoch + 1) % self.config.log_every_epoch == 0: epoch_loss = np.mean(loss_history) log_str = f'Epoch {epoch + 1} | loss: {epoch_loss:.2f}\n' print(log_str) # Save model parameters if (epoch + 1) % self.config.save_every_epoch == 0: ckpt_path = os.path.join(self.config.save_dir, f'epoch-{epoch+1}.pkl') print('Save parameters at ', ckpt_path) torch.save(self.model.state_dict(), ckpt_path) def eval(self, epoch=None): # Load model parameters if not isinstance(epoch, int): epoch = self.config.epochs ckpt_path = os.path.join(self.config.save_dir, f'epoch-{epoch}.pkl') print('Load parameters from ', ckpt_path) self.model.load_state_dict(torch.load(ckpt_path)) loss_history = [] for _, batch in tqdm(enumerate(self.data_loader)): # text: [max_seq_len, batch_size] # label: [batch_size] text, label = batch.text, batch.label # [batch_size, max_seq_len] text.data.t_() # [batch_size, 2] logit = self.model(text) # Calculate loss average_batch_loss = self.loss_fn(logit, label) # [1] loss_history.append( average_batch_loss.data[0]) # Variable -> Tensor epoch_loss = np.mean(loss_history) print('Loss: {epoch_loss:.2f}')
class Solver(object): def __init__(self, config, data_loader): self.config = config self.data_loader = data_loader def build(self, is_train): if torch.cuda.is_available(): self.model = nn.DataParallel(CNN(self.config)).cuda() else: self.model = CNN(self.config) self.loss_fn = self.config.loss_fn() if is_train: self.model.train() self.optimizer = self.config.optimizer(self.model.parameters(), lr=self.config.lr) else: if torch.cuda.is_available(): self.model = self.model.module self.model.eval() def save(self, ckpt_path): """Save model parameters""" print('Save parameters at ', ckpt_path) if torch.cuda.is_available(): torch.save(self.model.module.state_dict(), ckpt_path) else: torch.save(self.model.state_dict(), ckpt_path) def load(self, ckpt_path=None, epoch=None): """Load model parameters""" if not (ckpt_path or epoch): epoch = self.config.epochs if epoch: ckpt_path = os.path.join(self.config.save_dir, f'epoch-{epoch}.pkl') print('Load parameters from ', ckpt_path) print (self.model) self.model.load_state_dict(torch.load(ckpt_path)) def train_once(self): loss_history = [] for batch_i, batch in enumerate(tqdm(self.data_loader)): text, label = batch.text, batch.label if torch.cuda.is_available(): text = text.cuda() label = label.cuda() text.data.t_() logit = self.model(text) average_batch_loss = self.loss_fn(logit, label) loss_history.append(average_batch_loss.item()) self.optimizer.zero_grad() average_batch_loss.backward() self.optimizer.step() epoch_loss = np.mean(loss_history) return epoch_loss def train(self): """Train model with training data""" for epoch in tqdm(range(self.config.epochs)): loss_history = [] for batch_i, batch in enumerate(tqdm(self.data_loader)): # text: [max_seq_len, batch_size] # label: [batch_size] text, label = batch.text, batch.label if torch.cuda.is_available(): text = text.cuda() label = label.cuda() # [batch_size, max_seq_len] text.data.t_() # [batch_size, 2] logit = self.model(text) # Calculate loss average_batch_loss = self.loss_fn(logit, label) # [1] loss_history.append(average_batch_loss.item()) # Variable -> Tensor # Flush out remaining gradient self.optimizer.zero_grad() # Backpropagation average_batch_loss.backward() # Gradient descent self.optimizer.step() # Log intermediate loss if (epoch + 1) % self.config.log_every_epoch == 0: epoch_loss = np.mean(loss_history) log_str = f'Epoch {epoch + 1} | loss: {epoch_loss:.4f}\n' print(log_str) # Save model parameters if (epoch + 1) % self.config.save_every_epoch == 0: ckpt_path = os.path.join(self.config.save_dir, f'epoch-{epoch+1}.pkl') self.save(ckpt_path) def eval(self): """Evaluate model from text data""" n_total_data = 0 n_correct = 0 loss_history = [] ''' import ipdb ipdb.set_trace() ''' for _, batch in enumerate(tqdm(self.data_loader)): # text: [max_seq_len, batch_size] # label: [batch_size] text, label = batch.text, batch.label if torch.cuda.is_available(): text = text.cuda() label = label.cuda() # [batch_size, max_seq_len] text.data.t_() # [batch_size, 2] logit = self.model(text) # Calculate loss average_batch_loss = self.loss_fn(logit, label) # [1] loss_history.append(average_batch_loss.item()) # Variable -> Tensor # Calculate accuracy n_total_data += len(label) # [batch_size] _, prediction = logit.max(1) n_correct += (prediction == label).sum().data epoch_loss = np.mean(loss_history) accuracy = n_correct.item() / float(n_total_data) print(f'Loss: {epoch_loss:.2f}') print(f'Accuracy: {accuracy}') return epoch_loss, accuracy def inference(self, text): text = Variable(torch.LongTensor([text])) # [batch_size, 2] logit = self.model(text) _, prediction = torch.max(logit) return prediction def train_eval(self): # Set this variable to your MLflow server's DNS name mlflow_server = '172.23.147.124' # Tracking URI mlflow_tracking_URI = 'http://' + mlflow_server + ':5000' print ("MLflow Tracking URI: %s" % (mlflow_tracking_URI)) with mlflow.start_run(): for key, value in vars(self.config).items(): mlflow.log_param(key, value) ''' output_dir = 'mlflow_logs' if not os.path.exists(output_dir): os.mkdir(output_dir) ''' for epoch in tqdm(range(self.config.epochs)): # print out active_run print("Active Run ID: %s, Epoch: %s \n" % (mlflow.active_run(), epoch)) train_loss = self.train_once() mlflow.log_metric('train_loss', train_loss) val_loss, val_acc = self.eval() mlflow.log_metric('val_loss', val_loss) mlflow.log_metric('val_acc', val_acc) # Finish run mlflow.end_run(status='FINISHED')
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)
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)))
class Solver(object): def __init__(self, config, data_loader): self.config = config self.data_loader = data_loader def build(self, is_train): self.model = CNN(self.config) self.loss_fn = self.config.loss_fn() if is_train: self.model.train() self.optimizer = self.config.optimizer(self.model.parameters(), lr=self.config.lr) else: self.model.eval() def save(self, ckpt_path): """Save model parameters""" print('Save parameters at ', ckpt_path) torch.save(self.model.state_dict(), ckpt_path) def load(self, ckpt_path=None, epoch=None): """Load model parameters""" if not (ckpt_path or epoch): epoch = self.config.epochs if epoch: ckpt_path = os.path.join(self.config.save_dir, f'epoch-{epoch}.pkl') print('Load parameters from ', ckpt_path) self.model.load_state_dict(torch.load(ckpt_path)) def train(self): """Train model with training data""" for epoch in tqdm(range(self.config.epochs)): loss_history = [] for batch_i, batch in enumerate(tqdm(self.data_loader)): # text: [max_seq_len, batch_size] # label: [batch_size] text, label = batch.text, batch.label # [batch_size, max_seq_len] text.data.t_() # [batch_size, 2] logit = self.model(text) # Calculate loss average_batch_loss = self.loss_fn(logit, label) # [1] loss_history.append(average_batch_loss.data[0]) # Variable -> Tensor # Flush out remaining gradient self.optimizer.zero_grad() # Backpropagation average_batch_loss.backward() # Gradient descent self.optimizer.step() # Log intermediate loss if (epoch + 1) % self.config.log_every_epoch == 0: epoch_loss = np.mean(loss_history) log_str = f'Epoch {epoch + 1} | loss: {epoch_loss:.2f}\n' print(log_str) # Save model parameters if (epoch + 1) % self.config.save_every_epoch == 0: ckpt_path = os.path.join(self.config.save_dir, f'epoch-{epoch+1}.pkl') self.save(ckpt_path) def eval(self): """Evaluate model from text data""" n_total_data = 0 n_correct = 0 loss_history = [] import ipdb ipdb.set_trace() for _, batch in enumerate(tqdm(self.data_loader)): # text: [max_seq_len, batch_size] # label: [batch_size] text, label = batch.text, batch.label # [batch_size, max_seq_len] text.data.t_() # [batch_size, 2] logit = self.model(text) # Calculate loss average_batch_loss = self.loss_fn(logit, label) # [1] loss_history.append(average_batch_loss.data[0]) # Variable -> Tensor # Calculate accuracy n_total_data += len(label) # [batch_size] _, prediction = logit.max(1) n_correct += (prediction == label).sum().data epoch_loss = np.mean(loss_history) accuracy = n_correct / n_total_data print(f'Loss: {epoch_loss:.2f}') print(f'Accuracy: {accuracy}') def inference(self, text): text = Variable(torch.LongTensor([text])) # [batch_size, 2] logit = self.model(text) _, prediction = torch.max(logit) return prediction
class Trainer: """ 训练 """ def __init__(self, _hparams): utils.set_seed(_hparams.fixed_seed) self.train_loader = get_train_loader(_hparams) self.val_loader = get_val_loader(_hparams) self.encoder = CNN().to(DEVICE) self.decoder = RNN(fea_dim=_hparams.fea_dim, embed_dim=_hparams.embed_dim, hid_dim=_hparams.hid_dim, max_sen_len=_hparams.max_sen_len, vocab_pkl=_hparams.vocab_pkl).to(DEVICE) self.loss_fn = nn.CrossEntropyLoss() self.optimizer = torch.optim.Adam(self.get_params(), lr=_hparams.lr) self.writer = SummaryWriter() self.max_sen_len = _hparams.max_sen_len self.val_cap = _hparams.val_cap self.ft_encoder_lr = _hparams.ft_encoder_lr self.ft_decoder_lr = _hparams.ft_decoder_lr self.best_CIDEr = 0 def fine_tune_encoder(self, fine_tune_epochs, val_interval, save_path, val_path): print('*' * 20, 'fine tune encoder for', fine_tune_epochs, 'epochs', '*' * 20) self.encoder.fine_tune() self.optimizer = torch.optim.Adam([ { 'params': self.encoder.parameters(), 'lr': self.ft_encoder_lr }, { 'params': self.decoder.parameters(), 'lr': self.ft_decoder_lr }, ]) self.training(fine_tune_epochs, val_interval, save_path, val_path) self.encoder.froze() print('*' * 20, 'fine tune encoder complete', '*' * 20) def get_params(self): """ 模型需要优化的全部参数,此处encoder暂时设计不用训练,故不加参数 :return: """ return list(self.decoder.parameters()) def training(self, max_epochs, val_interval, save_path, val_path): """ 训练 :param val_path: 保存验证过程生成句子的路径 :param save_path: 保存模型的地址 :param val_interval: 验证的间隔 :param max_epochs: 最大训练的轮次 :return: """ print('*' * 20, 'train', '*' * 20) for epoch in range(max_epochs): self.set_train() epoch_loss = 0 epoch_steps = len(self.train_loader) for step, (img, cap, cap_len) in tqdm(enumerate(self.train_loader)): # batch_size * 3 * 224 * 224 img = img.to(DEVICE) cap = cap.to(DEVICE) self.optimizer.zero_grad() features = self.encoder.forward(img) outputs = self.decoder.forward(features, cap) outputs = pack_padded_sequence(outputs, cap_len - 1, batch_first=True)[0] targets = pack_padded_sequence(cap[:, 1:], cap_len - 1, batch_first=True)[0] train_loss = self.loss_fn(outputs, targets) epoch_loss += train_loss.item() train_loss.backward() self.optimizer.step() epoch_loss /= epoch_steps self.writer.add_scalar('epoch_loss', epoch_loss, epoch) print('epoch_loss: {}, epoch: {}'.format(epoch_loss, epoch)) if (epoch + 1) % val_interval == 0: CIDEr = self.validating(epoch, val_path) if self.best_CIDEr <= CIDEr: self.best_CIDEr = CIDEr self.save_model(save_path, epoch) def save_model(self, save_path, train_epoch): """ 保存最好的模型 :param save_path: 保存模型文件的地址 :param train_epoch: 当前训练的轮次 :return: """ model_state_dict = { 'encoder_state_dict': self.encoder.state_dict(), 'decoder_state_dict': self.decoder.state_dict(), 'tran_epoch': train_epoch, } print('*' * 20, 'save model to: ', save_path, '*' * 20) torch.save(model_state_dict, save_path) def validating(self, train_epoch, val_path): """ 验证 :param val_path: 保存验证过程生成句子的路径 :param train_epoch: 当前训练的epoch :return: """ print('*' * 20, 'validate', '*' * 20) self.set_eval() sen_json = [] with torch.no_grad(): for val_step, (img, img_id) in tqdm(enumerate(self.val_loader)): img = img.to(DEVICE) features = self.encoder.forward(img) sens, _ = self.decoder.sample(features) sen_json.append({'image_id': int(img_id), 'caption': sens[0]}) with open(val_path, 'w') as f: json.dump(sen_json, f) result = coco_eval(self.val_cap, val_path) scores = {} for metric, score in result: scores[metric] = score self.writer.add_scalar(metric, score, train_epoch) return scores['CIDEr'] def set_train(self): self.encoder.train() self.decoder.train() def set_eval(self): self.encoder.eval() self.decoder.eval()
if __name__ == '__main__': opt = Training_options().parse() if opt.model == 'cnn': from models import CNN net = CNN(opt) train_predictors, train_predictands = assemble_predictors_predictands( opt, train=True) train_dataset = ENSODataset(train_predictors, train_predictands) trainloader = DataLoader(train_dataset, batch_size=opt.batch_size) optimizer = optim.Adam(net.parameters(), lr=opt.lr) device = "cuda:0" if torch.cuda.is_available() else "cpu" net = net.to(device) best_loss = np.infty train_losses = [] net.train() criterion = nn.MSELoss() for epoch in range(opt.epoch): running_loss = 0.0 for i, data in enumerate(trainloader): batch_predictors, batch_predictands = data batch_predictands = batch_predictands.to(device) batch_predictors = batch_predictors.to(device) optimizer.zero_grad() predictions = net(batch_predictors).squeeze() loss = criterion(predictions, batch_predictands.squeeze()) loss.backward() optimizer.step() running_loss += loss.item() print('Training Set: Epoch {:02d}. loss: {:3f}'.format( epoch+1, \ running_loss/len(trainloader)))
#create test loader test_dataset = HumanActivityDataset(file='test') test_loader = DataLoader(test_dataset, batch_size=batch_size_test, shuffle=True, num_workers=0) test_gen = iter(test_loader) #print every 't' steps t = 5 for epoch in range(n_epochs): # loop over the dataset multiple times network.train() train_loss = 0.0 for i_batch, batch in enumerate(train_loader): # get the inputs and labels inputs, labels = batch['inputs'], batch['labels'] # zero the parameter gradients optimizer.zero_grad() # forward + backward + optimize outputs = network(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step()
# shuffle=True) # test_loader = test train_data, test_data = dataFetch(dset=args.data) train_loader = t.utils.data.DataLoader(dataset=train_data, batch_size=args.batch_size, shuffle=True) test_loader = t.utils.data.DataLoader(dataset=test_data, batch_size=args.batch_size, shuffle=False) print("Starting with training process...") if not args.validate: for epoch in range(args.epochs): model.train() start = time.time() tloss = [] best = 1000 for i, (img, lbl) in enumerate(train_loader): if args.gpu: images = Variable(img).cuda() labels = Variable(lbl).cuda() else: images = Variable(img) labels = Variable(lbl) # Pass and Backpropagate #clear gradient optimizer.zero_grad() # Clear stored gradients