Project: Building an E-Commerce Clothing Classifier Model

Fashion Forward is a new AI-based e-commerce clothing retailer. They want to use image classification to automatically categorize new product listings, making it easier for customers to find what they're looking for. It will also assist in inventory management by quickly sorting items.

As a data scientist tasked with implementing a garment classifier, your primary objective is to develop a machine learning model capable of accurately categorizing images of clothing items into distinct garment types such as shirts, trousers, shoes, etc.

# Run the cells below first

!pip install torchmetrics

Hidden output

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
from torchmetrics import Accuracy, Precision, Recall

# Load datasets
from torchvision import datasets
import torchvision.transforms as transforms

train_data = datasets.FashionMNIST(root='./data', train=True, download=True, transform=transforms.ToTensor())
test_data = datasets.FashionMNIST(root='./data', train=False, download=True, transform=transforms.ToTensor())
train_data.__getitem__(0)[0].shape
print(train_data.__getitem__(0)[0].shape)

# Start coding here
# Use as many cells as you need
num_classes = 10
model = nn.Sequential(
    nn.Conv2d(1,32,kernel_size=3,stride=1,padding=1),
    nn.MaxPool2d(kernel_size=2,stride=2),
    nn.ReLU(),
    nn.Conv2d(32,64,kernel_size=3,stride=1,padding=1),
    #nn.MaxPool2d(kernel_size=2,stride=2),
    nn.ReLU(),
    nn.Flatten(),
    nn.Linear(64*14*14,num_classes)
    #nn.Linear(32*14*14,num_classes)
)

dataloader_train = DataLoader(train_data, batch_size=10, shuffle=True)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(),lr=0.001)

for epoch in range(3):
    running_loss = 0.0
    # Iterate over training batches
    for images, labels in dataloader_train:
        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    
    epoch_loss = running_loss / len(dataloader_train)
    print(f"Epoch {epoch+1}, Loss: {epoch_loss:.4f}")

metric_precision = Precision(task='multiclass', num_classes=num_classes, average=None)
metric_recall = Recall(task='multiclass', num_classes=num_classes, average=None)
metric_accuracy = Accuracy(task='multiclass', num_classes=num_classes)
dataloader_test = DataLoader(test_data)

model.eval()
predicted = []
with torch.no_grad():
    for images, labels in dataloader_test:
        outputs = model(images)
        _, preds = torch.max(outputs, 1)
        predicted.append(preds.tolist()[0])
        metric_precision(preds, labels)
        metric_recall(preds, labels)
        metric_accuracy(preds,labels)

#print("Predictions: ",predictions)
precision = metric_precision.compute().tolist()
recall = metric_recall.compute().tolist()
accuracy = metric_accuracy.compute()
print(f"Accuracy: {accuracy}")
print(f"Precision: {precision}")
print(f"Recall: {recall}")