#!/usr/bin/env python # coding: utf-8 # Deep Learning Models -- A collection of various deep learning architectures, models, and tips for TensorFlow and PyTorch in Jupyter Notebooks. # - Author: Sebastian Raschka # - GitHub Repository: https://github.com/rasbt/deeplearning-models # In[1]: get_ipython().run_line_magic('load_ext', 'watermark') get_ipython().run_line_magic('watermark', "-a 'Sebastian Raschka' -v -p torch") # - Runs on CPU or GPU (if available) # # Convolutional Autoencoder with Deconvolutions and Continuous Jaccard Distance # A convolutional autoencoder using deconvolutional layers that compresses 768-pixel MNIST images down to a 7x7x8 (392 pixel) representation. # # # This convolutional VAE uses a continuous Jaccard distance. I.e., given 2 vectors, $x$ and $y$: # # $$J(x, y)=1-\frac{\sum_{i} \min \left(x_{i}, y_{i}\right)}{\sum_{i} \max \left(x_{i}, y_{i}\right)}$$ # Reference: # # - [1] https://en.wikipedia.org/wiki/Jaccard_index # In[2]: import torch def continuous_jaccard(x, y): """ Implementation of the continuous version of the Jaccard distance: 1 - [sum_i min(x_i, y_i)] / [sum_i max(x_i, y_i)] """ c = torch.cat((x.view(-1).unsqueeze(1), y.view(-1).unsqueeze(1)), dim=1) numerator = torch.sum(torch.min(c, dim=1)[0]) denominator = torch.sum(torch.max(c, dim=1)[0]) return 1. - numerator/denominator # Example x = torch.tensor([7, 2, 3, 4, 5, 6]).float() y = torch.tensor([1, 8, 9, 10, 11, 4]).float() continuous_jaccard(x, y) # ## Additional Imports # In[3]: import time import numpy as np import torch import torch.nn.functional as F from torch.utils.data import DataLoader from torchvision import datasets from torchvision import transforms if torch.cuda.is_available(): torch.backends.cudnn.deterministic = True # In[4]: ########################## ### SETTINGS ########################## # Device device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print('Device:', device) # Hyperparameters random_seed = 456 learning_rate = 0.005 num_epochs = 10 batch_size = 128 ########################## ### MNIST DATASET ########################## # Note transforms.ToTensor() scales input images # to 0-1 range train_dataset = datasets.MNIST(root='data', train=True, transform=transforms.ToTensor(), download=True) test_dataset = datasets.MNIST(root='data', train=False, transform=transforms.ToTensor()) train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True) test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False) # Checking the dataset for images, labels in train_loader: print('Image batch dimensions:', images.shape) print('Image label dimensions:', labels.shape) break # ## Model # In[5]: ########################## ### MODEL ########################## class ConvolutionalAutoencoder(torch.nn.Module): def __init__(self): super(ConvolutionalAutoencoder, self).__init__() # calculate same padding: # (w - k + 2*p)/s + 1 = o # => p = (s(o-1) - w + k)/2 ### ENCODER # 28x28x1 => 28x28x4 self.conv_1 = torch.nn.Conv2d(in_channels=1, out_channels=4, kernel_size=(3, 3), stride=(1, 1), # (1(28-1) - 28 + 3) / 2 = 1 padding=1) # 28x28x4 => 14x14x4 self.pool_1 = torch.nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2), # (2(14-1) - 28 + 2) / 2 = 0 padding=0) # 14x14x4 => 14x14x8 self.conv_2 = torch.nn.Conv2d(in_channels=4, out_channels=8, kernel_size=(3, 3), stride=(1, 1), # (1(14-1) - 14 + 3) / 2 = 1 padding=1) # 14x14x8 => 7x7x8 self.pool_2 = torch.nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2), # (2(7-1) - 14 + 2) / 2 = 0 padding=0) ### DECODER # 7x7x8 => 15x15x4 self.deconv_1 = torch.nn.ConvTranspose2d(in_channels=8, out_channels=4, kernel_size=(3, 3), stride=(2, 2), padding=0) # 15x15x4 => 31x31x1 self.deconv_2 = torch.nn.ConvTranspose2d(in_channels=4, out_channels=1, kernel_size=(3, 3), stride=(2, 2), padding=0) def forward(self, x): ### ENCODER x = self.conv_1(x) x = F.leaky_relu(x) x = self.pool_1(x) x = self.conv_2(x) x = F.leaky_relu(x) x = self.pool_2(x) ### DECODER x = self.deconv_1(x) x = F.leaky_relu(x) x = self.deconv_2(x) x = F.leaky_relu(x) logits = x[:, :, 2:30, 2:30] probas = torch.sigmoid(logits) return logits, probas torch.manual_seed(random_seed) model = ConvolutionalAutoencoder() model = model.to(device) optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) # ## Training # In[6]: start_time = time.time() for epoch in range(num_epochs): for batch_idx, (features, targets) in enumerate(train_loader): # don't need labels, only the images (features) features = features.to(device) ### FORWARD AND BACK PROP logits, decoded = model(features) #cost = F.binary_cross_entropy_with_logits(logits, features) cost = continuous_jaccard(features, decoded) optimizer.zero_grad() cost.backward() ### UPDATE MODEL PARAMETERS optimizer.step() ### LOGGING if not batch_idx % 50: print ('Epoch: %03d/%03d | Batch %03d/%03d | Cost: %.4f' %(epoch+1, num_epochs, batch_idx, len(train_dataset)//batch_size, cost)) print('Time elapsed: %.2f min' % ((time.time() - start_time)/60)) print('Total Training Time: %.2f min' % ((time.time() - start_time)/60)) # ## Evaluation # In[7]: get_ipython().run_line_magic('matplotlib', 'inline') import matplotlib.pyplot as plt ########################## ### VISUALIZATION ########################## n_images = 15 image_width = 28 fig, axes = plt.subplots(nrows=2, ncols=n_images, sharex=True, sharey=True, figsize=(20, 2.5)) orig_images = features[:n_images] decoded_images = decoded[:n_images] for i in range(n_images): for ax, img in zip(axes, [orig_images, decoded_images]): curr_img = img[i].detach().to(torch.device('cpu')) ax[i].imshow(curr_img.view((image_width, image_width)), cmap='binary') # In[8]: get_ipython().run_line_magic('watermark', '-iv')