CS计算机代考程序代写 python cuda LeNet-5 MNIST Digits Classifier¶

LeNet-5 MNIST Digits Classifier¶

References¶
• [1] Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, november 1998.

Imports¶
In [13]:
import os
import time

import numpy as np
import pandas as pd

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader

from torchvision import datasets
from torchvision import transforms

import matplotlib.pyplot as plt
from PIL import Image

if torch.cuda.is_available():
torch.backends.cudnn.deterministic = True

Model Settings¶
In [20]:
##########################
### SETTINGS
##########################

# Hyperparameters
RANDOM_SEED = 1
LEARNING_RATE = 0.001
BATCH_SIZE = 128
# NUM_EPOCHS = 10
NUM_EPOCHS = 10

# Architecture
NUM_FEATURES = 32*32
# NUM_CLASSES = 10
NUM_CLASSES = 10

# Other
if torch.cuda.is_available():
DEVICE = “cuda:0”
else:
DEVICE = “cpu”

GRAYSCALE = True

MNIST Dataset¶
In [21]:
##########################
### MNIST DATASET
##########################

resize_transform = transforms.Compose([transforms.Resize((32, 32)), # transforms.Resize((32, 32)),
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))])

# Note transforms.ToTensor() scales input images
# to 0-1 range
train_dataset = datasets.MNIST(root=’data’,
train=True,
transform=resize_transform,
download=True)

test_dataset = datasets.MNIST(root=’data’,
train=False,
transform=resize_transform)

train_loader = DataLoader(dataset=train_dataset,
batch_size=BATCH_SIZE,
shuffle=True)

test_loader = DataLoader(dataset=test_dataset,
batch_size=BATCH_SIZE,
shuffle=False)

# Checking the dataset
for images, labels in train_loader:
print(‘Image batch dimensions:’, images.shape)
print(‘Image label dimensions:’, labels.shape)
break

Image batch dimensions: torch.Size([128, 1, 32, 32])
Image label dimensions: torch.Size([128])
In [22]:
device = torch.device(DEVICE)
torch.manual_seed(0)

for epoch in range(2):

for batch_idx, (x, y) in enumerate(train_loader):

print(‘Epoch:’, epoch+1, end=”)
print(‘ | Batch index:’, batch_idx, end=”)
print(‘ | Batch size:’, y.size()[0])

x = x.to(device)
y = y.to(device)
break

Epoch: 1 | Batch index: 0 | Batch size: 128
Epoch: 2 | Batch index: 0 | Batch size: 128
In [23]:
##########################
### MODEL
##########################

class LeNet5(nn.Module):

def __init__(self, num_classes, grayscale=False):
super(LeNet5, self).__init__()

self.grayscale = grayscale
self.num_classes = num_classes

if self.grayscale:
in_channels = 1
else:
in_channels = 3

self.features = nn.Sequential(

nn.Conv2d(in_channels, 6, kernel_size=5),
nn.Tanh(),
nn.MaxPool2d(kernel_size=2),
nn.Conv2d(6, 16, kernel_size=5),
nn.Tanh(),
nn.MaxPool2d(kernel_size=2)
)

self.classifier = nn.Sequential(
nn.Linear(16*5*5, 120),
nn.Tanh(),
nn.Linear(120, 84),
nn.Tanh(),
nn.Linear(84, num_classes),
)

def forward(self, x):
x = self.features(x)
x = torch.flatten(x, 1)
logits = self.classifier(x)
probas = F.softmax(logits, dim=1)
return logits, probas
In [24]:
torch.manual_seed(RANDOM_SEED)

model = LeNet5(NUM_CLASSES, GRAYSCALE)
model.to(DEVICE)

optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE)

Training¶
In [25]:
def compute_accuracy(model, data_loader, device):
correct_pred, num_examples = 0, 0
for i, (features, targets) in enumerate(data_loader):

features = features.to(device)
targets = targets.to(device)

logits, probas = model(features)
_, predicted_labels = torch.max(probas, 1)
num_examples += targets.size(0)
correct_pred += (predicted_labels == targets).sum()
return correct_pred.float()/num_examples * 100

start_time = time.time()
for epoch in range(NUM_EPOCHS):

model.train()
for batch_idx, (features, targets) in enumerate(train_loader):

features = features.to(DEVICE)
targets = targets.to(DEVICE)

### FORWARD AND BACK PROP
logits, probas = model(features)
cost = F.cross_entropy(logits, targets)
optimizer.zero_grad()

cost.backward()

### UPDATE MODEL PARAMETERS
optimizer.step()

### LOGGING
if not batch_idx % 50:
print (‘Epoch: %03d/%03d | Batch %04d/%04d | Cost: %.4f’
%(epoch+1, NUM_EPOCHS, batch_idx,
len(train_loader), cost))

model.eval()
with torch.set_grad_enabled(False): # save memory during inference
print(‘Epoch: %03d/%03d | Train: %.3f%%’ % (
epoch+1, NUM_EPOCHS,
compute_accuracy(model, train_loader, device=DEVICE)))

print(‘Time elapsed: %.2f min’ % ((time.time() – start_time)/60))

print(‘Total Training Time: %.2f min’ % ((time.time() – start_time)/60))

Evaluation¶
In [26]:
with torch.set_grad_enabled(False): # save memory during inference
print(‘Test accuracy: %.2f%%’ % (compute_accuracy(model, test_loader, device=DEVICE)))

Test accuracy: 98.88%
In [2]:
for batch_idx, (features, targets) in enumerate(test_loader):

features = features
targets = targets
break

nhwc_img = np.transpose(features[0], axes=(1, 2, 0))
nhw_img = np.squeeze(nhwc_img.numpy(), axis=2)
plt.imshow(nhw_img, cmap=’Greys’);

—————————————————————————
NameError Traceback (most recent call last)
in
—-> 1 for batch_idx, (features, targets) in enumerate(test_loader):
2
3 features = features
4 targets = targets
5 break

NameError: name ‘test_loader’ is not defined
In [1]:
model.eval()
logits, probas = model(features.to(device)[0, None])
print(‘Probability 7 %.2f%%’ % (probas[0][7]*100))

—————————————————————————
NameError Traceback (most recent call last)
in
—-> 1 model.eval()
2 logits, probas = model(features.to(device)[0, None])
3 print(‘Probability 7 %.2f%%’ % (probas[0][7]*100))

NameError: name ‘model’ is not defined
In [ ]:

Related Posts