Create S10.py

S10.py

@@ -0,0 +1,161 @@
+from __future__ import print_function
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+from torchvision import datasets, transforms
+import os
+os.environ['KMP_DUPLICATE_LIB_OK']='True'
+import pytorch_lightening as pl
+
+#MODEL
+class LtAutoEncoder(L.LighteningModule):
+    def __init__(self):
+        super(Net,self).__init__()
+        self.conv1 = nn.Sequential (
+            nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1,bias=False),
+            nn.BatchNorm2d(64),
+            nn.ReLU(inplace=True)
+            )  # Number of Parameters = 3*3*3*64=1728
+        # Layer 1
+        self.conv11 = nn.Sequential(
+            nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1,bias=False),
+            nn.MaxPool2d(kernel_size=2,stride=2),
+            nn.BatchNorm2d(128),
+            nn.ReLU(inplace=True)
+            )  # Number of Parameters = 3*3*64*128 = 73728
+        self.conv12 = nn.Sequential(
+            nn.Conv2d(128,128, kernel_size=3, stride=1, padding=1,bias=False),# Number of Parameters = 3*3*64*128 = 73728
+            nn.BatchNorm2d(128),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(128,128, kernel_size=3, stride=1, padding=1,bias=False),# Number of Parameters = 3*3*64*128 = 73728
+            nn.BatchNorm2d(128),
+            nn.ReLU(inplace=True)
+            )
+
+        # Layer 2
+        self.conv2 = nn.Sequential(
+            nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1,bias=False),
+            nn.MaxPool2d(kernel_size=2,stride=2),
+            nn.BatchNorm2d(256),
+            nn.ReLU(inplace=True)
+            )
+
+        # Layer 3
+        self.conv31 = nn.Sequential(
+            nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1,bias=False),
+            nn.MaxPool2d(kernel_size=2,stride=2),
+            nn.BatchNorm2d(512),
+            nn.ReLU(inplace=True)
+            )
+        self.conv32 = nn.Sequential(
+            nn.Conv2d(512,512, kernel_size=3, stride=1, padding=1,bias=False),
+            nn.BatchNorm2d(512),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(512,512, kernel_size=3, stride=1, padding=1,bias=False),
+            nn.BatchNorm2d(512),
+            nn.ReLU(inplace=True)
+            )
+
+        self.maxpool = nn.MaxPool2d(kernel_size=4,stride=2)
+
+        # Fully connected
+        self.fc = nn.Linear(512, 10, bias=True)
+
+    def forward(self, x):
+        x = self.conv1(x)
+
+        x = self.conv11(x)
+        R1=x
+        x = self.conv12(x)
+        x=x+R1
+
+        x = self.conv2(x)
+
+        x = self.conv31(x)
+        R2=x
+        x = self.conv32(x)
+        x=x+R2
+
+        x = self.maxpool(x)
+        
+        x = x.squeeze(dim=[2, 3])
+
+        x = self.fc(x)
+
+        x = x.view(-1, 10)
+        return x
+
+    def training_step(self, batch, batch_idx):
+        # training_step defines the train loop.
+        # It is independent of forward
+        train_losses = []
+        train_acc = []
+        model.train()
+        pbar = tqdm(train_loader)
+        correct = 0
+        processed = 0
+        criterion = nn.CrossEntropyLoss()
+        for batch_idx, (data, target) in enumerate(pbar):
+        # get samples
+            data, target = data.to(device), target.to(device)
+            loss = criterion(y_pred, target)
+       
+            train_losses.append(loss)
+            optimizer.zero_grad()
+            # Backpropagation
+            loss.backward()
+            optimizer.step()
+
+            pred = y_pred.argmax(dim=1, keepdim=True)  # get the index of the max log-probability
+            correct += pred.eq(target.view_as(pred)).sum().item()
+            processed += len(data)
+
+            pbar.set_description(desc= f'Loss={loss.item()} Batch_id={batch_idx} Accuracy={100*correct/processed:0.2f}')
+            train_acc.append(100*correct/processed)
+        
+        
+    def test_model(self, batch, batch_idx):
+        test_losses = []
+        test_acc = []
+        model.eval()
+        test_loss = 0
+        correct = 0
+        with torch.no_grad():
+            for data, target in test_loader:
+                data, target = data.to(device), target.to(device)
+                output = model(data)
+                pred =output.argmax(dim=1, keepdim=True)  # get the index of the max log-probability
+                correct += pred.eq(target.view_as(pred)).sum().item()
+
+        test_loss /= len(test_loader.dataset)
+        test_losses.append(test_loss)
+
+        print('\nTest set:  Accuracy: {}/{} ({:.2f}%)\n'.format(
+             correct, len(test_loader.dataset),
+            100. * correct / len(test_loader.dataset)))
+
+        test_acc.append(100. * correct / len(test_loader.dataset))   
+        
+        
+    #OPTIMIZER
+    def configure_optimizers(self):
+        optimizer = torch.optim.Adam(model.parameters(), lr=1e-3, weight_decay=1e-4)
+        return optimizer
+
+model=LtAutoEncoder(Net)  
+
+
+# setup data
+dataset = MNIST(os.getcwd(), download=True, transform=ToTensor())
+train_loader = utils.data.DataLoader(dataset)
+
+# setup data
+dataset = CIFAR10(os.getcwd(), download=True, transform=ToTensor())
+train_loader = utils.data.DataLoader(dataset)
+
+# train the model (hint: here are some helpful Trainer arguments for rapid idea iteration)
+trainer = pl.Trainer(limit_train_batches=100, max_epochs=1)
+trainer.fit(model=autoencoder, train_dataloaders=train_loader)
+    
+