title: CNN Pytorch Error : Input type (torch.cuda.ByteTensor) and weight type (torch.cuda.FloatTensor) should be the same
body: <p>I'm receiving the error,</p>
  
  <blockquote>
    <p>Input type (torch.cuda.ByteTensor) and weight type (torch.cuda.FloatTensor) should be the same</p>
  </blockquote>
  
  <p>Following is my code,</p>
  
  <pre><code>device    = torch.device('cuda:0')
  
  trainData = torchvision.datasets.FashionMNIST('/content/', train=True, transform=None, target_transform=None, download=True)
  testData  = torchvision.datasets.FashionMNIST('/content/', train=False, transform=None, target_transform=None, download=True)
  
  class Net(nn.Module):
    def __init__(self):
      super().__init__()
  
      '''
      Network Structure:
  
      input &gt; 
      (1)Conv2D &gt; (2)MaxPool2D &gt; 
      (3)Conv2D &gt; (4)MaxPool2D &gt; 
      (5)Conv2D &gt; (6)MaxPool2D &gt; 
      (7)Linear &gt; (8)LinearOut
  
      '''
  
      # Creating the convulutional Layers
      self.conv1 = nn.Conv2d(in_channels=CHANNELS, out_channels=32, kernel_size=3)
      self.conv2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3)
      self.conv3 = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3)
  
      self.flatten = None
      # Creating a Random dummy sample to get the Flattened Dimensions
      x = torch.randn(CHANNELS, DIM, DIM).view(-1, CHANNELS, DIM, DIM)
      x = self.convs(x)
  
      # Creating the Linear Layers
      self.fc1   = nn.Linear(self.flatten, 512)
      self.fc2   = nn.Linear(512, CLASSES)
  
    def convs(self, x):
  
      # Creating the MaxPooling Layers
      x = F.max_pool2d(F.relu(self.conv1(x)), kernel_size=(2, 2))
      x = F.max_pool2d(F.relu(self.conv2(x)), kernel_size=(2, 2))
      x = F.max_pool2d(F.relu(self.conv3(x)), kernel_size=(2, 2))
  
      if not self.flatten:
        self.flatten = x[0].shape[0] * x[0].shape[1] * x[0].shape[2]
      return x
  
    # FORWARD PASS
    def forward(self, x):
      x = self.convs(x)
      x = x.view(-1, self.flatten)
      sm = F.relu(self.fc1(x))
      x = F.softmax(self.fc2(sm), dim=1)
      return x, sm
  
  
    x_train, y_train = training_set
    x_train, y_train = x_train.to(device), y_train.to(device)
    optimizer = optim.Adam(net.parameters(), lr=LEARNING_RATE)
    loss_func = nn.MSELoss()
    loss_log  = []
  
    for epoch in range(EPOCHS):
      for i in tqdm(range(0, len(x_train), BATCH_SIZE)):
          x_batch = x_train[i:i+BATCH_SIZE].view(-1, CHANNELS, DIM, DIM).to(device)
          y_batch = y_train[i:i+BATCH_SIZE].to(device)
  
          net.zero_grad()
          output, sm = net(x_batch)
          loss = loss_func(output, y_batch.float())
          loss.backward()
          optimizer.step()
      loss_log.append(loss)
      # print(f"Epoch : {epoch} || Loss : {loss}")
  
    return loss_log
  
  
  train_set = (trainData.train_data, trainData.train_labels)
  test_set  = (testData.test_data, testData.test_labels)
  
  EPOCHS        = 5
  LEARNING_RATE = 0.001
  BATCH_SIZE    = 32
  
  net = Net().to(device)
  
  loss_log = train(net, train_set, EPOCHS, LEARNING_RATE, BATCH_SIZE)
  </code></pre>
  
  <p><strong>And this is the Error that I'm getting,</strong></p>
  
  <pre><code>RuntimeError                              Traceback (most recent call last)
  &lt;ipython-input-8-0db1a1b4e37d&gt; in &lt;module&gt;()
        5 net = Net().to(device)
        6 
  ----&gt; 7 loss_log = train(net, train_set, EPOCHS, LEARNING_RATE, BATCH_SIZE)
  
  6 frames
  &lt;ipython-input-6-7de4a78e3736&gt; in train(net, training_set, EPOCHS, LEARNING_RATE, BATCH_SIZE)
       13 
       14         net.zero_grad()
  ---&gt; 15         output, sm = net(x_batch)
       16         loss = loss_func(output, y_batch.float())
       17         loss.backward()
  
  /usr/local/lib/python3.6/dist-packages/torch/nn/modules/module.py in __call__(self, *input, **kwargs)
      539             result = self._slow_forward(*input, **kwargs)
      540         else:
  --&gt; 541             result = self.forward(*input, **kwargs)
      542         for hook in self._forward_hooks.values():
      543             hook_result = hook(self, input, result)
  
  &lt;ipython-input-5-4fddc427892a&gt; in forward(self, x)
       41   # FORWARD PASS
       42   def forward(self, x):
  ---&gt; 43     x = self.convs(x)
       44     x = x.view(-1, self.flatten)
       45     sm = F.relu(self.fc1(x))
  
  &lt;ipython-input-5-4fddc427892a&gt; in convs(self, x)
       31 
       32     # Creating the MaxPooling Layers
  ---&gt; 33     x = F.max_pool2d(F.relu(self.conv1(x)), kernel_size=(2, 2))
       34     x = F.max_pool2d(F.relu(self.conv2(x)), kernel_size=(2, 2))
       35     x = F.max_pool2d(F.relu(self.conv3(x)), kernel_size=(2, 2))
  
  /usr/local/lib/python3.6/dist-packages/torch/nn/modules/module.py in __call__(self, *input, **kwargs)
      539             result = self._slow_forward(*input, **kwargs)
      540         else:
  --&gt; 541             result = self.forward(*input, **kwargs)
      542         for hook in self._forward_hooks.values():
      543             hook_result = hook(self, input, result)
  
  /usr/local/lib/python3.6/dist-packages/torch/nn/modules/conv.py in forward(self, input)
      343 
      344     def forward(self, input):
  --&gt; 345         return self.conv2d_forward(input, self.weight)
      346 
      347 class Conv3d(_ConvNd):
  
  /usr/local/lib/python3.6/dist-packages/torch/nn/modules/conv.py in conv2d_forward(self, input, weight)
      340                             _pair(0), self.dilation, self.groups)
      341         return F.conv2d(input, weight, self.bias, self.stride,
  --&gt; 342                         self.padding, self.dilation, self.groups)
      343 
      344     def forward(self, input):
  
  RuntimeError: Input type (torch.cuda.ByteTensor) and weight type (torch.cuda.FloatTensor) should be the same
  </code></pre>
  
  <p>I double-checked that my Neural Net and my Inputs both are in GPU. I'm still getting this error and I don't understand why!</p>
  
  <p>Somebody, please help me to get out of this error.</p>