def main(): logging.basicConfig(filename='log/experiment_spatial.log', level=logging.INFO) logging.info("Start training image network: {}".format( time.asctime(time.localtime(time.time())))) ctx = mx.gpu(0) classes_labels, train_videos_classes, test_videos_classes = get_ucf101_split( ucf.split_dir, ucf.split_id) #videos = list(test_videos_classes.keys()) #sample_videos= random.sample(videos, 500) #test_videos_classes_samples = {} #for video in sample_videos: # test_videos_classes_samples[video] = test_videos_classes[video] cm = ConvNet(model_params=resnet_50, data_params=ucf.image, train_params=train_image, test_params=test_image, train_videos_classes=train_videos_classes, test_videos_classes=test_videos_classes, classes_labels=classes_labels, num_classes=ucf.num_classes, ctx=ctx, mode='spatial') cm.train() return
def normal_train(args, loader_train, loader_test, dtype): model = ConvNet() model = model.type(dtype) model.train() loss_f = nn.CrossEntropyLoss() SCHEDULE_EPOCHS = [15] learning_rate = 0.01 for num_epochs in SCHEDULE_EPOCHS: print('\nTraining %d epochs with learning rate %.4f' % (num_epochs, learning_rate)) optimizer = optim.Adam(model.parameters(), lr=learning_rate) for epoch in range(num_epochs): print('\nTraining epoch %d / %d ...\n' % (epoch + 1, num_epochs)) # print(model.training) for i, (X_, y_) in enumerate(loader_train): X = Variable(X_.type(dtype), requires_grad=False) y = Variable(y_.type(dtype), requires_grad=False).long() preds = model(X) loss = loss_f(preds, y) if (i + 1) % args.print_every == 0: print('Batch %d done, loss = %.7f' % (i + 1, loss.item())) optimizer.zero_grad() loss.backward() optimizer.step() print('Batch %d done, loss = %.7f' % (i + 1, loss.item())) test(model, loader_test, dtype) learning_rate *= 0.1 return model
def unrolled(args, loader_train, loader_test, dtype): model = ConvNet() model = model.type(dtype) model.train() SCHEDULE_EPOCHS = [50, 50] learning_rate = 5e-4 for num_epochs in SCHEDULE_EPOCHS: print('\nTraining %d epochs with learning rate %.7f' % (num_epochs, learning_rate)) optimizer = optim.Adam(model.parameters(), lr=learning_rate) for epoch in range(num_epochs): print('\nTraining epoch %d / %d ...\n' % (epoch + 1, num_epochs)) # print(model.training) for i, (X_, y_) in enumerate(loader_train): X = Variable(X_.type(dtype), requires_grad=False) y = Variable(y_.type(dtype), requires_grad=False) loss = cw_train_unrolled(model, X, y, dtype) optimizer.zero_grad() loss.backward() optimizer.step() if (i + 1) % args.print_every == 0: print('Batch %d done, loss = %.7f' % (i + 1, loss.item())) test(model, loader_test, dtype) print('Batch %d done, loss = %.7f' % (i + 1, loss.item())) learning_rate *= 0.1 return model
class Training: def __init__(self, epoch, learningRate, batchSize, imageSize, L2Rate, trainPath): super(Training, self).__init__() self.epoch = epoch self.learningRate = learningRate self.batchSize = batchSize self.imageSize = imageSize self.L2Rate = L2Rate self.trainPath = trainPath self.data_size = calculate_data_size(self.trainPath) self.num_batches = self.data_size // batchSize self.data_loader = run_loader('train', trainPath, batchSize, imageSize, shuffle=True) self.model = ConvNet(10) self.train() def train(self): self.model.train() crossentropy = torch.nn.CrossEntropyLoss() optimizer = torch.optim.Adam(self.model.parameters(), lr=self.learningRate, weight_decay=self.L2Rate) for epoch in range(self.epoch): epoch_loss = 0 epoch_acc = 0 for X, y in tqdm(self.data_loader): optimizer.zero_grad() out = self.model(X) loss = crossentropy(out, y) loss.backward() optimizer.step() epoch_loss += loss.item() # makes it to python float predictions = torch.argmax(out, 1) epoch_acc += torch.sum(predictions == y).item() epoch_loss = epoch_loss / self.num_batches epoch_acc = epoch_acc / self.data_size print(f"Epoch {epoch}:", "ACC:", epoch_acc, "LOSS:", epoch_loss) torch.save(self.model.state_dict(), f"Trained/Model_{epoch}.model")
# train loop # use k-fold validation k_fold = 10 fold_size = int(train_data_size // k_fold) for i in range(k_fold): # split data into train/val val_data_curr_fold = train_data[i * fold_size:(i + 1) * fold_size] train_data_curr_fold_head = train_data[:i * fold_size] train_data_curr_fold_tail = train_data[(i + 1) * fold_size:] train_data_curr_fold = np.concatenate( (train_data_curr_fold_head, train_data_curr_fold_tail)) # epoch model = model.train() for curr_epoch in range(epoch): # train minibatch train_pred = [] train_data_curr_fold = train_data_curr_fold[np.random.permutation( len(train_data_curr_fold))] for b in minibatch(train_data_curr_fold, batch_size): train_batch_pred = train_batch(model, criterion, optimizer, b) train_pred.append(train_batch_pred) train_pred = np.concatenate(train_pred, axis=0) val_pred = [] for b in minibatch(val_data_curr_fold, batch_size): val_batch_pred = val_batch(model, criterion, optimizer, b) val_pred.append(val_batch_pred)
model = ConvNet() if torch.cuda.is_available(): model = model.cuda() summary(model, input_size=(3, 640, 640), device='cuda') else: summary(model, input_size=(3, 640, 640), device='cpu') # model.load_state_dict(torch.load('no_gassuion_epoch35.pth')) criterion = MultiBranchLoss(input_size=(640, 640), writer=writer, obj_scale=obj_scale, nobj_scale=nobj_scale, loc_scale=loc_scale) optimizer = Adam(model.parameters(), lr=learing_rate) batchs_loss = 0 for epoch in range(epochs): model.train() dataset = WIDERFaceDetection(WIDERFace_ROOT, transform=SSDAugmentation(640, (127.5, 127.5, 127.5))) dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True, collate_fn=collate_fn) for i, (images, labels) in enumerate(dataloader): batch_num = epoch * len(dataloader) + i + 1 optimizer.zero_grad() if torch.cuda.is_available(): images = images.cuda() outputs = model(images) loss = criterion(outputs, labels, batch_num) batchs_loss += loss.item() loss.backward() optimizer.step() if batch_num % show_iter == 0: average_loss = batchs_loss / show_iter print("epoch {} batch {}:".format(epoch, i))
outputs = net(images) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() return correct / total net = ConvNet().to(device) criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9) mt = MetricTracker() for epoch in range(EPOCHS): net.train() running_loss = 0.0 for i, (inputs, labels) in enumerate(trainloader): inputs, labels = inputs.to(device), labels.to(device) # zero the parameter gradients optimizer.zero_grad() # forward + backward + optimize outputs = net(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() # print statistics