Hy all. i have this train class
import torch
import torch.nn as nn
from torch.optim import SGD, Adam
from torch.optim.lr_scheduler import StepLR
import numpy as np
from dataset import Dataset
from net import *
from torch.utils.data import DataLoader
from torchnet.meter import AverageValueMeter
from torchnet.logger import VisdomPlotLogger, VisdomSaver


def train(model, train_loader, valid_loader, exp_name = "MLP121",  lr=0.00001, epochs=1000, wd = 0.000001):

    criterionX = nn.MSELoss()
    criterionZ = nn.MSELoss()
    optimizer = Adam(params=model.parameters(),lr = lr, weight_decay=wd)
    scheduler = StepLR(optimizer, step_size=100, gamma=0.5)#per ogni 100 epochs, lr si divide per due

    # meters
    lossX_meter = AverageValueMeter()
    lossZ_meter = AverageValueMeter()
    lossT_meter = AverageValueMeter()

    # device
    device = "cuda" if torch.cuda.is_available() else "cpu"

    model.to(device)
    loader = {"train": train_loader, "test": valid_loader}


    loss_X_logger = VisdomPlotLogger('line', env=exp_name, opts={'title': 'LossX', 'legend': ['train', 'test']})
    loss_Z_logger = VisdomPlotLogger('line', env=exp_name, opts={'title': 'LossZ', 'legend': ['train', 'test']})
    loss_T_logger = VisdomPlotLogger('line', env=exp_name, opts={'title': 'Total_Loss', 'legend': ['train', 'test']})
    visdom_saver = VisdomSaver(envs=[exp_name])

    last_best_loss = np.inf #for early stopping for best model
    for e in range(epochs):
        for mode in ["train", "test"]:

            lossX_meter.reset()
            lossZ_meter.reset()
            lossT_meter.reset()
            model.train() if mode == "train" else model.eval()
            with torch.set_grad_enabled(mode == "train"):  # abilitiamo i gradienti in training

                for i, batch in enumerate(loader[mode]):
                    x = batch["Array"].to(device)
                    dx = batch['Movement'][:,0].float().to(device)
                    dz = batch['Movement'][:,1].float().to(device)

                    output = model(x)


                    #out1, out2 = model(x)
                    out1, out2 = output[:,0], output[:,1]

                    #out2 = out2 / torch.sqrt((out2 ** 2).sum(1)).view(-1, 1)

                    l1 = criterionX(out1, dx)
                    l2 = criterionZ(out2, dz)
                    loss = l1+l2

                    if mode == "train":
                        optimizer.zero_grad()
                        loss.backward()
                        optimizer.step()

                    else:
                        if loss < last_best_loss:
                            torch.save(model.state_dict(), 'Best_%s.pth' % exp_name)
                            last_best_loss = loss



                    n = x.shape[0]  # numero di elementi nel batch


                    lossX_meter.add(l1.item() * n, n)#update meter to ploot
                    lossZ_meter.add(l2.item() * n, n)
                    lossT_meter.add(loss.item()* n, n)


                    if mode == "train":

                        loss_X_logger.log(e + (i + 1) / len(loader[mode]), lossX_meter.value()[0], name=mode)
                        loss_Z_logger.log(e + (i + 1) / len(loader[mode]), lossZ_meter.value()[0], name=mode)
                        loss_T_logger.log(e + (i + 1) / len(loader[mode]), lossT_meter.value()[0], name=mode)

            loss_X_logger.log(e + (i + 1) / len(loader[mode]), lossX_meter.value()[0], name=mode)
            loss_Z_logger.log(e + (i + 1) / len(loader[mode]), lossZ_meter.value()[0], name=mode)
            loss_T_logger.log(e + (i + 1) / len(loader[mode]), lossT_meter.value()[0], name=mode)


        scheduler.step()

        #save visdom environment
        visdom_saver.save()

        # conserviamo solo l'ultimo modello sovrascrivendo i vecchi, salviamo anche il best di volta in volta
        torch.save(model.state_dict(), '%s.pth' % exp_name)



    return model





def start_all():

    model = DeepMLPRegressor(15, 2)



    #Define train dataset and loader
    #
    train_dataset = Dataset('../../Dataset/121/','121_Train.csv', 'raw/')
    valid_dataset = Dataset('../../Dataset/121/','121_Validation.csv', 'raw/')


    train_loader = DataLoader(train_dataset, batch_size=16, num_workers=2)
    valid_loader = DataLoader(valid_dataset, batch_size=16, num_workers=2)

    model_trained = train(model, train_loader, valid_loader, exp_name="MLP_121_interpolated_datas+Time", epochs=700)



And my dataset class:
from torch.utils.data.dataset import Dataset
import numpy as np
import pandas as pd
from os import path
import torch

# CREAZIONE DELLA CLASSE CHE CI PERMETTE DI CARICARE LE FEATURES

class Dataset(Dataset):

    """
    Carica il dataset per l'eseprimento  che ci permette di caricare le feature
    """

    def __init__(self, base_path, csv_Name, pathNPArray):

        """Input:
            dataset CSV
        """
        self.base_path = base_path
        path_finale = path.join(base_path, csv_Name)
        self.pathNPArry = pathNPArray
        self.file = pd.read_csv(path_finale)

    def __getitem__(self, index):
        names = []
        array = torch.empty(15,1)
        coordinateX = 0
        coordinateY = 0
        if index == 0 or index <3:
            idx, name, coordinateX, coordinateY = self.file.iloc[index]
            name = int(name)
            names.append(name)
            array1 = torch.from_numpy(np.load(self.base_path +  self.pathNPArry + str(name) + ".npy").astype(np.float32))
            array2 = torch.from_numpy(np.load(self.base_path +  self.pathNPArry + str(name) + ".npy").astype(np.float32))
            array3 = torch.from_numpy(np.load(self.base_path +  self.pathNPArry + str(name) + ".npy").astype(np.float32))

            array = torch.cat((array1, array2, array3))

        elif index == len(self.file)-1  or (len(self.file)-1 > index  and index <= len(self.file)-4):
            _, name, coordinateX, coordinateY = self.file.iloc[index]
            name = int(name)
            names.append(name)
            array1 = torch.from_numpy(np.load(self.base_path + self.pathNPArry + str(name) + ".npy").astype(np.float32))
            array2 = torch.from_numpy(np.load(self.base_path + self.pathNPArry + str(name) + ".npy").astype(np.float32))
            array3 = torch.from_numpy(np.load(self.base_path + self.pathNPArry + str(name) + ".npy").astype(np.float32))
            array = torch.cat((array1, array2, array3))

        elif index == 3933:
            _, name1, coordinateX1, coordinateY1 = self.file.iloc[index]
            _, name2, coordinateX2, coordinateY2 = self.file.iloc[index+1]
            _, name3, coordinateX3, coordinateY3 = self.file.iloc[index+2]
            name1 = int(name1)
            name2 = int(name2)
            name3 = int(name3)
            names.append(name1)
            names.append(name2)
            names.append(name3)
            array1 = torch.from_numpy(np.load(self.base_path + self.pathNPArry + str(name1) + ".npy").astype(np.float32))
            array2 = torch.from_numpy(np.load(self.base_path + self.pathNPArry + str(name2) + ".npy").astype(np.float32))
            array3 = torch.from_numpy(np.load(self.base_path + self.pathNPArry + str(name3) + ".npy").astype(np.float32))
            array = torch.cat((array1, array2, array3))
            coordinateX = np.mean([coordinateX1, coordinateX2, coordinateX3])
            coordinateY = np.mean([coordinateY1, coordinateY2, coordinateY3])

        else:
            pass
        return {"ID":names, "Array": array,'Movement': np.array([coordinateX, coordinateY], dtype= 'float')}


    def __len__(self):
        return len(self.file)

This is my net class:
from torch import nn
class DeepMLPRegressor(nn.Module):
    def __init__(self, in_features, out_features):
        """Costruisce un regressore MLP.
            Input:
                in_features: numero di feature in input
                out_classes: numero di feature in uscita
                hidden_units: numero di unità nel livello nascosto """
        super(DeepMLPRegressor, self).__init__()

        self.model = nn.Sequential(nn.Linear(in_features, 32),
                                   nn.ReLU(),
                                   nn.Linear(32, 64),
                                   nn.ReLU(),
                                   nn.Linear(64, 128),
                                   nn.ReLU(),
                                   nn.Linear(128, 64),
                                   nn.ReLU(),
                                   nn.Linear(64, 32),
                                   nn.ReLU(),
                                   nn.Linear(32, out_features))

    def forward(self, x):
        return self.model(x)

I have a dataset with numpy arrays of 5 element each one.
i would load three array as one element and i have this error.
Every array contains 5 element and i 'm sure because in previous experiments (when in dataloader i loaded one single array ) i had no runtime error.
can you help me? Please