def main(): env_name = 'CartPole-v0' env = gym.make(env_name) action_space = env.action_space.n observation_space = env.observation_space.low.shape # set logger logging.config.fileConfig('./log/log.conf') logger = logging.getLogger(__name__) logger.info('START') # set network model shared_model = A3CFFSoftmaxFFF(observation_space, action_space) # set optimizer opt = RMSpropAsync(lr=LEARNING_RATE , alpha=0.99 , eps=RMSPROP_EPS) opt.setup(shared_model) opt.add_hook(chainer.optimizer.GradientClipping(40)) writer = SummaryWriter('results/' + datetime.datetime.now().strftime('%B%d %H:%M:%S')) state = env.reset() state = chainer.Variable(np.expand_dims(np.array(state).astype(np.float32), axis=0)) pi, v = shared_model.get_pi_and_v(state) writer.add_graph([pi, v]) writer.close() async_train(env_name, shared_model, opt, phi) logger.info('END')
return i def classification_accuracy(out, labels): # mi servono argmax _, out = torch.max(out, 1) accuracy = torch.sum(out == labels).float() accuracy /= len(out) return accuracy net = Net().cuda() writer = SummaryWriter('runs/' + datetime.now().strftime('%B%d %H:%M:%S')) writer.add_graph( net, net(Variable(torch.rand(1, 75, features_size), requires_grad=True).cuda())) loader = DataLoader(MyDataset("data/text_1", input_len=75, output_len=1), batch_size=64, shuffle=True) # net = net.cuda() optimizer = Adam(params=net.parameters(), lr=0.001) # loss loss = nn.NLLLoss() batch_number = len(loader) num_epochs = 500 logging_step = 50 logging_text_step = 1000
self.conv1 = nn.Conv2d(1, 10, kernel_size=5) self.conv2 = nn.Conv2d(10, 20, kernel_size=5) self.conv2_drop = nn.Dropout2d() self.fc1 = nn.Linear(320, 50) self.fc2 = nn.Linear(50, 10) self.bn = nn.BatchNorm2d(20) def forward(self, x): x = F.max_pool2d(self.conv1(x), 2) x = F.relu(x) + F.relu(-x) x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2)) x = self.bn(x) x = x.view(-1, 320) x = F.relu(self.fc1(x)) x = F.dropout(x, training=self.training) x = self.fc2(x) x = F.log_softmax(x) return x model = Mnist() # if you want to show the input tensor, set requires_grad=True res = model( torch.autograd.Variable(torch.Tensor(1, 1, 28, 28), requires_grad=True)) writer = SummaryWriter('runs/' + datetime.now().strftime('%B%d %H:%M:%S')) writer.add_graph(model, res) writer.close()
def train(): data_augmentation = DataAugmentationTransform_old(translation_range=(0.0, 0.15), rotation_range=10, zoom_range = (0.8, 1.0), flip_p = 0.5, brightness_range = (-0.2, 0.2), gamma_range = (0.5, 1.5), saturation_range=(-0.3, 0.3)) loader_train = CityscapesLoader(base_data_folder, split='train', is_transform=True, img_size=image_shape, transforms=None) trainloader = data.DataLoader(loader_train, batch_size=batch_size, num_workers=4, shuffle=True, pin_memory=True) if overlay_during_training: loader_test = CityscapesLoader(base_data_folder, split='test', is_transform=True, img_size=image_shape) test_loader = data.DataLoader(loader_test, batch_size=batch_size, num_workers=4, shuffle=False, pin_memory=True) if check_validation: loader_val = CityscapesLoader(base_data_folder, split='val', is_transform=True, img_size=image_shape) valloader = data.DataLoader(loader_val, batch_size=batch_size, num_workers=4, shuffle=False, pin_memory=True) model = get_model('fcn1s',num_classes) writer = SummaryWriter() if resume: print("Resuming From ",resume_filename) checkpoint = torch.load(resume_filename) model.load_state_dict(checkpoint['state_dict']) #starting_epoch = checkpoint['epoch'] #optimizer.load_state_dict(checkpoint['optimizer']) for param in model.parameters(): param.requires_grad = True if freeze_layers: print("Freezing VGG layers") for param in model.conv_block1.parameters(): param.requires_grad = False for param in model.conv_block2.parameters(): param.requires_grad = False for param in model.conv_block3.parameters(): param.requires_grad = False for param in model.conv_block4.parameters(): param.requires_grad = False for param in model.conv_block5.parameters(): param.requires_grad = False if torch.cuda.is_available(): print("Using GPU") model.cuda(0) else: print("Using CPU") model.train() parameters = filter(lambda p: p.requires_grad, model.parameters()) if opt == "SGD": optimizer = torch.optim.SGD(parameters, lr=l_rate, momentum=0.9, weight_decay=5e-4) elif opt =="Adam": optimizer = torch.optim.Adam(parameters, lr=l_rate, weight_decay=5e-4) best_metric = 0 old_file = "" for epoch in range(starting_epoch, epochs): train_acc = 0 train_IoU = 0 train_loss = 0 train_count = 0 print("\nEpoch: ",epoch) if overlay_during_training and epoch % 5 == 0: test_img = loader_test[67] test_img = test_img.unsqueeze(0) model.eval() test_pred = model(Variable(test_img.cuda(0), requires_grad=True)) test_img = Variable(test_img.cuda(0), requires_grad=True) overlay_images(test_img, test_pred, epoch, '67_') writer.add_graph(model, test_pred) del test_pred del test_img test_img = loader_test[88] test_img = test_img.unsqueeze(0) test_pred = model(Variable(test_img.cuda(0), requires_grad=True)) test_img = Variable(test_img.cuda(0), requires_grad=True) overlay_images(test_img, test_pred, epoch, '88_') del test_pred del test_img test_img = loader_test[175] test_img = test_img.unsqueeze(0) test_pred = model(Variable(test_img.cuda(0), requires_grad=True)) test_img = Variable(test_img.cuda(0), requires_grad=True) overlay_images(test_img, test_pred, epoch, '175_') del test_pred del test_img model.train() with tqdm.tqdm(trainloader, ncols=100) as t: for i, (images, labels) in enumerate(t): if torch.cuda.is_available(): images = Variable(images.cuda(0)) labels = Variable(labels.cuda(0)) else: images = Variable(images) labels = Variable(labels) iter = len(trainloader) * epoch + i if poly_lr: poly_lr_scheduler(optimizer, l_rate, iter, lr_decay_iter=10) optimizer.zero_grad() outputs = model(images) loss = cross_entropy2d(outputs, labels, ignore_index=255) loss.backward() optimizer.step() #print("%8.2f %% -> Loss: %8.6f " % (i / len(trainloader) * 100, loss.data[0]), end='\r') t.set_description('Loss: %8.6f' % loss.data[0]) t.update(1) train_loss = train_loss + loss.data[0] acc, IoU = accuracy_IoU(outputs,labels, np.array(range(num_classes))) train_acc = train_acc + acc train_IoU = train_IoU + IoU.mean() train_count = train_count + 1 del outputs del loss del images del labels train_acc = train_acc / train_count train_IoU = train_IoU / train_count train_loss = train_loss / train_count print("\nTrain Accuracy: ", train_acc) print("Train Loss: ", train_loss) print("Train IoU: ", train_IoU, "\n") writer.add_scalar('Train Accuracy', train_acc, epoch) writer.add_scalar('Train IoU', train_IoU, epoch) writer.add_scalar('Train Los', train_loss, epoch) if check_validation: #VALIDATION!!! val_acc = 0 val_IoU = 0 val_loss = 0 val_count = 0 model.eval() for i, (images, labels) in enumerate(valloader): if torch.cuda.is_available(): images = Variable(images.cuda(0)) labels = Variable(labels.cuda(0)) else: images = Variable(images) labels = Variable(labels) iter = len(trainloader) * epoch + i #poly_lr_scheduler(optimizer, l_rate, iter) outputs = model(images) loss = cross_entropy2d(outputs, labels, ignore_index=255) val_loss = val_loss + loss.data[0] acc, IoU = accuracy_IoU(outputs,labels, np.array(range(num_classes))) val_acc = val_acc + acc val_IoU = val_IoU + IoU.mean() val_count = val_count + 1 del outputs del loss del images del labels val_acc = val_acc / val_count val_IoU = val_IoU / val_count val_loss = val_loss / val_count print("\nVal Accuracy: ", val_acc) print("Val Loss: ", val_loss) print("Val IoU: ", val_IoU, "\n") writer.add_scalar('Val Accuracy', val_acc, epoch) writer.add_scalar('Val IoU', val_IoU, epoch) writer.add_scalar('Val Loss', val_loss, epoch) save_metric = val_IoU if check_validation: save_metric = val_IoU if best_metric < save_metric: best_metric = save_metric print("New Best IoU!") if save: torch.save({ 'epoch': epoch, 'state_dict': model.state_dict(), 'optimizer': optimizer.state_dict(), }, base_save_folder + "/checkpoint_" + str(epoch) + "_" + str(save_metric) + ".pth.tar") print("Model Saves As " + base_save_folder + "/checkpoint_" + str(epoch) + "_" + str(save_metric) + ".pth.tar") if os.path.isfile(old_file): os.remove(old_file) old_file = base_save_folder + "/checkpoint_" + str(epoch) + "_" + str(save_metric) + ".pth.tar" print("Best IoU So Far: ", best_metric) writer.close() print("End Of Training")
data_train = train_raw[0].reshape(-1, 1, 28, 28) labels_train = train_raw[1] # converto a variabili # loader loader = DataLoader(TensorDataset(torch.FloatTensor(data_train[0:]), torch.LongTensor(labels_train[0:])), batch_size=16) # loss loss = nn.NLLLoss() # due grafi? # net.batch_real = True # writer.add_graph(net, net(Variable(torch.FloatTensor(data_train[0:1]), requires_grad=True))) net.train(False) net.batch_real = False writer.add_graph(net, net(Variable(torch.randn(1,100), requires_grad=True).cuda())) batch_number = len(loader) num_epochs = 50 num_epochs_pretrain = 7 logging_step = 50 logging_image_step = 25 widgets = [ 'Batch: ', progressbar.Counter(), '/', progressbar.FormatCustomText('%(total)s', {"total": batch_number}), ' ', progressbar.Bar(marker="-", left='[', right=']'), ' ', progressbar.ETA(), ' ', progressbar.DynamicMessage('loss_discriminator'), ' ', progressbar.DynamicMessage('loss_generator'), ' ', progressbar.DynamicMessage("accuracy_discriminator"), ' ', progressbar.DynamicMessage('accuracy_generator'),
optimizer = SGD(params=net.parameters(), lr=0.01, momentum=0.85) #definisco input da numpy train_raw, _, test_raw = cPickle.load(open("data/mnist.pkl")) data_train = train_raw[0].reshape(-1, 1, 28, 28) labels_train = train_raw[1] #converto a variabili #loader loader = DataLoader(TensorDataset(torch.FloatTensor(data_train[0:]), torch.LongTensor(labels_train[0:])), batch_size=32) #loss loss = nn.NLLLoss() writer.add_graph( net, net(Variable(torch.FloatTensor(data_train[0:1]), requires_grad=True))) batch_number = len(loader) num_epochs = 10 logging_step = 50 logging_image_step = 100 widgets = [ 'Batch: ', progressbar.Counter(), '/', progressbar.FormatCustomText('%(total)s', {"total": batch_number}), ' ', progressbar.Bar(marker="-", left='[', right=']'), ' ', progressbar.ETA(), ' ',
net = Net() optimizer = SGD(params=net.parameters(), lr=0.5, momentum=0.85) #definisco input da numpy #data = numpy.random.randint(-2,2,120) data = numpy.random.randint(0, 2, (120, 2)) labels = data[:, 0:1] | data[:, 1:] #labels = to_categorical(labels,num_classes=2) #converto a variabili data = Variable(torch.FloatTensor(data), requires_grad=True) labels = Variable(torch.LongTensor(labels)).squeeze() loss = nn.NLLLoss() writer.add_graph(net, net(Variable(torch.rand(120, 2), requires_grad=True))) for i in xrange(120): #calcolo uscita out = net(data) #azzero gradiente net.zero_grad() optimizer.zero_grad() #loss loss_value = loss(out, labels) writer.add_scalar('loss_NLL', loss_value.data[0], i) #propago loss_value.backward() #adesso ho accesso al gradiente e posso aggiornare anche i pesi optimizer.step()