Skip to content

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
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())
# Start coding here
# Use as many cells as you need
# Get the number of classes
classes = train_data.classes
num_classes = len(classes)
print(num_classes)
# Define some relevant variables
num_input_channels = 1
num_output_channels = 16
image_size = train_data[0][0].shape[1]
print(image_size)
print((image_size//2)**2)

1 - Defining the CNN (Convolutional Neural Network)

# Creating a class to contain the layers of a CNN
class MultiClassImageClassifier(nn.Module):
    # Define the init method
    def __init__(self, num_classes):
        super(MultiClassImageClassifier, self).__init__()
        # Adding a convolutional layer
        self.conv = nn.Conv2d(num_input_channels, num_output_channels, kernel_size=3, stride=1, padding=1)
        # Adding a Rectilinear Unit
        self.relu = nn.ReLU()
        # Adding a pooling layer
        self.maxpool = nn.MaxPool2d(kernel_size=2, stride=2)
        # Flatten the input
        self.flatten = nn.Flatten()

        # Adding a fully connected layer
        self.fc = nn.Linear(num_output_channels * (image_size//2)**2, num_classes)
        
    # Defining a .forward() method
    def forward(self, x):
        # Pass inputs through each layer
        x = self.conv(x)
        x = self.relu(x)
        x = self.maxpool(x)
        x = self.flatten(x)
        x = self.fc(x)
        return x

2 - Training the CNN

# Define the training set DataLoader
dataloader_train = DataLoader(
    train_data,
    batch_size=10,
    shuffle=True,
)
# Define training function
def train_model(optimizer, net, num_epochs):
    num_processed = 0
    # Define a suitable loss criterion
    criterion = nn.CrossEntropyLoss()
    for epoch in range(num_epochs):
        running_loss = 0
        num_processed = 0
        for features, labels in dataloader_train:
            optimizer.zero_grad()
            outputs = net(features)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
            running_loss += loss.item()
            num_processed += len(labels)
            print(f'epoch {epoch}, loss: {running_loss / num_processed}')

    train_loss = running_loss / len(dataloader_train)
# Train for 1 epochs
net = MultiClassImageClassifier(num_classes)
# Define an optimizer
optimizer = optim.Adam(net.parameters(), lr=0.001)

train_model(optimizer=optimizer, net=net, num_epochs=1)
‌
‌
‌