CNNDog

import os
from torchvision import datasets
import torch
import numpy as np

# check if CUDA is available
train_on_gpu = torch.cuda.is_available()

if not train_on_gpu:
    print('CUDA is not available.  Training on CPU ...')
else:
    print('CUDA is available!  Training on GPU ...')


### TODO: Write data loaders for training, validation, and test sets
## Specify appropriate transforms, and batch_sizes
from torchvision import datasets
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
from torch.utils.data.sampler import SubsetRandomSampler
from PIL import ImageFile
ImageFile.LOAD_TRUNCATED_IMAGES = True

# number of subprocesses to use for data loading
num_workers = 0
# how many samples per batch to load
batch_size = 20
# percentage of training set to use as validation
image_size=256
rootTrain="/data/dog_images/train/"
rootTest="/data/dog_images/test/"
rootValid="/data/dog_images/valid/"
transform = transforms.Compose([
                transforms.Resize((image_size,image_size)),
                transforms.ToTensor(),
                transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
transform2 = transforms.Compose([
                transforms.Resize((image_size,image_size)),
                transforms.RandomHorizontalFlip(p=0.99), # randomly flip and rotate
                transforms.RandomRotation(60),
                transforms.ToTensor(),
                transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
train_data1 = datasets.ImageFolder(root=rootTrain, transform=transform)
print(len(train_data1))
train_data2 = datasets.ImageFolder(root=rootTrain, transform=transform)
train_data = train_data1 + train_data2
print(len(train_data))

test_data = datasets.ImageFolder(root=rootTest, transform=transform)
valid_data = datasets.ImageFolder(root=rootValid, transform=transform)


# prepare data loaders (combine dataset and sampler)
train_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size, num_workers=num_workers, shuffle=True)
valid_loader = torch.utils.data.DataLoader(valid_data, batch_size=batch_size, num_workers=num_workers, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_data, batch_size=batch_size, num_workers=num_workers, shuffle=True)

classes = []
for i in range(0,133):
    classes.append(str(i))

print (classes)
#Visualize a Batch of Training Data
import matplotlib.pyplot as plt
%matplotlib inline

# helper function to un-normalize and display an image
def imshow(img):
    img = img / 2 + 0.5  # unnormalize
    plt.imshow(np.transpose(img, (1, 2, 0)))  # convert from Tensor image
# obtain one batch of training images
dataiter = iter(train_loader)
images, labels = dataiter.next()
images = images.numpy() # convert images to numpy for display

# plot the images in the batch, along with the corresponding labels
fig = plt.figure(figsize=(25, 4))
# display 20 images
for idx in np.arange(20):
    ax = fig.add_subplot(2, 20/2, idx+1, xticks=[], yticks=[])
    imshow(images[idx])
    ax.set_title(classes[labels[idx]])



#----------------------------------------- Arch ----------------------------------

import torch.nn as nn
import torch.nn.functional as F

# define the CNN architecture
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        # convolutional layer
        #32x32x3 image
        #(n-2p+f)/s + 1
        self.conv1 = nn.Conv2d(3, 16, 3, padding=1)
        self.conv3 = nn.Conv2d(16, 32, 3, padding=1)
        self.conv4 = nn.Conv2d(32, 64, 3, padding=1)

        self.pool = nn.MaxPool2d(2, 2)
        self.conv1_bn = nn.BatchNorm2d(16)
        self.conv2_bn = nn.BatchNorm2d(32)
        self.conv3_bn = nn.BatchNorm2d(64)

        self.fc1 = nn.Linear(32*32*64, 500)
        self.fc3 = nn.Linear(500, 133)
        self.dropout = nn.Dropout(p=0.3)

    def forward(self, x):
        x = self.conv1_bn((self.pool(F.relu(self.conv1(x)))))
        x = self.conv2_bn(self.pool(F.relu(self.conv3(x))))
        x = self.conv3_bn(self.pool(F.relu(self.conv4(x))))
        x = x.view(-1, 32*32*64)
        x = self.dropout(F.relu(self.fc1(x)))
        x = self.fc3(x)
        return x

## complete this function
def weights_init_normal(m):
    '''Takes in a module and initializes all linear layers with weight
       values taken from a normal distribution.'''

    classname = m.__class__.__name__
    # for every Linear layer in a model
    # m.weight.data shoud be taken from a normal distribution
    # m.bias.data should be 0
    if classname.find('Linear') != -1:
        # get the number of the inputs
        n = m.in_features
        y = 1.0/np.sqrt(n)
        m.weight.data.normal_(0,y)
        m.bias.data.fill_(0)

# create a new model with the rule-based, NORMAL weights
model_scratch = Net()
model_scratch.apply(weights_init_normal)

print(model_scratch)

# move tensors to GPU if CUDA is available
if train_on_gpu:
    model_scratch.cuda()