i got this error when doing the cs231n assignment2 on jupyter.
i checked and all my parameters and inputs are sent to device, which is cuda:0.
the error message :
RuntimeError                              Traceback (most recent call last)
<ipython-input-33-851ef5a1f987> in <module>
     29 
     30 params = [conv_w1, conv_b1, conv_w2, conv_b2, fc_w, fc_b]
---> 31 train_part2(three_layer_convnet, params, learning_rate)

<ipython-input-32-3e676edf85f7> in train_part2(model_fn, params, learning_rate)
     23         for i in params:
     24             print(i.device)
---> 25         scores = model_fn(x, params)
     26         loss = F.cross_entropy(scores, y)
     27 

<ipython-input-28-279d7a4f4cea> in three_layer_convnet(x, params)
     52     out = conv1(x)
     53     out = relu(out)
---> 54     out = conv2(out)
     55     out = relu(out)
     56     out = flatten(out)

~\.conda\envs\torch_env\lib\site-packages\torch\nn\modules\module.py in __call__(self, *input, **kwargs)
    530             result = self._slow_forward(*input, **kwargs)
    531         else:
--> 532             result = self.forward(*input, **kwargs)
    533         for hook in self._forward_hooks.values():
    534             hook_result = hook(self, input, result)

~\.conda\envs\torch_env\lib\site-packages\torch\nn\modules\conv.py in forward(self, input)
    343 
    344     def forward(self, input):
--> 345         return self.conv2d_forward(input, self.weight)
    346 
    347 class Conv3d(_ConvNd):

~\.conda\envs\torch_env\lib\site-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,
--> 342                         self.padding, self.dilation, self.groups)
    343 
    344     def forward(self, input):

RuntimeError: Input type (torch.cuda.FloatTensor) and bias type (torch.FloatTensor) should be the same

code leading to error:
def train_part2(model_fn, params, learning_rate):
    """
    Train a model on CIFAR-10.
    
    Inputs:
    - model_fn: A Python function that performs the forward pass of the model.
      It should have the signature scores = model_fn(x, params) where x is a
      PyTorch Tensor of image data, params is a list of PyTorch Tensors giving
      model weights, and scores is a PyTorch Tensor of shape (N, C) giving
      scores for the elements in x.
    - params: List of PyTorch Tensors giving weights for the model
    - learning_rate: Python scalar giving the learning rate to use for SGD
    
    Returns: Nothing
    """
    for t, (x, y) in enumerate(loader_train):
        # Move the data to the proper device (GPU or CPU)
        x = x.to(device=device, dtype=dtype)
        y = y.to(device=device, dtype=torch.long)

        # Forward pass: compute scores and loss
        print(x.device)
        for i in params:
            print(i.device)
        scores = model_fn(x, params)
        loss = F.cross_entropy(scores, y)

        # Backward pass: PyTorch figures out which Tensors in the computational
        # graph has requires_grad=True and uses backpropagation to compute the
        # gradient of the loss with respect to these Tensors, and stores the
        # gradients in the .grad attribute of each Tensor.
        loss.backward()

        # Update parameters. We don't want to backpropagate through the
        # parameter updates, so we scope the updates under a torch.no_grad()
        # context manager to prevent a computational graph from being built.
        with torch.no_grad():
            for w in params:
                w -= learning_rate * w.grad

                # Manually zero the gradients after running the backward pass
                w.grad.zero_()

        if t % print_every == 0:
            print('Iteration %d, loss = %.4f' % (t, loss.item()))
            check_accuracy_part2(loader_val, model_fn, params)
            print()

def random_weight(shape):
    """
    Create random Tensors for weights; setting requires_grad=True means that we
    want to compute gradients for these Tensors during the backward pass.
    We use Kaiming normalization: sqrt(2 / fan_in)
    """
    if len(shape) == 2:  # FC weight
        fan_in = shape[0]
    else:
        fan_in = np.prod(shape[1:]) # conv weight [out_channel, in_channel, kH, kW]
    # randn is standard normal distribution generator. 
    w = torch.randn(shape, device=device, dtype=dtype) * np.sqrt(2. / fan_in)
    w.requires_grad = True
    return w

learning_rate = 3e-3

channel_1 = 32
channel_2 = 16

conv_w1 = None
conv_b1 = None
conv_w2 = None
conv_b2 = None
fc_w = None
fc_b = None

################################################################################
# TODO: Initialize the parameters of a three-layer ConvNet.                    #
################################################################################
# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****
conv_w1 = random_weight((32,3,5,5))
conv_b1 = random_weight((32,))
conv_w2 = random_weight((16,32,3,3))
conv_b2 = random_weight((16,))
fc_w = random_weight((16 * 32 * 32, 10))
fc_b = random_weight((10,))
pass

# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****
################################################################################
#                                 END OF YOUR CODE                             #
################################################################################

params = [conv_w1, conv_b1, conv_w2, conv_b2, fc_w, fc_b]
train_part2(three_layer_convnet, params, learning_rate)

the three_layer_convnet referred above:
def three_layer_convnet(x, params):
    """
    Performs the forward pass of a three-layer convolutional network with the
    architecture defined above.

    Inputs:
    - x: A PyTorch Tensor of shape (N, 3, H, W) giving a minibatch of images
    - params: A list of PyTorch Tensors giving the weights and biases for the
      network; should contain the following:
      - conv_w1: PyTorch Tensor of shape (channel_1, 3, KH1, KW1) giving weights
        for the first convolutional layer
      - conv_b1: PyTorch Tensor of shape (channel_1,) giving biases for the first
        convolutional layer
      - conv_w2: PyTorch Tensor of shape (channel_2, channel_1, KH2, KW2) giving
        weights for the second convolutional layer
      - conv_b2: PyTorch Tensor of shape (channel_2,) giving biases for the second
        convolutional layer
      - fc_w: PyTorch Tensor giving weights for the fully-connected layer. Can you
        figure out what the shape should be?
      - fc_b: PyTorch Tensor giving biases for the fully-connected layer. Can you
        figure out what the shape should be?
    
    Returns:
    - scores: PyTorch Tensor of shape (N, C) giving classification scores for x
    """
    conv_w1, conv_b1, conv_w2, conv_b2, fc_w, fc_b = params
    scores = None
    import torch.nn as nn
    pad1 = 2
    pad2 = 1
    channel_input = x.shape[1]
    channel_1 = conv_w1.shape[0]
    channel_2 = conv_w2.shape[0]
    KW1, KH1 = conv_w1.shape[2:]
    KW2, KH2 = conv_w2.shape[2:]
    
    conv1 = nn.Conv2d(channel_input,channel_1,(KW1,KH1),stride = 1,padding = pad1,padding_mode = 'zeros',bias=True)
    conv1.weight = nn.Parameter(conv_w1)
    conv1.bias = nn.Parameter(conv_b1)
    
    relu = nn.ReLU()
    
    conv2 = nn.Conv2d(channel_1,channel_2,(KW2,KH2),stride = 1,padding = pad2,padding_mode = 'zeros',bias=True)
    conv2.weight = nn.Parameter(conv_w2)
    conv2_bias = nn.Parameter(conv_b2)
    
    
    out = conv1(x)
    out = relu(out)
    out = conv2(out)
    out = relu(out)
    out = flatten(out)
    scores = out.mm(fc_w)+fc_b

    pass

 
    return scores

i checked thoroughly that all the tensors are sent to device, and i have a feeling that might be something wrong with the way i installed cuda or some activation of gpu i didn;t do.
by examining the task manager, i know i have:
GPU 0 intel® HD graphics 630
GPU 1 NVIDIA GeForce GTX 1050
i followed some tutorials to install nvidia driver and activate in in cmd but maybe it was erroneous. that’s just my hunch though.
does anybody have a clue?