title: Expected device cuda:0 but got device cpu in PyTorch when I have already assigned the device to be cuda
body: <p>I have a following neural network code, and I get &quot;Expected device cuda:0 but got device cpu in PyTorch&quot; error and I can't figure out why. I assign the device to be cuda and the print line returns cuda. I've tried assign the device as device = cuda:0 as well just in case but that had no effect. Here's the code:</p>
  <pre><code>def run():
      torch.multiprocessing.freeze_support()
      device = torch.device(&quot;cuda&quot; if torch.cuda.is_available() else &quot;cpu&quot;)
      print(device)  
  
      metabolites = pd.read_excel(&quot;testmetabolitedata.xlsx&quot;)
      subject_metadata = pd.read_excel(&quot;testsubj.xlsx&quot;)
      metabolitesdf = pd.DataFrame(data=metabolites)
      metabolitesdf = metabolitesdf.iloc[:, 1:9153] 
      subjectsdf = pd.DataFrame(data=subject_metadata)
  
      n_samples, n_metabolites = metabolitesdf.shape
      print(n_samples)
  
      #genotypes of the target gene
      print(subjectsdf['SLCO1B1_rs4149056'])
      genotypes = subjectsdf['SLCO1B1_rs4149056']
      print(genotypes)
      # print('{} unique genotypes'.format(len(set(genotypes))))
  
      labels = [1 if g == 1 else 0 for g in genotypes]
      print('{} samples with genotype 1 out of {}  samples ({:.1%})'.format(sum(labels), len(labels),
                                                      sum(labels) / len(labels)))
  
  
      #Insert 0 into index 0 (first) into the list for the first row with column names
      labels.insert(0, 0)
      #log transform                                                 
      log_metabol = np.log10(metabolitesdf + 1)
  
      #Split data into training and validation 70% / 30%
      data = torch.utils.data.TensorDataset(torch.Tensor(np.array(log_metabol)),
                                                      torch.Tensor(labels))
      train, val = torch.utils.data.random_split(data, [int(0.7 * len(data)), 
                                                                  len(data) - int(0.7 * len(data))])
  
      print('{:.0f}/{} training/total ({:.1%}) in training set, {:.0f}/{} val/total ({:.1%}) in validation set'.format(\
          train[:][1].sum(), len(train), train[:][1].sum() / len(train),
          val[:][1].sum(), len(val), val[:][1].sum() / len(val)))
  
  
  
  
      class MultiLayerPredictor(torch.nn.Module):
          def __init__(self, input_shape, output_shape=1, hidden_dim=1024, **kwargs):
              super().__init__()
              self.fc1 = torch.nn.Linear(in_features=input_shape, out_features=hidden_dim)
              self.bn1 = torch.nn.BatchNorm1d(hidden_dim)
              self.fc2 = torch.nn.Linear(in_features=hidden_dim, out_features=hidden_dim)
              self.bn2 = torch.nn.BatchNorm1d(hidden_dim)
              self.fc3 = torch.nn.Linear(in_features=hidden_dim, out_features=output_shape)
  
          def forward(self, x):
              l1 = torch.relu(self.bn1(self.fc1(x)))
              l2 = torch.relu(self.bn2(self.fc2(l1)))
              return torch.sigmoid(self.fc3(l2)).reshape(-1)
  
  
      #load the training and validation sets       
      print(&quot;Load training and validation data &quot;)
      train_loader = torch.utils.data.DataLoader(train, batch_size=128, 
                                                  shuffle=True, num_workers=10, pin_memory=True)
      val_loader = torch.utils.data.DataLoader(val, batch_size=128, 
                                                  shuffle=False, num_workers=10, pin_memory=True)
  
      print(&quot;Loading complete, create model&quot;)
      model3 = MultiLayerPredictor(input_shape=n_metabolites).to(device)
      print(&quot;Model created! Moving to optimizer&quot;)
      optimizer3 = torch.optim.SGD(model3.parameters(), lr=1e-2)
      print(&quot;Optimizer done&quot;)
      objective3 = torch.nn.BCELoss()
      epochs = 30
  
  
      print_stats_interval = 10
      log3 = []
      print(&quot;Moving to training loop&quot;)
  
      for epoch in range(epochs):
          loss = n_correct = 0
          model3.train()
          for batch, target in train_loader:
              batch = batch.view(-1, n_metabolites).to(device)
              optimizer3.zero_grad()
              outputs = model3(batch) # stack trace shows the issue being either on this line 
              train_loss = objective3(outputs, target) # or this line
              loss += train_loss.item()
              n_correct += (target == (outputs.reshape(-1) &gt; 0.5).float()).sum()
              train_loss.backward()
              optimizer3.step()
          
          loss = loss / len(train_loader)    
          acc = (n_correct.float() / len(train)).numpy()
          epoch += 1
              
          model3.eval();
          val_loss = val_n_correct = 0
          with torch.no_grad():
              for batch, target in val_loader:
                  batch = batch.view(-1, n_metabolites).to(device)
                  outputs = model3(batch)
                  val_loss += objective3(outputs, target)
                  val_n_correct += (target == (outputs.reshape(-1) &gt; 0.5).float()).sum()
          val_loss = (val_loss / len(val_loader)).numpy()
          val_acc = (val_n_correct.float() / len(val)).numpy()
          
          if (epoch % print_stats_interval) == 0 or epoch == epochs:
              print(f'epoch={epoch:.0f}, loss={loss:.5f}, val_loss={np.round(val_loss,5):.5f}, acc={np.round(acc,5):.5f}, val_acc={np.round(val_acc,5):.5f}')
          log3.append((epoch, loss, val_loss, acc, val_acc))
      log3 = pd.DataFrame(log3, columns=['epoch', 'loss', 'val_loss', 'acc', 'val_acc'])
  
      plt.figure(figsize=(6, 3))
      plt.plot(log3['epoch'], log3['loss'], label='Training');
      plt.plot(log3['epoch'], log3['val_loss'], label='Validation');
      plt.xlabel('Epoch'); plt.ylabel('Loss')
      plt.legend();
  
      val_log_mutations = val_hcc[:][0].numpy().reshape(-1)
      val_true_labels = val_hcc[:][1].numpy() + 0
  
      res = model3(val_hcc[:][0])
      predictions = (res.detach().numpy().reshape(-1) &gt; 0.5) + 0
      correct = (val_true_labels == predictions) + 0
      n_correct = correct.sum()
      print('{}/{} ({:.1%}) in the validation set'.format(n_correct, len(correct), n_correct / len(correct)))
      print('Majority classifier accuracy: {:.1%}'.format((len(correct) - val_true_labels.sum()) / len(correct)))
  
  if __name__ == '__main__':
      run()
  
  </code></pre>
  <p>What's going on here? The stack trace here:</p>
  <pre><code>Traceback (most recent call last):
    File &quot;//ad..fi/home/h/h/Desktop/neuralnet/neuralnet_train.py&quot;, line 142, in &lt;module&gt;
      run()
    File &quot;//ad..fi/home/h/h/Desktop/neuralnet/neuralnet_train.py&quot;, line 99, in run
      train_loss = objective3(outputs, target)
    File &quot;C:\Users\h\AppData\Roaming\Python\Python38\site-packages\torch\nn\modules\module.py&quot;, line 550, in __call__
      result = self.forward(*input, **kwargs)
    File &quot;C:\Users\h\AppData\Roaming\Python\Python38\site-packages\torch\nn\modules\loss.py&quot;, line 516, in forward
      return F.binary_cross_entropy(input, target, weight=self.weight, reduction=self.reduction)
    File &quot;C:\Users\h\AppData\Roaming\Python\Python38\site-packages\torch\nn\functional.py&quot;, line 2378, in binary_cross_entropy
      return torch._C._nn.binary_cross_entropy(
  RuntimeError: expected device cuda:0 but got device cpu
  PS Microsoft.PowerShell.Core\FileSystem::\\ad..fi\home\h\h\Desktop\neuralnet&gt;
  </code></pre>