import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt
import torchvision
import torchvision.transforms as transforms

if torch.cuda.is_available():
    device = torch.device('cuda')
else:
    device = torch.device('cpu')
print(device)

train_dataset = torchvision.datasets.FashionMNIST(root='./data',
                                           train=True,
                                           transform=transforms.ToTensor(),
                                           download=True)

test_dataset = torchvision.datasets.FashionMNIST(root='./data',
                                          train=False,
                                          transform=transforms.ToTensor(),
                                          download=True)

print(train_dataset)
print(test_dataset)

Dataset FashionMNIST
    Number of datapoints: 60000
    Root location: ./data
    Split: Train
    StandardTransform
Transform: ToTensor()
Dataset FashionMNIST
    Number of datapoints: 10000
    Root location: ./data
    Split: Test
    StandardTransform
Transform: ToTensor()

print(f'Class names: {train_dataset.classes}')
for number, name in enumerate(train_dataset.classes):
    print(f"Class Number: {number}, Class Name: {name}")

Class names: ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']
Class Number: 0, Class Name: T-shirt/top
Class Number: 1, Class Name: Trouser
Class Number: 2, Class Name: Pullover
Class Number: 3, Class Name: Dress
Class Number: 4, Class Name: Coat
Class Number: 5, Class Name: Sandal
Class Number: 6, Class Name: Shirt
Class Number: 7, Class Name: Sneaker
Class Number: 8, Class Name: Bag
Class Number: 9, Class Name: Ankle boot

batch_size = 50

train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                                           batch_size=batch_size,
                                           shuffle=True)

test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
                                          batch_size=batch_size,
                                          shuffle=False)

print(len(train_loader))
print(len(test_loader))

1200
200

examples = iter(test_loader)
example_data, example_targets = next(examples)
example_data, example_targets = next(examples)

for i in range(9):
    plt.subplot(3,3,i+1)
    plt.title (train_dataset.classes[example_targets[i].item()])
    plt.imshow(example_data[i][0], cmap='gray')
    print(example_targets[i].item(), example_data[i].shape)

plt.show()
print(example_data[8][0][10])

4 torch.Size([1, 28, 28])
4 torch.Size([1, 28, 28])
5 torch.Size([1, 28, 28])
8 torch.Size([1, 28, 28])
2 torch.Size([1, 28, 28])
2 torch.Size([1, 28, 28])
8 torch.Size([1, 28, 28])
4 torch.Size([1, 28, 28])
8 torch.Size([1, 28, 28])

tensor([0.0000, 0.0000, 0.0000, 0.0588, 0.9843, 0.8039, 0.7961, 0.8353, 0.8275,
        0.8078, 0.8196, 0.8235, 0.8353, 0.8314, 0.8314, 0.8392, 0.8353, 0.8392,
        0.8471, 0.8392, 0.8314, 0.8196, 0.8392, 0.8275, 0.8235, 0.8235, 0.9020,
        0.2431])

input_size = 784 # 28x28
hidden_size1 = 200
hidden_size2 = 100
output_size = 1
epochs = 3
learning_rate = 0.01
required_label = 3
print (train_dataset.classes[required_label])

Dress

Model = nn.Sequential(
    nn.Linear(input_size,hidden_size1,device=device),
    nn.ReLU(),
    nn.Linear(hidden_size1,hidden_size2,device=device),
    nn.ReLU(),
    nn.Linear(hidden_size2, 1, device=device),
    nn.Sigmoid()
)

Loss = nn.BCELoss()
optim = torch.optim.Adam(Model.parameters(), lr=learning_rate)

n_total_steps = len(train_loader)
for epoch in range(epochs):
    for i, (images, lables) in enumerate(train_loader):

        # origin shape: [50, 1, 28, 28]
        # resized: [50, 784]
        images = images.reshape(-1, 28*28).to(device)
        lables = lables.reshape(-1,1).to(device)
        lables = (torch.eq(lables, required_label)).float()


        # forward
        Y_predict = Model(images)

        # backward
        loss = Loss(Y_predict, lables)
        loss.backward()

        # update wights
        optim.step()

        if (i + epoch * n_total_steps) % 100 == 0:
            print(f"epoch= {epoch} i= {i} num= {i+epoch * n_total_steps} loss={loss.item():.4f} ")

        # zero grads
        optim.zero_grad()

epoch= 0 i= 0 num= 0 loss=0.6926 
epoch= 0 i= 100 num= 100 loss=0.0097 
epoch= 0 i= 200 num= 200 loss=0.0658 
epoch= 0 i= 300 num= 300 loss=0.1033 
...
epoch= 2 i= 1100 num= 3500 loss=0.0225

with torch.no_grad():
    n_correct = 0
    n_samples = 0
    for images, lables in test_loader:
        images = images.reshape(-1, 28*28).to(device)
        lables = lables.reshape(-1,1).to(device)
        lables = (torch.eq(lables, required_label)).float()
        y_predict = Model(images).round()
        # print(y_predict.T)
        # print(lables.T)

        n_samples += lables.size(0)
        n_correct += (y_predict == lables).sum().item()

    acc = 100 * n_correct / n_samples
    print(f'Accuracy of the network on the {n_samples} test images: {acc} %')

Accuracy of the network on the 10000 test images: 96.89 %

print(len(test_loader))
print (n_samples)
print(lables.shape)
examples = iter(test_loader)
example_data, example_targets = next(examples)
example_data = example_data.to(device)
example_targets = example_targets.to(device)
with torch.no_grad():
    example_predict = Model(example_data.reshape(-1, 28*28)).T #.round()
example_predict.shape
for i in range(len(example_data)):
    print (example_predict[0,i].item(), example_targets[i].item(), round(example_predict[0,i].item()) )

200
10000
torch.Size([50, 1])
3.8038247885490236e-28 9 0
...
0.00022870743123348802 2 0

predict = example_predict.round().reshape(-1)
print(predict)
plt.figure(figsize=(12, 10))  # Adjust the figure size
for i in range(35):
    plt.subplot(7,5,i+1)

    plt.title (train_dataset.classes[example_targets[i].item()])
    plt.title(predict[i].item())
    plt.imshow(example_data[i][0].cpu(), cmap='gray')
    print(example_targets[i].item(), example_data[i].shape)
plt.tight_layout()
plt.show()

tensor([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.,
        0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0.,
        0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       device='cuda:0')
...
8 torch.Size([1, 28, 28])

import torch
import torch.nn as nn
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("Device:", device)

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Lambda(lambda x: x.flip(2)),
    transforms.Lambda(lambda x: torch.rot90(x, 1, [1, 2]))  # 90° CCW
])

train_dataset = torchvision.datasets.EMNIST(
    root="./data",
    split="byclass",
    train=True,
    transform=transform,
    download=True
)

test_dataset = torchvision.datasets.EMNIST(
    root="./data",
    split="byclass",
    train=False,
    transform=transform,
    download=True
)

print(train_dataset)
print(test_dataset)

Dataset EMNIST
    Number of datapoints: 697932
    Root location: ./data
    Split: Train
    StandardTransform
Transform: Compose(
               ToTensor()
               Lambda()
               Lambda()
           )
Dataset EMNIST
    Number of datapoints: 116323
    Root location: ./data
    Split: Test
    StandardTransform
Transform: Compose(
               ToTensor()
               Lambda()
               Lambda()
           )

batch_size = 64

train_loader = torch.utils.data.DataLoader(
    dataset=train_dataset,
    batch_size=batch_size,
    shuffle=True
)

test_loader = torch.utils.data.DataLoader(
    dataset=test_dataset,
    batch_size=batch_size,
    shuffle=False
)

print(len(train_loader), len(test_loader))

10906 1818

def emnist_label_to_char(label: int) -> str:
    """
    Convert an EMNIST 'byclass' numeric label to its corresponding character.

    EMNIST byclass mapping:
    0–9   -> '0'–'9'
    10–35 -> 'A'–'Z'
    36–61 -> 'a'–'z'
    """
    if 0 <= label <= 9:
        return chr(ord('0') + label)
    elif 10 <= label <= 35:
        return chr(ord('A') + (label - 10))
    elif 36 <= label <= 61:
        return chr(ord('a') + (label - 36))
    else:
        raise ValueError(f"Invalid EMNIST byclass label: {label}")

examples = iter(test_loader)
example_data, example_targets = next(examples)

plt.figure(figsize=(6,6))
for i in range(9):
    plt.subplot(3,3,i+1)
    plt.imshow(example_data[i][0], cmap="gray")
    plt.title(f"Label: {emnist_label_to_char(example_targets[i].item())}")
    plt.axis("off")
plt.show()

input_size = 28 * 28
hidden_size1 = 200
hidden_size2 = 100
epochs = 5
learning_rate = 0.001

Model = nn.Sequential(
    nn.Linear(input_size, hidden_size1, device=device),
    nn.ReLU(),
    nn.Linear(hidden_size1, hidden_size2, device=device),
    nn.ReLU(),
    nn.Linear(hidden_size2, 1, device=device),
    nn.Sigmoid()
)

Loss = nn.BCELoss()
optimizer = torch.optim.Adam(Model.parameters(), lr=learning_rate)

n_total_steps = len(train_loader)

for epoch in range(epochs):
    for i, (images, labels) in enumerate(train_loader):

        # flatten images
        images = images.reshape(-1, 28*28).to(device)

        # binary labels:
        # digit (0–9)  -> 1
        # letter (>=10) -> 0
        labels = labels.to(device)
        labels = (labels < 10).float().view(-1, 1)

        # forward
        outputs = Model(images)
        loss = Loss(outputs, labels)

        # backward
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if (i + epoch * n_total_steps) % 200 == 0:
            print(f"epoch={epoch} step={i} loss={loss.item():.4f}")

epoch=0 step=0 loss=0.6922
epoch=0 step=200 loss=0.3900
epoch=0 step=400 loss=0.4345
epoch=0 step=600 loss=0.4177
...
epoch=4 step=10776 loss=0.1791

Model.eval()
with torch.no_grad():
    n_correct = 0
    n_samples = 0

    for images, labels in test_loader:
        images = images.reshape(-1, 28*28).to(device)

        labels = labels.to(device)
        labels = (labels < 10).float().view(-1, 1)

        preds = Model(images).round()

        n_samples += labels.size(0)
        n_correct += (preds == labels).sum().item()

    acc = 100 * n_correct / n_samples
    print(f"Test Accuracy: {acc:.2f}%")

Test Accuracy: 90.93%

examples = iter(test_loader)
example_data, example_targets = next(examples)
example_data = example_data.to(device)

with torch.no_grad():
    probs = Model(example_data.reshape(-1, 28*28))
    preds = probs.round().view(-1)

plt.figure(figsize=(10,8))
for i in range(20):
    plt.subplot(4,5,i+1)
    plt.imshow(example_data[i][0].cpu(), cmap="gray")
    title = "Digit" if preds[i].item() == 1 else "Letter"
    plt.title(title)
    plt.axis("off")
plt.show()