Hello Torchers,

I have an issue with the data input from the dataloader wrapper and its dimension not adapted to my CNN inputs.

I am using a 1D CNN for an interpolation problem right now. For debugging purpose I have set the input size to 1 node and the CNN must learn the identity function. (is that meaningful btw?, target/label = input for the identity function). I am also training by batches.

Let me tell you first what I am doing before I ask my questions -

The data is constructed with the following custom dataset constructor and dataloader wrapper:

```
class custom_dataset(torch.utils.data.Dataset):
'Characterizes a dataset for PyTorch'
def __init__(self, examples, labels):
'Initialization'
self.labels = labels
self.examples = examples
def __len__(self):
'Denotes the total number of samples'
return len(self.examples)
def __getitem__(self, index):
'Generates one sample of data'
# Select sample
# Load data and get label
X = self.examples [index]
y = self.labels [index]
return X, y
```

the wrapping happens here, in comments my data shape:

```
#with train_example.shape = torch.Size([57600])
#and train_label.shape = torch.Size([57600])
train_example = np.asarray(train_example)
train_label = np.asarray(train_label)
trainset = custom_dataset(train_example,train_label)
```

the CNN look like this:

```
class ConvNet1D(nn.Module):
def __init__(self,winlength_size, dropout=0.2):
super(ConvNet1D, self).__init__()
self.layer1 = nn.Sequential(
nn.Conv1d(1, 16, kernel_size=1, stride=1, padding=1),
nn.ReLU(),
nn.MaxPool1d(kernel_size=2, stride=1))
self.layer2 = nn.Sequential(
nn.Conv1d(16, 32, kernel_size=2, stride=1, padding=1),
nn.ReLU(),
nn.MaxPool1d(kernel_size=2, stride=1))
self.drop_out = nn.Dropout()
self.fc1 = nn.Linear(64, 20)
self.fc2 = nn.Linear(20, 1)
def forward(self, x):
out = self.layer1(x)
out = self.layer2(out)
out = out.reshape(out.size(0), -1)
out = self.drop_out(out)
out = self.fc1(out)
out = self.fc2(out)
return out
```

finally the training happens in the following snippet:

```
'''optimizer is adam'''
'''criterion is MSE loss, reduce = True'''
for batch_idx, data in enumerate(train_loader):
inputs = data[0]
labels = data[1]
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion (outputs, labels)
loss.backward()
optimizer.step()
```

first issue that came, the dimension : run with those snippets, with a batch_size of 16, the code would give me the following error:

expected 3-dimensional input for 3-dimensional weights 16, but got 1 dimensional input of size 16

by adding new dimensions on my input and label data, I could solve the 1D ConvNet input structure issue which must be 3 dimensional, for channel numbers and lengths.

It is done as following:

```
train_example = train_example.reshape(train_example[0].shape, 1,1)
train_labels = train_labels.reshape(train_labels[0].shape,1,1)
```

now I have the following mistake:

Using a target size: torch.Size([16,1,1]) that is different to the input size : torch.Size([16,1]). This will likely lead to incorrect results due to error.

The input dimension somehow reduced to 2, but I cannot change the input dimension because of the conditions on my inputs given by the convnet, so I need to work with the label dimensions:

```
train_labels = train_labels.reshape(train_labels[0].shape, 1)
```

here I would have a running code, but I donâ€™t have a clear convergence:

```
#3 firsts loss by batch:
3_losses= [0.31,0.181,0.143]
#!PSEUDO CODE! The rest:
the_rest = span(random between 0.005 and 0.09)
```

so I changed the CNN to

```
class ConvNet1D(nn.Module):
def __init__(self,winlength_size, dropout=0.2):
super(ConvNet1D, self).__init__()
self.layer1 = nn.Sequential(
nn.Conv1d(1, 16, kernel_size=1, stride=1, padding=1),
nn.ReLU(),
nn.MaxPool1d(kernel_size=2, stride=1))
self.layer2 = nn.Sequential(
nn.Conv1d(16, 32, kernel_size=2, stride=1, padding=1),
nn.ReLU(),
nn.MaxPool1d(kernel_size=2, stride=1))
self.drop_out = nn.Dropout()
self.fc1 = nn.Linear(64, 3000)
self.fc2 = nn.Linear(3000, 150)
self.fc3 = nn.Linear(150,1)
def forward(self, x):
out = self.layer1(x)
out = self.layer2(out)
out = out.reshape(out.size(0), -1)
out = self.drop_out(out)
out = F.relu(self.fc1(out))
out = F.relu(self.fc2(out))
out = self.fc3(out)
return out
```

to get better results.

now my questions:

- Is it okay for the CNN to have so many nodes in the fully connected layouts?
- Is it okay for the CNN to have more than 2 layers in the fully connected part?
- Is it okay to use relus functions on the fully connected part of the CNN?
- Can we expect better losses for the 1 node input identity CNN ? With the later CNN architecture I get values ranging from 0.0002 and 0.001, but should I not get better losses for my trivial problem?
- Is my identity function really that trivial?
- why do I have to change the dims of my labels? actually, the real question is, why did the dimension of inputs reduced to 2?

It is a long post it will interest someone, thanks in advance for reading me anyway.

Cheers

P.