多层神经网络对具有 pyTorch 错误的图像进行分类

Question

I need to classify flower images into 7 classes. I initialized batch_size as 128 and image_size as 32. It is obligatory to use Linear layers so I created a Multi Layer Neural Network class as it is seen below:

number_of_classes = 7
input_dim = image_size
num_hidden = [batch_size * 3 * image_size ,4,number_of_classes]
output_dim = 1

class MultiLayerNeuralNetwork(nn.Module):

    def __init__(self,input_dim, num_hidden, output_dim):
        super(MultiLayerNeuralNetwork, self).__init__()

        #first layer
        self.first_layer = nn.Linear(input_dim, num_hidden[0])

        # initialize weight and bias
        nn.init.kaiming_uniform_(self.first_layer.weight, nonlinearity="relu")
        nn.init.constant_(self.first_layer.bias.data, 0)
        print(self.first_layer)
        #initialize hidden layers 
        self.hidden = nn.ModuleList()
        for k in range(len(num_hidden)-1):
            self.hidden.append(nn.Linear(num_hidden[k], num_hidden[k+1]))

            # initialize weight and bias in hidden layer
            nn.init.kaiming_uniform_(self.hidden[k].weight, nonlinearity="relu")
            nn.init.constant_(self.hidden[k].bias.data, 0)
            print(self.hidden[k])

        # output layer
        self.output_layer = nn.Linear(num_hidden[-1], output_dim)

        # initialize weight and bias
        nn.init.kaiming_uniform_(self.output_layer.weight, nonlinearity="relu")
        nn.init.constant_(self.output_layer.bias.data, 0)

        print(self.output_layer)
       
    def forward(self, x):
        x = torch.nn.functional.relu(self.first_layer(x))
        print("x:", x.shape)
        for layer in self.hidden:
            x = torch.nn.functional.relu(layer(x))
        x = torch.nn.functional.sigmoid(self.output_layer(x))

        return x
       
multi_layer_nn_model = MultiLayerNeuralNetwork(input_dim, num_hidden, output_dim)

print(multi_layer_nn_model)

But, when I tried to train this model, I got this error message: "only batches of spatial targets supported (3D tensors) but got targets of size: : [128]"

At this line:

loss = loss_function(outputs, labels)

I got these shapes:

outputs torch.Size([128, 3, 32, 1])

labels torch.Size([128])

How can I handle this situation?

Note: Also, my outputs are between [0,2], but they have to be between [1-7]. How can I handle this too?

Thanks a lot.

Answer 1

Here are some fixes:

1. Output dimention is set to 1, so final layer projects into 1 dimention instead of 7.
2. Since you are using just linear layers, the input needs to be converted into 2 dimentional vector of shape: [batch_size, 3 * image_width * image_height]
3. The layers need to be modified accordingly as well.

Below is a modified version of your code snippet. Modify it according to your needs.

import torch.nn as nn
import torch

number_of_classes = 7
batch_size, image_size = 128, 32
input_dim = 3 * image_size * image_size
num_hidden = [3 * image_size, 4, number_of_classes]
output_dim = 7

class MultiLayerNeuralNetwork(nn.Module):

    def __init__(self,input_dim, num_hidden, output_dim):
        super(MultiLayerNeuralNetwork, self).__init__()

        #first layer
        self.first_layer = nn.Linear(input_dim, num_hidden[0])

        # initialize weight and bias
        nn.init.kaiming_uniform_(self.first_layer.weight, nonlinearity="relu")
        nn.init.constant_(self.first_layer.bias.data, 0)
        # print(self.first_layer)
        #initialize hidden layers 
        self.hidden = nn.ModuleList()
        for k in range(len(num_hidden)-1):
            self.hidden.append(nn.Linear(num_hidden[k], num_hidden[k+1]))

            # initialize weight and bias in hidden layer
            nn.init.kaiming_uniform_(self.hidden[k].weight, nonlinearity="relu")
            nn.init.constant_(self.hidden[k].bias.data, 0)
            print(self.hidden[k])

        # output layer
        self.output_layer = nn.Linear(num_hidden[-1], output_dim)

        # initialize weight and bias
        nn.init.kaiming_uniform_(self.output_layer.weight, nonlinearity="relu")
        nn.init.constant_(self.output_layer.bias.data, 0)

        print(self.output_layer)
       
    def forward(self, x):
        cur_shape = x.shape
        print(cur_shape, 'is shape')
        x = torch.nn.functional.relu(self.first_layer(x.view(cur_shape[0], -1)))
        print("x:", x.shape)
        for layer in self.hidden:
            x = torch.nn.functional.relu(layer(x))
        print(f'Before sigmoid: {self.output_layer(x).shape}')
        x = torch.nn.functional.sigmoid(self.output_layer(x))

        return x
       
multi_layer_nn_model = MultiLayerNeuralNetwork(input_dim, num_hidden, output_dim)

# print(multi_layer_nn_model)
x = torch.rand(batch_size, 3, image_size, image_size)
y = multi_layer_nn_model(x)
print('x', x.shape, 'y', y.shape)

Gives the following output:

Linear(in_features=96, out_features=4, bias=True)
Linear(in_features=4, out_features=7, bias=True)
Linear(in_features=7, out_features=7, bias=True)
torch.Size([128, 3, 32, 32]) is shape
x: torch.Size([128, 96])
Before sigmoid: torch.Size([128, 7])

x torch.Size([128, 3, 32, 32]) y torch.Size([128, 7])

PS. I feel crossentropy loss might be a better choice for this case.

Answer 2

I think it should help. I have included comments in the code for brevity. I have used CrossEntropy loss which is generally used for Multiclass classification problems. Notice that NLLLoss can also be used but it operates on the output of log_softmax. Hopefully it helps.

Setting up the necessary parameters

number_of_classes = 7
input_dim = 1024
image_size = (32, 32)
# change the batch size if required
batch_size = 8
# you can change the num_hidden size according to the requirements
num_hidden = [input_dim*3 ,input_dim*4, input_dim, 256, 64]

Model Definition

class MultiLayerNeuralNetwork(nn.Module):
    def __init__(self,input_dim, num_hidden, output_dim):
        super(MultiLayerNeuralNetwork, self).__init__()
        #first layer
        self.first_layer = nn.Linear(input_dim, num_hidden[0])
        # initialize weight and bias
        nn.init.kaiming_uniform_(self.first_layer.weight, 
        nonlinearity="relu")
        nn.init.constant_(self.first_layer.bias.data, 0)

        #initialize hidden layers 
        self.hidden = nn.ModuleList()
        for k in range(0, len(num_hidden)-1):
            self.hidden.append(nn.Linear(num_hidden[k], num_hidden[k+1]))
            # initialize weight and bias in hidden layer
            nn.init.kaiming_uniform_(self.hidden[k].weight, 
            nonlinearity="relu")
            nn.init.constant_(self.hidden[k].bias.data, 0)
  

        # output layer
        self.output_layer = nn.Linear(num_hidden[-1], output_dim)

        # initialize weight and bias
        nn.init.kaiming_uniform_(self.output_layer.weight, 
        nonlinearity="relu")
        nn.init.constant_(self.output_layer.bias.data, 0)


    def forward(self, x):
        x = self.first_layer(x)
        for layer in self.hidden:
            x = layer(x)
        return self.output_layer(x)

Model Instance Declaration

# number of classes are 7, so is the output_dim
output_dim = 7
model = MultiLayerNeuralNetwork(input_dim, num_hidden, output_dim)
print(model)

Model Summary

MultiLayerNeuralNetwork(
(first_layer): Linear(in_features=1024, out_features=3072, bias=True)
(hidden): ModuleList(
    (0): Linear(in_features=3072, out_features=4096, bias=True)
    (1): Linear(in_features=4096, out_features=1024, bias=True)
    (2): Linear(in_features=1024, out_features=256, bias=True)
    (3): Linear(in_features=256, out_features=64, bias=True)
)
(output_layer): Linear(in_features=64, out_features=7, bias=True)
)

Feeding a batch to the model

samples = torch.from_numpy(np.random.randn(8, 32, 32)).float()
labels = torch.tensor([1, 5, 1, 2, 4, 1, 3, 6]).long()

# notice that input should be vectorized while batch dimension is left 
alone
# input shape is torch.Size([8, 1024])
samples = samples.view(sample.shape[0], -1)
# Forward Pass
output = model(samples)
# output shape is torch.Size([8, 7]), 
# 1st dimension represent the batch dimension, A batch of size 8
# notice the 2nd dimension, 7 classes.
 

Calculating the loss

loss_fn = nn.CrossEntropyLoss()
loss = loss_fn(output, labels)
# loss for our dummy batch comes out to be tensor(10.3904, grad_fn= 
# <NllLossBackward0>)

Prediction

preds = torch.argmax(torch.softmax(output, axis=1), axis=1)