Hello, I am quite new to pytorch. This is my first try and I am getting an error named forward() missing 1 required positional argument: ‘x’ and I don’t know why. If somebody could help me that would be appreciated. Here is the code:
First I load the data in and afterwards I make a directory to make the data a .pt tensor:
try:
    os.mkdir('data')
except:
    print('Directory exists')

# Save the files with leading zeros (e.g., ID00001.pt) and save in each file all three frequencies
# Also, create a text file that lists all the files available (all data). This is used to sort the dataset in the different sets
decimal_places = 6
os.path.join('ID_list.txt') #hier stond eerst os.remove()
ID_list = open('ID_list.txt','a') 
for sample in range(T20MHz.shape[1]):
    name = 'ID' + str(sample+1).zfill(decimal_places) +'.pt'
    ID_list.write(name + '\n')
    torch.save([T20MHz[:,sample], T100MHz[:,sample], T250MHz[:,sample]], 'data/' + name)
ID_list.close()

Then I load the data for trainign and validation:
import torch
from torch.utils import data

class Dataset(data.Dataset):
    
    'Characterizes a dataset for PyTorch'
    def __init__(self, list_IDs):
          'Initialization'
          self.list_IDs = list_IDs
    
    def __len__(self):
          'Denotes the total number of samples'
          return len(self.list_IDs)
    
    def __getitem__(self, index):
          'Generates one sample of data'
          # Select sample
          ID = self.list_IDs[index]
    
          # Load data and get label
          sample = torch.load('data/' + ID)
          T20MHz = torch.DoubleTensor(sample[0]).detach()
          T100MHz = torch.DoubleTensor(sample[1]).detach()
          T250MHz = torch.DoubleTensor(sample[2]).detach()
          return T20MHz, T100MHz, T250MHz
      

Then I define my CNN:
import torch.nn as nn
import torch.nn.functional as F

class model(nn.Module):
   def __init__(self):
       super(model, self).__init__()
       #1 input trace channel, 18 output channels and 3x3 square (?) convolution kernel        
       self.conv1 = nn.Conv1d(1, 3, kernel_size=3) 
       self.conv2 = nn.Conv1d(3, 6, kernel_size=6) 
       self.conv3 = nn.Conv1d(6, 12, kernel_size=12) 
       self.conv4 = nn.Conv1d(12,24, kernel_size=24) 
       self.conv5 = nn.Conv1d(24,48, kernel_size = 48)
       self.conv_drop = nn.Dropout2d()
       self.conv6_transpose = nn.ConvTranspose1d(48,24, kernel_size = 48)
       self.conv7_transpose = nn.ConvTranspose1d(24,12, kernel_size = 24)
       self.conv8_transpose = nn.ConvTranspose1d(12,6, kernel_size = 12)
       self.conv9_transpose=nn.ConvTranspose1d(6,3, kernel_size = 6)
       self.conv10_transpose = nn.ConvTranspose1d(3,1, kernel_size = 3)
      
      #self.fc1 = nn.Linear(1536, 72) #Fully-connected classifier layer
      #self.fc2 = nn.Linear(72, 19) #Fully-connected classifier layer
       self.bn1 = nn.BatchNorm1d(3)
       self.bn2 = nn.BatchNorm1d(6)
       self.bn3 = nn.BatchNorm1d(12)
       self.bn4 = nn.BatchNorm1d(24)
       self.bn5 = nn.BatchNorm1d(48)
       self.bn6 = nn.BatchNorm1d(24)
       self.bn7 = nn.BatchNorm1d(12)
       self.bn8 = nn.BatchNorm1d(6)
       self.bn9 = nn.BatchNorm1d(3)
       self.bn10 = nn.BatchNorm1d(1)
      
   
   def forward(self, x):
       #x = x.unsqueeze(1) # create an additional channel dimension (only 1 channel here).. We have a single sample, so add a fake batch dimension
      #downsample
       out = self.conv1(x)
       out = F.relu(out)
       out = self.bn1(out)
       
       out = self.conv2(out)
       out = F.relu(out)
       out = self.bn2(out)
       
       out = self.conv3(out)
       out = F.relu(out)
       out = self.bn3(out)
       
       out = self.conv4(out)
       out = F.relu(out)
       out = self.bn4(out)
       
       #bottleneck
       out = self.conv5(out)
       out = F.relu(out)
       out = self.bn5(out)
       out = self.conv_drop(out)
       
       #upsample
       out = self.conv6_transpose(out)
       out = self.conv6_drop(out)
       out = F.relu(out)
       out = out.unsqueeze(1)
       out = self.bn6(out)
       
       out = self.conv7_transpose(out)
       out = self.conv_drop(out)
       out = F.relu(out)
       out = out.unsqueeze(1)
       out = self.bn7(out)
       
       out = self.conv8_transpose(out)
       out = self.conv_drop(out)
       out = F.relu(out)
       out = out.unsqueeze(1)
       out = self.bn8(out)
       
       out = self.conv9_transpose(out)
       out = self.conv_drop(out)
       out = F.relu(out)
       out = out.unsqueeze(1)
       out = self.bn9(out)
       
       out = self.conv10_transpose(out)
       out = self.conv_drop(out)
       out = F.relu(out)
       out = out.unsqueeze(1)
       out = self.bn10(out)
       
       return out
       
       
model = model()

print(model)

I set my parameters and optimizer:
import torch
from torch.utils import data
import numpy as np
import torch.optim as optim


# Check if CUDA is available
use_cuda = torch.cuda.is_available()
device = torch.device("cuda:0" if use_cuda else "cpu")
# cudnn.benchmark = True


# Set training parameters
params = {'batch_size': 64,
          'shuffle': True,
          'num_workers': 6}
max_epochs = 100

# Load all the data from the txt file
file_IDs = open('ID_list.txt','r').read().split('\n')
file_IDs = file_IDs[:-1] # remove last line
complete_dataset = Dataset(file_IDs)


#%% Here we define a loss function and the optimizer
# create your loss function
def rmse(y, y_hat):
    """Compute root mean squared error"""
    return torch.sqrt(torch.mean((y - y_hat).pow(2)))

# create your optimizer
optimizer = optim.SGD(model.parameters(), lr=0.0003, momentum = 0.1)

And try to train it/test if it works in the first place
# Divide the dataset into the training and validation set
lengths = [int(np.ceil(len(complete_dataset)*0.8)), int(np.floor(len(complete_dataset)*0.1)), int(np.floor(len(complete_dataset)*0.1))]
training_set, validation_set, evaluation_set = torch.utils.data.random_split(complete_dataset, lengths)
training_generator = data.DataLoader(training_set, **params)
validation_generator = data.DataLoader(validation_set, **params)
evaluation_generator = data.DataLoader(evaluation_set, **params)


# instantiate the model to make it a double tensor
forward_model = model().double()
t20, t100 ,t250 = next(iter(training_generator))
one_prediction = forward_model(t20)

THE ERROR SEEMS TO APPEAR HERE IN THE LAST STEP.
I don’t know what to fizx so if anyone can help it would be lovely.
Thank!