I am trying to build multilayer perceptron. I do not know why i am get this error please help (mat1 and mat2 shapes cannot be multiplied (64x784 and 16875x1020)). I am using a dataset of people classification from kaggle

tranformed =transforms.Compose([transforms.Resize((75,75)) ,
transforms.ToTensor()])

train_path =‘C:/Users/anask/Desktop/AI/NN/data/train’

test_path = ‘C:/Users/anask/Desktop/AI/NN/data/val’

train_loader=DataLoader(torchvision.datasets.ImageFolder(train_path,transform=tranformed) , batch_size= 14 , shuffle=True)
test_loader=DataLoader(torchvision.datasets.ImageFolder(test_path,transform=tranformed) , batch_size=14 ,shuffle=True)

class NN(nn.Module):
def init(self,num_classes=5):
super(NN,self).init()
self.l1=nn.Linear(37575 , 1020)
self.relu= nn.ReLU()
self.l2 = nn.Linear(255,5)

def forward(self,x):
out= x.view(x.size(0), -1)
out =self.l1(x)
out = self.relu(out)

return out

Hi Anas!

Your model expects an input with 3 * 75 * 75 = 16875 features, but
you are only passing in 784 features.

Print out the shape of the tensor that you are passing into your model.
I expect that it will be [64, 28, 28] (where you are passing in a batch
of 64 28x28 images that x.view(x.size(0), -1) turns into a tensor
of shape [64, 784]).

Best.

K. Frank

know I am getting this error

class NN(nn.Module):
def init(self,num_classes):
super(NN,self).init()

    self.l1=nn.Linear(3*75*75, 50)
    self.relu= nn.ReLU()
    self.l2 = nn.Linear(50,5)

def forward(self,x):
    
    out= x.view(x.size(0), -1)
    
    out =self.l1(x)
    out = self.relu(out)
    out=self.l2(out)
    return out

model=NN(num_classes=5)
optimizer=Adam(model.parameters(),lr=0.001,weight_decay=0.0001)
loss_function = nn.CrossEntropyLoss()
num_epochs=10
train_count=len(glob.glob(train_path+’//*.jpg’))
test_count=len(glob.glob(test_path+’/
/*.jpg’))

print_every = 5

Initialize the loss variables

running_loss = 0
train_losses, test_losses = [], []

Track the current training step, start at 0

steps = 0
for epochs in range(num_epochs):
epochs += 1
model.train()
for i, (images,labels) in enumerate(train_loader):
steps += 1
images=images.view(images.size(0),-1)
optimizer.zero_grad()
print(images.shape)
output=model(images)

    loss=loss_function(output,labels)
    loss.backward()
    optimizer.step()
    running_loss += loss.item()

  # Every 5 steps, evaluate the model
    if steps % print_every == 0:
        
        # Initialize loss and accuracy
        test_loss = 0
        accuracy = 0
        # Start the model evaluation
        model.eval()

        # Refine the accuracy of the prediction without updating the gradients
        with torch.no_grad():
            
            
             # Load in all of the image inputs and labels from the TEST loader 
            for i, (inputs, labels) in enumerate(test_loader):
                
                 # Load the inputs and labels to the already selected device
                images, labels = images, labels
               # images=images.reshape(images.shape[0],-1)
                images=images.view(images.size(0),-1)
                
                # Pass the images through the model, return the log probabilities of each label
                output = model(images)
                print(f"images: {images.shape}" )
                # Run the log probabilities through the criterion to get the output graph
                loss = loss_function(output, labels)
                # Add the actual loss number to the running loss total for the test batch
                test_loss += loss.item()
                # Return a new tensor with the true probabilities
                ps = torch.exp(output)
                # Return the largest probability and class of the new tensor along a given dimension
                top_p, top_class = ps.topk(1, dim=1)
                # Reshape the tensor to match the same shape as the top class
                equals = top_class == labels.view(*top_class.shape)
                # Compute the accuracy and add it to the running accuracy count for the test batch
                accuracy += torch.mean(equals.type(torch.FloatTensor)).item()
            # Append the training and testing losses
        train_losses.append(running_loss/len(train_loader))
        test_losses.append(test_loss/len(test_loader))  
        # Display the accuracy of the prediction with 3 digits in the fractional part of the decimal
        print(f"\n     Epoch {epoch}/{epochs}: "
           f"Train loss: {running_loss/print_every:.3f}.. "
           f"Test loss: {test_loss/len(test_loader):.3f}.. "
           f"Test accuracy: {accuracy/len(test_loader):.3f}\n")
          # Train the model
        running_loss = 0
        model.train()

     # After 5 training steps, start the next epoch
     # Break here in case the trainloader has remaining data
        break
  ..............................
   output......................

torch.Size([14, 16875])
torch.Size([14, 16875])
torch.Size([14, 16875])
torch.Size([14, 16875])
torch.Size([14, 16875])
images: torch.Size([14, 16875])
images: torch.Size([14, 16875])

ValueError Traceback (most recent call last)
in
72 print(f"images: {images.shape}" )
73 # Run the log probabilities through the criterion to get the output graph
—> 74 loss = loss_function(output, labels)
75 # Add the actual loss number to the running loss total for the test batch
76 test_loss += loss.item()

~\Miniconda3\lib\site-packages\torch\nn\modules\module.py in _call_impl(self, *input, **kwargs)
725 result = self._slow_forward(*input, **kwargs)
726 else:
→ 727 result = self.forward(*input, **kwargs)
728 for hook in itertools.chain(
729 _global_forward_hooks.values(),

~\Miniconda3\lib\site-packages\torch\nn\modules\loss.py in forward(self, input, target)
959
960 def forward(self, input: Tensor, target: Tensor) → Tensor:
→ 961 return F.cross_entropy(input, target, weight=self.weight,
962 ignore_index=self.ignore_index, reduction=self.reduction)
963

~\Miniconda3\lib\site-packages\torch\nn\functional.py in cross_entropy(input, target, weight, size_average, ignore_index, reduce, reduction)
2466 if size_average is not None or reduce is not None:
2467 reduction = _Reduction.legacy_get_string(size_average, reduce)
→ 2468 return nll_loss(log_softmax(input, 1), target, weight, None, ignore_index, None, reduction)
2469
2470

~\Miniconda3\lib\site-packages\torch\nn\functional.py in nll_loss(input, target, weight, size_average, ignore_index, reduce, reduction)
2259
2260 if input.size(0) != target.size(0):
→ 2261 raise ValueError(‘Expected input batch_size ({}) to match target batch_size ({}).’
2262 .format(input.size(0), target.size(0)))
2263 if dim == 2:

ValueError: Expected input batch_size (14) to match target batch_size (11).

please look into it. I do not understand it why this error

Hi Anas!

Does this help?

>>> torch.__version__
'1.9.0'
>>> torch.nn.CrossEntropyLoss() (torch.randn (14, 3), torch.randint (3, (11,)))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<path_to_pytorch_install>\torch\nn\modules\module.py", line 1051, in _call_impl
    return forward_call(*input, **kwargs)
  File "<path_to_pytorch_install>\torch\nn\modules\loss.py", line 1121, in forward
    ignore_index=self.ignore_index, reduction=self.reduction)
  File "<path_to_pytorch_install>\torch\nn\functional.py", line 2824, in cross_entropy
    return torch._C._nn.cross_entropy_loss(input, target, weight, _Reduction.get_enum(reduction), ignore_index)
ValueError: Expected input batch_size (14) to match target batch_size (11).

Best.

K. Frank