title: Pytorch getting RuntimeError: Found dtype Double but expected Float
body: <p>I am trying to implement a neural net in PyTorch but it doesn't seem to work. The problem seems to be in the training loop. I've spend several hours into this but can't get it right. Please help, thanks.</p>
  <p>I haven't added the data preprocessing parts.</p>
  <pre><code># importing libraries
  import pandas as pd
  import numpy as np
  import torch
  import torch.nn as nn
  from torch.utils.data import Dataset
  from torch.utils.data import DataLoader
  import torch.nn.functional as F
  </code></pre>
  <pre><code># get x function (dataset related stuff)
  def Getx(idx):
      sample = samples[idx]
      vector = Calculating_bottom(sample)
      vector = torch.as_tensor(vector, dtype = torch.float64)
      
      return vector
  
  # get y function (dataset related stuff)
  def Gety(idx):
      y = np.array(train.iloc[idx, 4], dtype = np.float64)
      y = torch.as_tensor(y, dtype = torch.float64)
      
      return y
  </code></pre>
  <pre><code># dataset
  class mydataset(Dataset):
  
      def __init__(self):
          super().__init__()
  
      def __getitem__(self, index):
          x = Getx(index)
          y = Gety(index)
          
          return x, y
  
      def __len__(self):
          return len(train)
      
  dataset = mydataset()
  </code></pre>
  <pre><code># sample dataset value
  print(dataset.__getitem__(0))
  </code></pre>
  <p>(tensor([ 5.,  5.,  8., 14.], dtype=torch.float64), tensor(-0.3403, dtype=torch.float64))</p>
  <pre><code># data-loader
  dataloader = DataLoader(dataset, batch_size = 1, shuffle = True)
  </code></pre>
  <pre><code># nn architecture
  class Net(nn.Module):
      def __init__(self):
          super().__init__()
          self.fc1 = nn.Linear(4, 4)
          self.fc2 = nn.Linear(4, 2)
          self.fc3 = nn.Linear(2, 1)
  
      def forward(self, x):
          x = x.float()
          x = F.relu(self.fc1(x))
          x = F.relu(self.fc2(x))
          x = self.fc3(x)
          return x
  
  model = Net()
  </code></pre>
  <pre><code># device
  device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')
  model.to(device)
  </code></pre>
  <pre><code># hyper-parameters
  criterion = nn.MSELoss()
  optimizer = torch.optim.SGD(model.parameters(), lr=0.001)
  </code></pre>
  <pre><code># training loop
  
  for epoch in range(5):
      
      for batch in dataloader:
          
          # unpacking
          x, y = batch
          x.to(device)
          y.to(device)
          
          # reset gradients
          optimizer.zero_grad()
          
          # forward propagation through the network
          out = model(x)
          
          # calculate the loss
          loss = criterion(out, y)
          
          # backpropagation
          loss.backward()
          
          # update the parameters
          optimizer.step()
  </code></pre>
  <p>Error:</p>
  <pre><code>/opt/conda/lib/python3.7/site-packages/torch/nn/modules/loss.py:446: UserWarning: Using a target size (torch.Size([1])) that is different to the input size (torch.Size([1, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.
    return F.mse_loss(input, target, reduction=self.reduction)
  ---------------------------------------------------------------------------
  RuntimeError                              Traceback (most recent call last)
  &lt;ipython-input-18-3f68fcee9ff3&gt; in &lt;module&gt;
       20 
       21         # backpropagation
  ---&gt; 22         loss.backward()
       23 
       24         # update the parameters
  
  /opt/conda/lib/python3.7/site-packages/torch/tensor.py in backward(self, gradient, retain_graph, create_graph)
      219                 retain_graph=retain_graph,
      220                 create_graph=create_graph)
  --&gt; 221         torch.autograd.backward(self, gradient, retain_graph, create_graph)
      222 
      223     def register_hook(self, hook):
  
  /opt/conda/lib/python3.7/site-packages/torch/autograd/__init__.py in backward(tensors, grad_tensors, retain_graph, create_graph, grad_variables)
      130     Variable._execution_engine.run_backward(
      131         tensors, grad_tensors_, retain_graph, create_graph,
  --&gt; 132         allow_unreachable=True)  # allow_unreachable flag
      133 
      134 
  
  RuntimeError: Found dtype Double but expected Float
  </code></pre>