first commit

Author: anilsathyan7

README.md

@@ -0,0 +1 @@
+# pytorch-image-classification

eval.py

@@ -0,0 +1,80 @@
+import numpy as np
+import torch
+import torchvision
+from torchvision import datasets, models, transforms
+import torch.utils.data as data
+import multiprocessing
+from sklearn.metrics import confusion_matrix
+
+# Paths for image directory and model
+EVAL_DIR=sys.argv[1])
+EVAL_MODEL='models/mobilenetv2.pth'
+
+# Load the model for evaluation
+model = torch.load(EVAL_MODEL)
+model.eval()
+
+# Configure batch size and nuber of cpu's
+num_cpu = multiprocessing.cpu_count()
+bs = 8
+
+# Prepare the eval data loader
+eval_transform=transforms.Compose([
+        transforms.Resize(size=256),
+        transforms.CenterCrop(size=224),
+        transforms.ToTensor(),
+        transforms.Normalize([0.485, 0.456, 0.406],
+                             [0.229, 0.224, 0.225])])
+
+eval_dataset=datasets.ImageFolder(root=EVAL_DIR, transform=eval_transform)
+eval_loader=data.DataLoader(eval_dataset, batch_size=bs, shuffle=True,
+                            num_workers=num_cpu, pin_memory=True)
+
+# Enable gpu mode, if cuda available
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+# Number of classes and dataset-size
+num_classes=len(eval_dataset.classes)
+dsize=len(eval_dataset)
+
+# Initialize the prediction and label lists
+predlist=torch.zeros(0,dtype=torch.long, device='cpu')
+lbllist=torch.zeros(0,dtype=torch.long, device='cpu')
+
+# Evaluate the model accuracy on the dataset
+correct = 0
+total = 0
+with torch.no_grad():
+    for images, labels in eval_loader:
+        images, labels = images.to(device), labels.to(device)
+        outputs = model(images)
+        _, predicted = torch.max(outputs.data, 1)
+
+        total += labels.size(0)
+        correct += (predicted == labels).sum().item()
+
+        predlist=torch.cat([predlist,predicted.view(-1).cpu()])
+        lbllist=torch.cat([lbllist,labels.view(-1).cpu()])
+
+# Overall accuracy
+overall_accuracy=100 * correct / total
+print('Accuracy of the network on the {:d} test images: {:.2f}%'.format(dsize, 
+    overall_accuracy))
+
+# Confusion matrix
+conf_mat=confusion_matrix(lbllist.numpy(), predlist.numpy())
+print('Confusion Matrix')
+print('-'*16)
+print(conf_mat,'\n')
+
+# Per-class accuracy
+class_accuracy=100*conf_mat.diagonal()/conf_mat.sum(1)
+print('Per class accuracy')
+print('-'*18)
+for label,accuracy in zip(eval_dataset.classes, class_accuracy):
+     print('Accuracy of %3s : %0.2f %%'%(label, accuracy)
+
+
+'''
+Sample run: python eval.py data/eval
+'''

models/mobilenetv2.pth

@@ -0,0 +1,51 @@
+import torch
+import torch.nn as nn
+
+def vgg_block_single(in_ch, out_ch, kernel_size=3, padding=1):
+    return nn.Sequential(
+        nn.Conv2d(in_ch, out_ch, kernel_size=kernel_size, padding=padding),
+        nn.ReLU(),
+        nn.MaxPool2d(kernel_size=2, stride=2)
+        ) 
+    
+def vgg_block_double(in_ch, out_ch, kernel_size=3, padding=1):
+    return nn.Sequential(
+        nn.Conv2d(in_ch, out_ch, kernel_size=kernel_size, padding=padding),
+        nn.ReLU(),
+        nn.Conv2d(out_ch, out_ch, kernel_size=kernel_size, padding=padding),
+        nn.ReLU(),
+        nn.MaxPool2d(kernel_size=2, stride=2)
+        )
+
+
+class MyVGG11(nn.Module):
+    def __init__(self, in_ch, num_classes):
+        super().__init__()
+
+        self.conv_block1 =vgg_block_single(in_ch,64)
+        self.conv_block2 =vgg_block_single(64,128)
+
+        self.conv_block3 =vgg_block_double(128,256)
+        self.conv_block4 =vgg_block_double(256,512)
+        self.conv_block5 =vgg_block_double(512,512)
+
+        self.fc_layers = nn.Sequential(
+            nn.Linear(512 * 7 * 7, 4096), nn.ReLU(inplace=True), nn.Dropout(),
+            nn.Linear(4096, 4096), nn.ReLU(inplace=True), nn.Dropout(),
+            nn.Linear(4096, num_classes)
+        )
+
+    def forward(self, x):
+        
+        x=self.conv_block1(x)
+        x=self.conv_block2(x)
+
+        x=self.conv_block3(x)
+        x=self.conv_block4(x)
+        x=self.conv_block5(x)
+
+        x=x.view(x.size(0), -1)
+
+        x=self.fc_layers(x)
+
+        return x

models/resnet18.pth

@@ -0,0 +1,54 @@
+import numpy as np
+import sys, random
+import torch
+from torchvision import models, transforms
+from PIL import Image
+from pathlib import Path
+import matplotlib.pyplot as plt
+
+# Paths for image directory and model
+IMDIR=sys.argv[1])
+MODEL='models/resnet18.pth'
+
+# Load the model for testing
+model = torch.load(MODEL)
+model.eval()
+
+# Class labels for prediction
+class_names=['apple','atm card','cat','banana','bangle','battery','bottle','broom','bulb','calender','camera']
+
+# Retreive 9 random images from directory
+files=Path(IMDIR).resolve().glob('*.*')
+images=random.sample(list(files), 9)
+
+# Configure plots
+fig = plt.figure(figsize=(9,9))
+rows,cols = 3,3
+
+# Preprocessing transformations
+preprocess=transforms.Compose([
+        transforms.Resize(size=256),
+        transforms.CenterCrop(size=224),
+        transforms.ToTensor(),
+        transforms.Normalize([0.485, 0.456, 0.406],
+                             [0.229, 0.224, 0.225])
+    ])
+
+# Enable gpu mode, if cuda available
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+# Perform prediction and plot results
+with torch.no_grad():
+    for num,img in enumerate(images):
+         img=Image.open(img).convert('RGB')
+         inputs=preprocess(img).unsqueeze(0).to(device)
+         outputs = model(inputs)
+         _, preds = torch.max(outputs, 1)    
+         label=class_names[preds]
+         plt.subplot(rows,cols,num+1)
+         plt.title("Pred: "+label)
+         plt.axis('off')
+         plt.imshow(img)
+'''
+Sample run: python test.py test
+'''