File "C:\Anaconda\lib\site-packages\torch\nn\functional.py", line 2846, in cross_entropy return torch._C._nn.cross_entropy_loss(input, target, weight, _Reduction.get_enum(reduction), ignore_index, label_smoothing) ValueError: Expected input batch_

Hi, So I have the following code:

if name == ‘main’:
import torch
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np
import torch.nn as nn
import torch.nn as nn
import torchvision.transforms as ToTensor
from torch.utils.data import DataLoader
from torch import optim
from torch.utils.data import Dataset
from torchvision import datasets
from torch.autograd import Variable
import torch.nn.functional as F
import torch.optim as optim
import pandas as pd
import os
import csv
from csv import DictReader
from sklearn.utils import shuffle
import matplotlib.pyplot as plt
from torch.utils.data import Dataset, DataLoader
from sklearn.model_selection import train_test_split
import torch.utils.data as data

#path = r"E:\Andreea\an 2\tidaim\tidaim\tidaim\Benign\data\train"
#filedirectory = []
#for files in os.listdir(path):

filedirectorys = filedirectory.append(os.path.join(path,files))

#filedirectory

#dataset = ImageFolder(’‘E:\Andreea\tidaim\Benign\data\train’)

device = torch.device(“cuda:0” if torch.cuda.is_available() else “cpu”)
print(device)

transforms_train = transforms.Compose([transforms.Resize((68, 68)),
transforms.RandomRotation(10.),
transforms.ToTensor()])

transforms_test = transforms.Compose([transforms.Resize((68, 68)),
transforms.ToTensor()])

transforms_validation = transforms.Compose([transforms.Resize((68, 68)),
transforms.ToTensor()])

BATCH_SIZE = 10
LEARNING_RATE = 0.1
TRAIN_DATA_PATH = “./train”
TEST_DATA_PATH = “./test”
VALIDATION_DATA_PATH = “./validation”
TRANSFORM_IMG = transforms.Compose([
transforms.Resize(30),
transforms.CenterCrop(256),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225] )
])
#dataset = ImageFolder(’‘E:\Andreea\tidaim\Benign\data\train’)
#transform_train = transforms.Compose([

transforms.ToTensor(),

])

#transform_test = transforms.Compose([

transforms.ToTensor(),

])

train_data = torchvision.datasets.ImageFolder(root=TRAIN_DATA_PATH, transform=transforms_train)
train_data_loader = data.DataLoader(train_data, batch_size=BATCH_SIZE, shuffle=True, num_workers=4)
test_data = torchvision.datasets.ImageFolder(root=TEST_DATA_PATH, transform=transforms_test)
test_data_loader = data.DataLoader(test_data, batch_size=BATCH_SIZE, shuffle=True, num_workers=4)
validation_data = torchvision.datasets.ImageFolder(root=VALIDATION_DATA_PATH, transform=transforms_validation)
validation_loader = data.DataLoader(validation_data, batch_size=BATCH_SIZE, shuffle=True, num_workers=4)

net = nn.Sequential(nn.Linear(4624, 64),
nn.ReLU(),
nn.Linear(64, 128),
nn.ReLU(),
nn.Linear(128,3),
)

class MLP(nn.Module):
def init (self,n_hidden):
super(MLP, self).init()

     self.linear1 = torch.nn.Linear(4624, n_hidden)
     self.linear2 = torch.nn.Linear(n_hidden,3)

     self.activation = torch.nn.ReLU()


 def forward(self,x):
    
      a1 = self.activation(self.linear1(x))
      z2 = self.linear2(a1)


      return z2

net = MLP(64)

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters(), lr=1e-3)
num_epochs = 50

for epoch in range(num_epochs):
net.train()
train_loss=0
total= 0
correct = 0

  for batch_idx, (inputs, targets) in enumerate(train_data_loader):
         correct =  0 
         
         inputs = inputs.view(-1, 4624)
         optimizer.zero_grad()
         outputs = net(inputs)

         loss = criterion(outputs, targets)
         loss.backward()
         optimizer.step()

         train_loss += loss.item()
         _, predicted = torch.max(outputs.data, 1)
         total += targets.size(0)
         #correct = correct + predicted.eq(targets.data).cpu().sum 

print(‘Results after epoch %d’ % (epoch + 1))

print(‘Training loss: %.3f | Training Acc: %3.f%% )%d%d)’
% (train_loss / (batch_idx + 1), 100. *float(correct) / total, correct, total))

net.eval()

valid_loss = 0
correct = 0
total = 0

for batch_idx, (inputs, targets) in enumerate(validation_loader):
inputs, targets = Variable(inputs), Variable(targets)
inputs = inputs.view(-1, 4624)

  outputs = net(inputs)

  loss = criterion(outputs, targets)

  valid_loss += loss.item()
  _, predicted = torch.max(outputs.data, 1)
  total += targets.size(0)
  correct += predicted.eq(targets.data).cpu().sum()

print(‘Validation loss: %.3f | Validation Acc: %.3f%% (%d/%d)’
%(valid_loss / (batch_idx + 1), * float(correct)/ total, correct, total))

And I get the following error:

File “C:\Users\Ioana PMEC\Documents\TIDAIM\lab6\cnn2 (1).py”, line 137, in
loss = criterion(outputs, targets)

File “C:\Anaconda\lib\site-packages\torch\nn\modules\module.py”, line 1102, in _call_impl
return forward_call(*input, **kwargs)

File “C:\Anaconda\lib\site-packages\torch\nn\modules\loss.py”, line 1150, in forward
return F.cross_entropy(input, target, weight=self.weight,

File “C:\Anaconda\lib\site-packages\torch\nn\functional.py”, line 2846, in cross_entropy
return torch._C._nn.cross_entropy_loss(input, target, weight, _Reduction.get_enum(reduction), ignore_index, label_smoothing)

ValueError: Expected input batch_size (30) to match target batch_size (10).

Could someone please help me with this? Thanks

Are you hitting the same shape mismatch error as described in this post or is this a different one?