I am aware that some others got a similar RuntimeError message, but unfortunately I was not able to fix it yet. Maybe someone else has a hint ?
I want to feed an input feature vector containing 16 features to the network, pass it through some hidden layers (just one for now) and finally get an output in one hot vector format.
I noticed that the variable data in the training step has a length of one while it should be 16. Trying to pass data[0] which has the desired length also doesnt work. Where is the problem. Thanks in advance
import os
import pandas as pd
import numpy as np
from torch.utils.data import Dataset, DataLoader, TensorDataset
from tqdm import tqdm
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch import Tensor
from natsort import os_sorted

# Device configuration
device = torch.device('cpu')

# Hyper-parameters 
input_size = 16
hidden_size = 32
num_classes = 2
num_epochs = 5
batch_size = 1
learning_rate = 0.001
Train_Val_Pct = 0.1 #distribution of learning and testing data in percent

class Features(Dataset):
    good_data = 'Preprocessed_Data/Balanced_Data/Good'
    bad_data = 'Preprocessed_Data/Balanced_Data/Bad'
    labels = {good_data: 0, bad_data: 1}
    samples = []
    
    goodcount = 0
    badcount = 0
    
    def __init__(self):
        for label in self.labels:
            print(label)
            for run in os_sorted(os.listdir(label)): #os_sorted needed to go through data as it is listed by windows (14,101,165,...) otherwise (101,14,165,...)
                path = os.path.join(label, run)
                print(path)
                data = pd.read_csv(path,header = None)
                self.samples.append([np.array(data), np.eye(2)[self.labels[label]]])
                
                if label == self.good_data:
                    self.goodcount += 1
                elif label == self.bad_data:
                    self.badcount += 1
        #np.random.shuffle(self.samples)
        np.save("samples.npy", self.samples)        
    
    def __len__(self):
        return len(self.samples)
    
    def __getitem__(self, idx):
        return self.samples[idx]
    
class Net(nn.Module):
    def __init__(self, input_size, hidden_size, num_classes):
        super().__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.relu1 = nn.ReLU() #activation function
        self.fc2 = nn.Linear(hidden_size, hidden_size)
        self.relu2 = nn.ReLU()
        self.fc3 = nn.Linear(hidden_size, num_classes)

    def forward(self, x): #x is a batch of inputs
        out = self.fc1(x)
        out = self.relu1(out)
        out = self.fc2(out)
        out = self.relu2(out)
        out = self.fc3(out)
        return F.softmax(x, dim=1)  #out is the number of classes
    
net = Net(input_size, hidden_size, num_classes).to(device)

samples = np.load('samples.npy',allow_pickle=True)

X = torch.Tensor([i[0] for i in samples])
y = torch.Tensor([i[1] for i in samples])

size = int(Train_Val_Pct*len(X))

train_X = X[:-size]
train_y = y[:-size]

test_X = X[-size:]
test_y = y[-size:]

trainset = TensorDataset(Tensor(train_X), Tensor(train_y))
testset = TensorDataset(Tensor(test_X), Tensor(test_y))

trainloader = DataLoader(trainset,batch_size=batch_size,shuffle=True)
testloader = DataLoader(testset,batch_size=batch_size,shuffle=False)

criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(), lr=learning_rate)  

#Train the model
total_step = len(trainloader)
for epoch in range(num_epochs):
    for i, (data, labels) in enumerate(trainloader):  
        # Move tensors to the configured device
        data = data[0].to(device)
        labels = labels[0].to(device)
        
        # Forward pass
        outputs = net(data)
        loss = criterion(outputs, labels)
        
        # Backward and optimize
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    print(loss)
    

# Test the model
# In test phase, we don't need to compute gradients (for memory efficiency)
with torch.no_grad():
    correct = 0
    total = 0
    for data, labels in testloader:
        data = data.to(device)
        labels = labels.to(device)
        outputs = net(data)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    print("Accuracy:", round(correct/total,3))

# Save the model checkpoint
torch.save(net.state_dict(), 'net.ckpt')