def train_encoder(): from AutoEncoder import AutoEncoder device = torch.device("cuda") enc = AutoEncoder(3).to(device) criterion = nn.MSELoss() optimizer = optim.Adam(enc.parameters(), lr=ETA) loader = get_cifar10() for e in range(EPOCHS): train_loss = 0.0 for images, _, in loader: images = images.to(device) _, decoded = enc(images) assert (decoded.size() == images.size()) loss = criterion(decoded, images) train_loss += loss.item() optimizer.zero_grad() loss.backward() optimizer.step() train_loss /= len(loader) print(f"Epochs {e+1}/{EPOCHS}") print(f"Loss: {train_loss:.8f}") enc.save("ckpts/encoder_test.pth")
#if os.path.exists('./AutoEncoder.pth'): # model.load_state_dict(torch.load('/home/so1463/LearningToPaint/baseline/AutoEncoder.pth')) # Define our RNN model RNN = RNN().to(device) # Freeze weights of the renderer renderer = FCN().to(device) renderer.load_state_dict(torch.load(args.renderer)) renderer = renderer.to(device).eval() for p in renderer.parameters(): p.requires_grad = True # Define optimizer and loss function optimizer = optim.Adam(encoder.parameters(), lr=learning_rate) criterion = nn.MSELoss(reduction='sum') loss_plot = [] ############################################################################### ################################# # Training ###################### ################################# imgid = 1 for epoch in range(num_epochs): # each training epoch for data in dataloader: # for each image image, _=data
torchvision.transforms.ToTensor(), # torchvision.transforms.Normalize(0, 1), ]) train_data = torchvision.datasets.MNIST( root='/home/slcheng/AutoEncoder/mnist', train=True, transform=transform, download=DOWNLOAD_MNIST, ) trian_loader = Data.DataLoader(dataset=train_data, batch_size=args.batch_size, shuffle=True) # load model auotencoder = AutoEncoder() optimizer = torch.optim.Adam(auotencoder.parameters(), lr=args.learning_rate) mse_loss = nn.MSELoss() # traning process def train(): fig, ax = plt.subplots(2, N) ln, = plt.plot([], [], animated=True) # randomly sample N images to visualize train_num = train_data.data.shape[0] random.seed(train_num) slice = random.sample(list(range(0, train_num)), N) origin_image = torch.empty(N, 28 * 28) for i in range(N): origin_image[i] = train_data.train_data[slice[i]].view(-1, 28*28)\
N = 400 D = 20 L = 9 R = np.array(np.random.rand(N, L) > .5, dtype=np.float32) # train_loader = torch.utils.data.DataLoader( # datasets.MNIST('../data', train=True, download=True, # transform=transforms.ToTensor()), # batch_size=args.batch_size, shuffle=True, **kwargs) # test_loader = torch.utils.data.DataLoader( # datasets.MNIST('../data', train=False, transform=transforms.ToTensor()), # batch_size=args.batch_size, shuffle=True, **kwargs) # model = VAE().to(device) model = AutoEncoder(9, 3).to(device) optimizer = optim.Adam(model.parameters(), lr=1e-3) # Reconstruction + KL divergence losses summed over all elements and batch def loss_function(recon_x, x): BCE = F.binary_cross_entropy(recon_x, x, size_average=False) # see Appendix B from VAE paper: # Kingma and Welling. Auto-Encoding Variational Bayes. ICLR, 2014 # https://arxiv.org/abs/1312.6114 # 0.5 * sum(1 + log(sigma^2) - mu^2 - sigma^2) # KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp()) return BCE
if __name__ == '__main__': if __DEBUG__ == True: print(DEVICE) train = get_dataset() if False: print("Showing Random images from dataset") showRandomImaged(train) model = AutoEncoder().cuda() if torch.cuda.is_available() else AutoEncoder( ) if __DEBUG__ == True: print(model) criterian = nn.MSELoss() optimizer = torch.optim.Adam(model.parameters(), weight_decay=1e-5) if LOAD == True: model.load_state_dict(torch.load(PATH)) for epoch in range(EPOCHS): for i, (images, _) in enumerate(train): images = images.to(DEVICE) out = model(images) loss = criterian(out, images) optimizer.zero_grad() loss.backward() optimizer.step() ## LOG print(f"epoch {epoch}/{EPOCHS}\nLoss : {loss.data}")
model = AutoEncoder().to(device) #if os.path.exists('./AutoEncoder.pth'): # model.load_state_dict(torch.load('/home/so1463/LearningToPaint/baseline/AutoEncoder.pth')) ############################### # or use the with no_grad block in our loop when we call the save_image function # Freeze weights of the renderer renderer = FCN().to(device) renderer.load_state_dict(torch.load(args.renderer)) renderer = renderer.to(device).eval() for p in renderer.parameters(): p.requires_grad = True # Define optimizer and loss function optimizer = optim.Adam(model.parameters(), lr=learning_rate) criterion = nn.MSELoss(reduction='sum') loss_plot = [] ############################################################################### ################################# # Training ###################### ################################# imgid = 1 for epoch in range(num_epochs): # each training epoch for data in dataloader: # for each image optimizer.zero_grad() # zeros the gradient, must do every iteration image, _ = data