title: TypeError: new(): argument 'size' must be tuple of ints, but found element of type NoneType at pos 2 when using pytorch, using nn.linear
body: <p>File &quot;C:\Users\J2\Desktop\Pytorchseries\thenn.py&quot;, line 50, in 
  net = Net()
  TypeError: new(): argument 'size' must be tuple of ints, but found element of type NoneType at pos 2</p>
  <p>If it helps I was following the sentdex pytorch tutorial. Any help would be appreciated. I am new to machine learning, and I was hoping that this would work. Please help me out!</p>
  <pre><code>
  import numpy as np
  import torch
  import torch.nn as nn
  import torch.nn.functional as F
  import matplotlib.pyplot as plt
  import tqdm
  
  training_data = np.load('training_data.npy', allow_pickle=True)
  print(len(training_data))
  
  X = torch.Tensor([i[0] for i in training_data]).view(-1,50,50)
  X = X/255.0
  y = torch.Tensor([i[1] for i in training_data])
  
  plt.imshow(X[0], cmap='gray')
  print(y[0])
  
  class Net(nn.Module):
      def __init__(self):
          super().__init__() # just run the init of parent class (nn.Module)
          self.conv1 = nn.Conv2d(1, 32, 5) # input is 1 image, 32 output channels, 5x5 kernel / window
          self.conv2 = nn.Conv2d(32, 64, 5) # input is 32, bc the first layer output 32. Then we say the output will be 64 channels, 5x5 kernel / window
          self.conv3 = nn.Conv2d(64, 128, 5)
  
          x = torch.randn(50,50).view(-1,1,50,50)
          self._to_linear = None
          self.convs(x)
  
          self.fc1 = nn.Linear(self._to_linear, 512) #flattening.
          self.fc2 = nn.Linear(512, 2) # 512 in, 2 out bc we're doing 2 classes (dog vs cat).
          
  
      def convs(self, x):
          # max pooling over 2x2
          x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
          x = F.max_pool2d(F.relu(self.conv2(x)), (2, 2))
          x = F.max_pool2d(F.relu(self.conv3(x)), (2, 2))
  
      def forward(self, x):
          x = self.convs(x)
          x = x.view(-1, self._to_linear)  # .view is reshape ... this flattens X before 
          x = F.relu(self.fc1(x))
          x = self.fc2(x) # bc this is our output layer. No activation here.
          return F.softmax(x, dim=1)
  
          if self._to_linear is None:
              self._to_linear = x[0].shape[0]*x[0].shape[1]*x[0].shape[2]
          return x
  
  net = Net()
  print(net)
  
  import torch.optim as optim
  
  optimizer = optim.Adam(net.parameters(), lr=0.001)
  loss_function = nn.MSELoss()
  
  X = torch.Tensor([i[0] for i in training_data]).view(-1,50,50)
  X = X/255.0
  y = torch.Tensor([i[1] for i in training_data])
  
  VAL_PCT = 0.1  # lets reserve 10% of our data for validation
  val_size = int(len(X)*VAL_PCT)
  print(val_size)
  
  train_X = X[:-val_size]
  train_y = y[:-val_size]
  
  test_X = X[-val_size:]
  test_y = y[-val_size:]
  
  print(len(train_X), len(test_X))
  
  BATCH_SIZE = 100
  EPOCHS = 1
  
  for epoch in range(EPOCHS):
      for i in tqdm(range(0, len(train_X), BATCH_SIZE)): # from 0, to the len of x, stepping BATCH_SIZE at a time. [:50] ..for now just to dev
          #print(f&quot;{i}:{i+BATCH_SIZE}&quot;)
          batch_X = train_X[i:i+BATCH_SIZE].view(-1, 1, 50, 50)
          batch_y = train_y[i:i+BATCH_SIZE]
  
          net.zero_grad()
  
          outputs = net(batch_X)
          loss = loss_function(outputs, batch_y)
          loss.backward()
          optimizer.step()    # Does the update
  
      print(f&quot;Epoch: {epoch}. Loss: {loss}&quot;)
  
  correct = 0
  total = 0
  with torch.no_grad():
      for i in tqdm(range(len(test_X))):
          real_class = torch.argmax(test_y[i])
          net_out = net(test_X[i].view(-1, 1, 50, 50))[0]  # returns a list, 
          predicted_class = torch.argmax(net_out)
  
          if predicted_class == real_class:
              correct += 1
          total += 1
  print(&quot;Accuracy: &quot;, round(correct/total, 3))
  
  
  </code></pre>