Hi,

I have constructed a neural network with as follows:

class Network(nn.Module):

```
class Network(nn.Module):
def __init__(self):
super().__init__()
self.fc1=nn.Linear(3840, 256)
self.fc2=nn.Linear(256,128)
self.fc3=nn.Linear(128,64)
self.fc4=nn.Linear(64,1)
def forward(self,x):
x=F.relu(self.fc1(x))
x=F.relu(self.fc2(x))
x=F.relu(self.fc3(x))
x=self.fc4(x)
return x
```
Here I expect the output to be just one value. However, I get the above error while calculating the crossentropyloss. When i checked my target , it has values ranging from 0 to 7 indicating the number of classes to be 8. I am providing a one dimensional vector as my target and converting it into tensor using
```

Variable(torch.FloatTensor(labels).long(),requires_grad=False)

```
However, when I changed the number of output nodes in my network to 8, my network is training properly.
Can anyone tell me why this problem is occuring?
My whole code is:
```

class Network(nn.Module):

```
def __init__(self):
super().__init__()
self.fc1=nn.Linear(3840, 256)
self.fc2=nn.Linear(256,128)
self.fc3=nn.Linear(128,64)
self.fc4=nn.Linear(64,1)
def forward(self,x):
x=F.relu(self.fc1(x))
x=F.relu(self.fc2(x))
x=F.relu(self.fc3(x))
x=self.fc4(x)
return x
```

data1 = pd.read_csv(“features_cnormal.csv”, index_col=0, header=0)

X = data1.values

target = pd.read_csv(“y.csv”)

y=target.values

model = Network()

criterion = nn.CrossEntropyLoss()

optimizer = optim.SGD(model.parameters(), lr = 0.01)

scaler = preprocessing.StandardScaler()

Xs = scaler.fit_transform(X)

Xtrain, ytrain = Xs, y

XTrain = torch.from_numpy(Xtrain).type(torch.FloatTensor)

YTrain = torch.from_numpy(np.array(ytrain).reshape((-1, 1))).type(torch.FloatTensor)

train = torch.utils.data.TensorDataset(XTrain, YTrain)

train_loader = torch.utils.data.DataLoader(train, batch_size=10, shuffle=True)

#print(data for i, data in enumerate(train_loader))

epochs = 100

for e in range(epochs):

running_loss = 0

for i, data in enumerate(train_loader):

inputs, labels = data

```
X1, Y1 = Variable(torch.FloatTensor(inputs),requires_grad=False), \
Variable(torch.FloatTensor(labels).long(),requires_grad=False)
output = model(X1)
Y1=Y1.view(-1)
loss = criterion(output, Y1)
optimizer.zero_grad()
loss.backward()
optimizer.step()
running_loss += loss.item()
else:
print(f"Training loss: {running_loss/len(train_loader)}")
```