Test.ipynb

+%% Cell type:markdown id: tags:
+
+## Test Pytorch
+
+%% Cell type:code id: tags:
+
+``` python
+import torch
+
+N, D = 14, 10
+x = torch.randn(N, D).type(torch.FloatTensor)
+print(x)
+
+from torchvision import models
+
+alexnet = models.alexnet()
+print(alexnet)
+```
+
+%% Output
+
+    tensor([[ 0.6650,  2.0888, -0.3361, -0.6212,  0.6276, -0.3091,  1.6601, -0.1404,
+              0.0224, -1.1360],
+            [-0.8311, -1.6385,  0.3011,  1.2989,  0.2328, -0.0061,  0.4039,  0.3956,
+             -0.2067, -0.8877],
+            [-0.2899, -1.7310, -0.4318,  1.3837,  3.1771,  1.7354,  0.3680, -0.0743,
+             -0.1610,  0.8281],
+            [-0.2591, -2.0913,  0.8630, -0.3533,  0.9323, -1.4520,  0.4476, -0.2588,
+             -0.0963,  1.8449],
+            [ 0.4599,  0.3258,  0.7780,  0.6943, -0.4343, -0.0536, -0.1049,  0.2867,
+              0.5493, -1.2934],
+            [-0.6990,  0.0783, -0.8745,  1.2521,  1.5363,  0.8770, -0.5319, -0.2629,
+              0.7732, -0.5001],
+            [-0.2902, -0.8901,  0.1904,  0.7456,  0.5802,  0.0443, -1.2447,  2.1954,
+              0.5382,  0.2219],
+            [ 1.0372, -0.7516,  0.7940,  0.8207,  0.6601,  0.0317,  0.1410, -1.7062,
+             -0.6549,  0.6287],
+            [ 0.6680,  1.0136, -0.0813, -1.4382,  0.4640,  1.2923, -1.0299,  0.5684,
+              1.6626, -1.1921],
+            [-1.1864, -0.6625, -1.0846,  0.7550, -0.8748,  0.2835, -1.4264,  1.0279,
+             -0.6046,  0.6298],
+            [-1.9253, -0.4960, -0.8379,  1.8726, -2.0282,  0.0869,  1.2508,  0.0390,
+             -1.7213,  0.3269],
+            [ 1.7196, -1.6188, -0.4604, -1.0196, -0.8883,  1.2987,  0.4795,  0.5581,
+             -1.0138, -0.2184],
+            [-0.6600,  0.5816, -0.6574,  0.4684,  1.2546, -0.4140, -0.2636,  0.4267,
+              0.1736, -1.5019],
+            [-0.8852,  0.6677, -1.3074, -1.2241, -1.4054,  0.0919,  1.5832,  1.4357,
+             -1.9016,  0.7274]])
+    AlexNet(
+      (features): Sequential(
+        (0): Conv2d(3, 64, kernel_size=(11, 11), stride=(4, 4), padding=(2, 2))
+        (1): ReLU(inplace=True)
+        (2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
+        (3): Conv2d(64, 192, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
+        (4): ReLU(inplace=True)
+        (5): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
+        (6): Conv2d(192, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+        (7): ReLU(inplace=True)
+        (8): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+        (9): ReLU(inplace=True)
+        (10): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+        (11): ReLU(inplace=True)
+        (12): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
+      )
+      (avgpool): AdaptiveAvgPool2d(output_size=(6, 6))
+      (classifier): Sequential(
+        (0): Dropout(p=0.5, inplace=False)
+        (1): Linear(in_features=9216, out_features=4096, bias=True)
+        (2): ReLU(inplace=True)
+        (3): Dropout(p=0.5, inplace=False)
+        (4): Linear(in_features=4096, out_features=4096, bias=True)
+        (5): ReLU(inplace=True)
+        (6): Linear(in_features=4096, out_features=1000, bias=True)
+      )
+    )
+
+%% Cell type:markdown id: tags:
+
+## Exercise 1: CNN on CIFAR10
+
+%% Cell type:markdown id: tags:
+
+See if cuda is available ==> it is not
+
+%% Cell type:code id: tags:
+
+``` python
+import torch
+
+# 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 ...")
+```
+
+%% Output
+
+    CUDA is not available.  Training on CPU ...
+
+%% Cell type:markdown id: tags:
+
+Load the CIFAR10 dataset
+
+%% Cell type:code id: tags:
+
+``` python
+import numpy as np
+from torchvision import datasets, transforms
+from torch.utils.data.sampler import SubsetRandomSampler
+
+# 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
+valid_size = 0.2
+
+# convert data to a normalized torch.FloatTensor
+transform = transforms.Compose(
+    [transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]
+)
+
+# choose the training and test datasets
+train_data = datasets.CIFAR10("data", train=True, download=True, transform=transform)
+test_data = datasets.CIFAR10("data", train=False, download=True, transform=transform)
+
+# obtain training indices that will be used for validation
+num_train = len(train_data)
+indices = list(range(num_train))
+np.random.shuffle(indices)
+split = int(np.floor(valid_size * num_train))
+train_idx, valid_idx = indices[split:], indices[:split]
+
+# define samplers for obtaining training and validation batches
+train_sampler = SubsetRandomSampler(train_idx)
+valid_sampler = SubsetRandomSampler(valid_idx)
+
+# prepare data loaders (combine dataset and sampler)
+train_loader = torch.utils.data.DataLoader(
+    train_data, batch_size=batch_size, sampler=train_sampler, num_workers=num_workers
+)
+valid_loader = torch.utils.data.DataLoader(
+    train_data, batch_size=batch_size, sampler=valid_sampler, num_workers=num_workers
+)
+test_loader = torch.utils.data.DataLoader(
+    test_data, batch_size=batch_size, num_workers=num_workers
+)
+
+# specify the image classes
+classes = [
+    "airplane",
+    "automobile",
+    "bird",
+    "cat",
+    "deer",
+    "dog",
+    "frog",
+    "horse",
+    "ship",
+    "truck",
+]
+```
+
+%% Output
+
+    Files already downloaded and verified
+    Files already downloaded and verified
+
+%% Cell type:code id: tags:
+
+``` python
+```