forked from amirrezarajabi/rs-dl-framework
-
Notifications
You must be signed in to change notification settings - Fork 0
/
mnist-task.py
110 lines (80 loc) · 3.25 KB
/
mnist-task.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
import sys
import numpy as np
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensor
from rsdl import Tensor
from rsdl.activations import Softmax, Tanh, Sigmoid, Relu, LeakyRelu
from rsdl.layers import Linear
from rsdl.optim import Adam, Momentum
from rsdl.losses import mean_square_errors, cross_entropy
sys.setrecursionlimit(10000)
train_set = datasets.MNIST(
root='./data',
train=True,
download=True,
transform=ToTensor()
)
test_set = datasets.MNIST(
root='./data',
train=False,
download=False,
transform=ToTensor()
)
batch_size = 32
train_loader = DataLoader(train_set, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_set, batch_size=batch_size, shuffle=False)
class Model:
def __init__(self, input_size: int, hidden_size: int, output_size: int) -> None:
super(Model, self).__init__()
self.input_size = input_size
self.hidden_size = hidden_size
self.output_size = output_size
self.layer0 = Linear(input_size, hidden_size, need_bias=True)
# self.layer1 = Linear(hidden_size, hidden_size, need_bias=True)
# self.layer2 = Linear(hidden_size, hidden_size, need_bias=True)
# self.layer3 = Linear(hidden_size, hidden_size, need_bias=True)
# self.layer4 = Linear(hidden_size, hidden_size, need_bias=True)
self.layer5 = Linear(hidden_size, output_size, need_bias=True)
self.optimizer = Momentum(layers=[self.layer0, self.layer5])
def forward(self, x):
# Assuming x is a tensor with size (batch_size, 1, 28, 28)
x = Relu(self.layer0.forward(x))
# x = Relu(self.layer1(x))
# x = Relu(self.layer2(x))
# x = Relu(self.layer3(x))
# x = Relu(self.layer4(x))
x = Relu(self.layer5.forward(x))
return x
def evaluate_accuracy(self, data_loader):
correct_count = 0
total_count = 0
for images, labels in data_loader:
flattened_images = images.view([images.size(0), -1])
numpy_images = flattened_images.numpy()
inputs = Tensor(numpy_images)
predicted = self.forward(inputs)
predicted_labels = np.argmax(predicted.data, axis=1)
correct_count += np.sum(predicted_labels == labels.numpy())
total_count += len(labels)
accuracy = correct_count / total_count
return accuracy
model = Model(input_size=784, hidden_size=100, output_size=10)
for epoch in range(5):
epoch_loss = 0.0
batch = 0
for images, labels in train_loader:
batch += 1
flattened_images = images.view([images.size(0), -1])
numpy_images = flattened_images.numpy()
inputs = Tensor(numpy_images)
predicted = model.forward(inputs)
actual = Tensor(np.zeros((len(labels), 10)))
actual.data[np.arange(len(labels)), labels] = 1
loss = cross_entropy(predicted, actual)
loss.zero_grad()
loss.backward()
epoch_loss += loss.data
model.optimizer.step()
model.optimizer.zero_grad()
print(f"Epoch {epoch + 1}, Loss: {epoch_loss}, Training Accuracy: {model.evaluate_accuracy(train_loader)}, Test Accuracy: {model.evaluate_accuracy(test_loader)}")