title: Pytorch RuntimeError: expected scalar type Float but found Byte
body: <p>I am working on the classic example with digits. I want to create a my first neural network that predict the labels of digit images {0,1,2,3,4,5,6,7,8,9}. So the first column of <code>train.txt</code> has the labels and all the other columns are the features of each label. I have defined a class to import my data:</p>
  <pre><code>class DigitDataset(Dataset):
      &quot;&quot;&quot;Digit dataset.&quot;&quot;&quot;
  
      def __init__(self, file_path, transform=None):
          &quot;&quot;&quot;
          Args:
              csv_file (string): Path to the csv file with annotations.
              root_dir (string): Directory with all the images.
              transform (callable, optional): Optional transform to be applied
                  on a sample.
          &quot;&quot;&quot;
          self.data = pd.read_csv(file_path, header = None, sep =&quot; &quot;)
          self.transform = transform
  
      def __len__(self):
          return len(self.data)
  
      def __getitem__(self, idx):
          if torch.is_tensor(idx):
              idx = idx.tolist()
  
          labels = self.data.iloc[idx,0]
          images = self.data.iloc[idx,1:-1].values.astype(np.uint8).reshape((1,16,16))
  
          if self.transform is not None:
              sample = self.transform(sample)
          return images, labels
  </code></pre>
  <p>And then I am running these commands to split my dataset into batches, to define a model and a loss:</p>
  <pre><code>train_dataset = DigitDataset(&quot;train.txt&quot;)
  train_loader = DataLoader(train_dataset, batch_size=64,
                          shuffle=True, num_workers=4)
  
  # Model creation with neural net Sequential model
  model=nn.Sequential(nn.Linear(256, 128), # 1 layer:- 256 input 128 o/p
                      nn.ReLU(),          # Defining Regular linear unit as activation
                      nn.Linear(128,64),  # 2 Layer:- 128 Input and 64 O/p
                      nn.Tanh(),          # Defining Regular linear unit as activation
                      nn.Linear(64,10),   # 3 Layer:- 64 Input and 10 O/P as (0-9)
                      nn.LogSoftmax(dim=1) # Defining the log softmax to find the probablities 
  for the last output unit 
                    ) 
  
  # defining the negative log-likelihood loss for calculating loss
  criterion = nn.NLLLoss()
  
  images, labels = next(iter(train_loader))
  images = images.view(images.shape[0], -1)
  
  logps = model(images) #log probabilities
  loss = criterion(logps, labels) #calculate the NLL-loss
  </code></pre>
  <p>And I take the error:</p>
  <pre><code>---------------------------------------------------------------------------
     RuntimeError                              Traceback (most recent call last) 
      &lt;ipython-input-2-7f4160c1f086&gt; in &lt;module&gt;
       47 images = images.view(images.shape[0], -1)
       48 
  ---&gt; 49 logps = model(images) #log probabilities
       50 loss = criterion(logps, labels) #calculate the NLL-loss
  
  ~/anaconda3/lib/python3.8/site-packages/torch/nn/modules/module.py in _call_impl(self, 
  *input, **kwargs)
      725             result = self._slow_forward(*input, **kwargs)
      726         else:
  --&gt; 727             result = self.forward(*input, **kwargs)
      728         for hook in itertools.chain(
      729                 _global_forward_hooks.values(),
  
  ~/anaconda3/lib/python3.8/site-packages/torch/nn/modules/container.py in forward(self, input)
      115     def forward(self, input):
      116         for module in self:
  --&gt; 117             input = module(input)
      118         return input
      119 
  
  ~/anaconda3/lib/python3.8/site-packages/torch/nn/modules/module.py in _call_impl(self, 
  *input, **kwargs)
      725             result = self._slow_forward(*input, **kwargs)
      726         else:
  --&gt; 727             result = self.forward(*input, **kwargs)
      728         for hook in itertools.chain(
      729                 _global_forward_hooks.values(),
  
   ~/anaconda3/lib/python3.8/site-packages/torch/nn/modules/linear.py in forward(self, input)
       91 
       92     def forward(self, input: Tensor) -&gt; Tensor:
  ---&gt; 93         return F.linear(input, self.weight, self.bias)
       94 
       95     def extra_repr(self) -&gt; str:
  
   ~/anaconda3/lib/python3.8/site-packages/torch/nn/functional.py in linear(input, weight, bias)
     1688     if input.dim() == 2 and bias is not None:
     1689         # fused op is marginally faster
  -&gt; 1690         ret = torch.addmm(bias, input, weight.t())
     1691     else:
     1692         output = input.matmul(weight.t())
  
  RuntimeError: expected scalar type Float but found Byte
  </code></pre>
  <p>Do you know what is wrong? Thank you for your patience and help!</p>