If anyone have python code, please share the code for using the decoder to classify or recognize the action?
I am new to Deep learning and machine learning codings. My already used codes (which I have taken from github repository) are:
%matplotlib inline
import os
import copy
import torch
import struct
import codecs
import numpy as np
import torchvision
import torch.nn as nn
from PIL import Image
import torch.optim as optim
from torchvision import datasets
import matplotlib.pyplot as plt
download = datasets.FashionMNIST('./FMNIST/', train=True, download=True)
Datapath = 'FMNIST/raw/'
def get_int(b):
return int(codecs.encode(b, 'hex'), 16)
def parse_byte(b):
if isinstance(b, str):
return ord(b)
return b
def read_image_file(path):
with open(path, 'rb') as f:
data = f.read()
assert get_int(data[:4]) == 2051
length = get_int(data[4:8])
num_rows = get_int(data[8:12])
num_cols = get_int(data[12:16])
images = []
idx = 16
for l in range(length):
img = []
images.append(img)
for r in range(num_rows):
row = []
img.append(row)
for c in range(num_cols):
row.append(parse_byte(data[idx]))
idx += 1
assert len(images) == length
return torch.ByteTensor(images).view(-1,784)
def read_label_file(path):
with open(path, 'rb') as f:
data = f.read()
assert get_int(data[:4]) == 2049
length = get_int(data[4:8])
labels = [parse_byte(b) for b in data[8:]]
assert len(labels) == length
return torch.LongTensor(labels)
TrainImages = read_image_file(os.path.join(Datapath, 'train-images-idx3-ubyte'))
TrainLabels = read_label_file(os.path.join(Datapath, 'train-labels-idx1-ubyte'))
TestImages = read_image_file(os.path.join(Datapath, 't10k-images-idx3-ubyte'))
TestLabels = read_label_file(os.path.join(Datapath, 't10k-labels-idx1-ubyte'))
print(TrainImages.size())
print(TrainLabels.size())
print(TestImages.size())
print(TestLabels.size())
use_gpu = torch.cuda.is_available()
if use_gpu:
print('GPU is available!')
device = "cuda"
else:
print('GPU is not available!')
device = "cpu"
# Define Autoencoder
class autoencoder(nn.Module):
def __init__(self):
super(autoencoder, self).__init__()
self.encoder = nn.Sequential(
nn.Linear(28*28, 100),
nn.ReLU(),
nn.Linear(100, 100),
nn.ReLU())
self.decoder = nn.Sequential(
nn.Linear(100, 100),
nn.ReLU(),
nn.Linear(100, 28*28),
nn.ReLU())
def forward(self, x):
x = self.encoder(x)
x = self.decoder(x)
return x
net = autoencoder()
print(net)
net = net.double().to(device)
init_weights = copy.deepcopy(net.encoder[0].weight.data)
criterion = nn.MSELoss()
optimizer = optim.SGD(net.parameters(), lr=0.5, momentum=0.9)
iterations = 30
BatchSize = 1000
for epoch in range(iterations):
runningLoss = 0
for i in range(int(TrainImages.shape[0]/BatchSize)):
inputs = torch.index_select(TrainImages,0,torch.linspace(i*BatchSize,(i+1)*BatchSize - 1,steps=BatchSize).long()).double()
inputs = inputs/255
inputs = inputs.to(device)
optimizer.zero_grad()
outputs = net(inputs)
loss = criterion(outputs, inputs)
loss.backward()
optimizer.step()
runningLoss += loss.item()
print('At Iteration : %d / %d ; Mean-Squared Error : %f'%(epoch + 1,iterations,runningLoss/
(TrainImages.shape[0]/BatchSize)))
print('Finished Training')
TestImg = torch.index_select(TestImages,0,torch.LongTensor([1]))
outputImg = net((TestImg.double().to(device))/255).data
outputImg = (outputImg*255).byte()
outputImg = outputImg.view(-1,28,28)
if use_gpu:
outputImg = outputImg.cpu()
TestImg = TestImg.view(-1,28,28)
fig = plt.figure()
plot=fig.add_subplot(1,2,1)
img = np.array(TestImg.numpy())[0]
plot.set_title('Original Image')
imgplot = plt.imshow(img,cmap='gray')
plot=fig.add_subplot(1,2,2)
img = np.array(outputImg.numpy())[0]
plot.set_title('Reconstructed Image')
imgplot = plt.imshow(img,cmap='gray')
plt.show()
# Remove Decoder and Add Classification Layer:
''''''''''''''''''''''''''''''''''''''''''''''''''
new_classifier = nn.Sequential(*list(net.children())[:-1])
net = new_classifier
net.add_module('classifier', nn.Sequential(nn.Linear(100, 10),nn.LogSoftmax(dim=1)))
print(net)
net = net.double().to(device)
cll_weights = copy.deepcopy(net[0][0].weight.data)
init_classifier_weights = copy.deepcopy(net.classifier[0].weight.data)
here i don't want to remove the decoder layer to add softmax layer to classify. INSTEAD OF REMOVING THE DECODER LAYER, I WANT TO USE THE DECODER LAYER AS CLASSIFIER. PLEASE HELP
Rest of the codes of this program are:
criterion = nn.NLLLoss()
optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9)
iterations = 30
BatchSize = 1000
for epoch in range(iterations):
runningLoss = 0
for i in range(int(TrainImages.shape[0]/BatchSize)):
inputs = torch.index_select(TrainImages,0,torch.linspace(i*BatchSize,(i+1)*BatchSize - 1,steps=BatchSize)
.long()).double()
labels = torch.index_select(TrainLabels,0,torch.linspace(i*BatchSize,(i+1)*BatchSize - 1,steps=BatchSize)
.long()).long()
inputs = inputs/255
inputs, labels = inputs.to(device), labels.to(device)
optimizer.zero_grad()
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
runningLoss += loss.item()
inputs = TestImages.double()/255
inputs = inputs.to(device)
outputs = net(inputs)
_, predicted = torch.max(outputs.data, 1)
if use_gpu:
predicted = predicted.cpu()
correct = 0
total = 0
total += TestLabels.size(0)
correct += (predicted == TestLabels).sum()
print('At Iteration: %d / %d ; Training Loss: %f ; Testing Acc: %f '%(epoch + 1,iterations,runningLoss/(TrainImages.shape[0]/BatchSize),(100 * correct/ float(total))))
print('Finished Training')
My question is whether the decoder of an Autoencoder is used to classify various classes. Is it possible to change the decoder's architecture so that the decoder gets transformed into a classifier? If anyone has an idea and code to transform the decoder into a classifier then please share and help me.
