Pytorch Skorch运行时错误：输入类型（torch.cuda.ByteTensor）和权重类型（torch.cuda.FloatTensor）应该相同

我正在尝试开发一个图像分割模型。在下面的代码中，我一直遇到运行时错误：输入类型（torch.cuda.ByteTensor）和权重类型（torch.cuda.FloatTensor）应该相同。我不知道为什么，因为我尝试使用.cuda（）将我的数据和我的UNet模型加载到GPU（虽然不是skorch模型——不知道如何实现）。我正在使用一个图书馆来进行积极的学习，它包裹了skorch

from modAL.models import ActiveLearner
import numpy as np
import torch

from torch import nn
from torch import Tensor
from torch.utils.data import DataLoader
from torch.utils.data import Dataset

from skorch.net import NeuralNet

from modAL.models import ActiveLearner
from modAL.uncertainty import classifier_uncertainty, classifier_margin
from modAL.utils.combination import make_linear_combination, make_product
from modAL.utils.selection import multi_argmax
from modAL.uncertainty import uncertainty_sampling

from model import UNet
from skorch.net import NeuralNet
from skorch.helper import predefined_split
from torch.optim import SGD

import cv2


# Map style dataset, 
class ImagesDataset(Dataset):
    """Constructs dataset of satellite images + masks"""
    def __init__(self, image_paths):
        super().__init__()
        self.image_paths = image_paths

    def __len__(self):
        return len(self.image_paths)

    def __getitem__(self, idx):  
        if torch.is_tensor(idx):
            idx = idx.tolist()
        print("idx:", idx)
        sample_dir = self.image_paths[idx]
        img_path = sample_dir +"/images/"+ Path(sample_dir).name +'.png'
        mask_path = sample_dir +'/mask.png'
        img, mask = cv2.imread(img_path), cv2.imread(mask_path)
        print("shape of img", img.shape)
        return img, mask

# turn data into dataset
train_ds = ImagesDataset(train_dirs)
val_ds = ImagesDataset(valid_dirs)

train_loader = torch.utils.data.DataLoader(train_ds, batch_size=3, shuffle=True, pin_memory=True)
val_loader = torch.utils.data.DataLoader(val_ds, batch_size=1, shuffle=True, pin_memory=True)

# make sure data loaded in cuda for train, validation
for i, (tr, val) in enumerate(train_loader):
    tr, val = tr.cuda(), val.cuda()

for i, (tr2, val2) in enumerate(val_loader):
    tr2, val2 = tr2.cuda(), val2.cuda()

X, y = next(iter(train_loader))
X_train = np.array(X.reshape(3,3,1024,1024))
y_train = np.array(y.reshape(3,3,1024,1024))

X2, y2 = next(iter(val_loader))
X_test = np.array(X2.reshape(1,3,1024,1024))
y_test = np.array(y2.reshape(1,3,1024,1024))


module = UNet(pretrained=True)
if torch.cuda.is_available():
    module = module.cuda()
    
# create the classifier

net = NeuralNet(
    module,
    criterion=torch.nn.NLLLoss,
    batch_size=32,
    max_epochs=20,
    optimizer=SGD,
    optimizer__momentum=0.9,
    iterator_train__shuffle=True,
    iterator_train__num_workers=4,
    iterator_valid__shuffle=False,
    iterator_valid__num_workers=4,
    train_split=predefined_split(val_ds),
    device='cuda',
)

# assemble initial data
n_initial = 1
initial_idx = np.random.choice(range(len(X_train)), size=n_initial, replace=False)
X_initial = X_train[initial_idx]
y_initial = y_train[initial_idx]

# generate the pool, remove the initial data from the training dataset
X_pool = np.delete(X_train, initial_idx, axis=0)
y_pool = np.delete(y_train, initial_idx, axis=0)

# train the activelearner
# shape of 4D matrix is 'batch', 'channel', 'width', 'height')
learner = ActiveLearner(
    estimator= net,
    X_training=X_initial, y_training=y_initial,
)

完整的错误跟踪是：

    ---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
<ipython-input-83-0af6007b6b72> in <module>
      8 learner = ActiveLearner(
      9     estimator= net,
---> 10     X_training=X_initial, y_training=y_initial,
     11     # X_training=X_initial, y_training=y_initial,
     12 )

~/.local/lib/python3.7/site-packages/modAL/models/learners.py in __init__(self, estimator, query_strategy, X_training, y_training, bootstrap_init, on_transformed, **fit_kwargs)
     80                  ) -> None:
     81         super().__init__(estimator, query_strategy,
---> 82                          X_training, y_training, bootstrap_init, on_transformed, **fit_kwargs)
     83 
     84     def teach(self, X: modALinput, y: modALinput, bootstrap: bool = False, only_new: bool = False, **fit_kwargs) -> None:

~/.local/lib/python3.7/site-packages/modAL/models/base.py in __init__(self, estimator, query_strategy, X_training, y_training, bootstrap_init, on_transformed, force_all_finite, **fit_kwargs)
     70         self.y_training = y_training
     71         if X_training is not None:
---> 72             self._fit_to_known(bootstrap=bootstrap_init, **fit_kwargs)
     73             self.Xt_training = self.transform_without_estimating(self.X_training) if self.on_transformed else None
     74 

~/.local/lib/python3.7/site-packages/modAL/models/base.py in _fit_to_known(self, bootstrap, **fit_kwargs)
    160         """
    161         if not bootstrap:
--> 162             self.estimator.fit(self.X_training, self.y_training, **fit_kwargs)
    163         else:
    164             n_instances = self.X_training.shape[0]

~/.local/lib/python3.7/site-packages/skorch/net.py in fit(self, X, y, **fit_params)
    901             self.initialize()
    902 
--> 903         self.partial_fit(X, y, **fit_params)
    904         return self
    905 

~/.local/lib/python3.7/site-packages/skorch/net.py in partial_fit(self, X, y, classes, **fit_params)
    860         self.notify('on_train_begin', X=X, y=y)
    861         try:
--> 862             self.fit_loop(X, y, **fit_params)
    863         except KeyboardInterrupt:
    864             pass

~/.local/lib/python3.7/site-packages/skorch/net.py in fit_loop(self, X, y, epochs, **fit_params)
    774 
    775             self.run_single_epoch(dataset_train, training=True, prefix="train",
--> 776                                   step_fn=self.train_step, **fit_params)
    777 
    778             if dataset_valid is not None:

~/.local/lib/python3.7/site-packages/skorch/net.py in run_single_epoch(self, dataset, training, prefix, step_fn, **fit_params)
    810             yi_res = yi if not is_placeholder_y else None
    811             self.notify("on_batch_begin", X=Xi, y=yi_res, training=training)
--> 812             step = step_fn(Xi, yi, **fit_params)
    813             self.history.record_batch(prefix + "_loss", step["loss"].item())
    814             self.history.record_batch(prefix + "_batch_size", get_len(Xi))

~/.local/lib/python3.7/site-packages/skorch/net.py in train_step(self, Xi, yi, **fit_params)
    707             return step['loss']
    708 
--> 709         self.optimizer_.step(step_fn)
    710         return step_accumulator.get_step()
    711 

~/.local/lib/python3.7/site-packages/torch/autograd/grad_mode.py in decorate_context(*args, **kwargs)
     24         def decorate_context(*args, **kwargs):
     25             with self.__class__():
---> 26                 return func(*args, **kwargs)
     27         return cast(F, decorate_context)
     28 

~/.local/lib/python3.7/site-packages/torch/optim/sgd.py in step(self, closure)
     84         if closure is not None:
     85             with torch.enable_grad():
---> 86                 loss = closure()
     87 
     88         for group in self.param_groups:

~/.local/lib/python3.7/site-packages/skorch/net.py in step_fn()
    703         def step_fn():
    704             self.optimizer_.zero_grad()
--> 705             step = self.train_step_single(Xi, yi, **fit_params)
    706             step_accumulator.store_step(step)
    707             return step['loss']

~/.local/lib/python3.7/site-packages/skorch/net.py in train_step_single(self, Xi, yi, **fit_params)
    643         """
    644         self.module_.train()
--> 645         y_pred = self.infer(Xi, **fit_params)
    646         loss = self.get_loss(y_pred, yi, X=Xi, training=True)
    647         loss.backward()

~/.local/lib/python3.7/site-packages/skorch/net.py in infer(self, x, **fit_params)
   1046             x_dict = self._merge_x_and_fit_params(x, fit_params)
   1047             return self.module_(**x_dict)
-> 1048         return self.module_(x, **fit_params)
   1049 
   1050     def _get_predict_nonlinearity(self):

~/.local/lib/python3.7/site-packages/torch/nn/modules/module.py in _call_impl(self, *input, **kwargs)
    725             result = self._slow_forward(*input, **kwargs)
    726         else:
--> 727             result = self.forward(*input, **kwargs)
    728         for hook in itertools.chain(
    729                 _global_forward_hooks.values(),

~/al/model.py in forward(self, x)
     51 
     52     def forward(self, x):
---> 53         conv1 = self.conv1(x)
     54         conv2 = self.conv2(conv1)
     55         conv3 = self.conv3(conv2)

~/.local/lib/python3.7/site-packages/torch/nn/modules/module.py in _call_impl(self, *input, **kwargs)
    725             result = self._slow_forward(*input, **kwargs)
    726         else:
--> 727             result = self.forward(*input, **kwargs)
    728         for hook in itertools.chain(
    729                 _global_forward_hooks.values(),

~/.local/lib/python3.7/site-packages/torch/nn/modules/container.py in forward(self, input)
    115     def forward(self, input):
    116         for module in self:
--> 117             input = module(input)
    118         return input
    119 

~/.local/lib/python3.7/site-packages/torch/nn/modules/module.py in _call_impl(self, *input, **kwargs)
    725             result = self._slow_forward(*input, **kwargs)
    726         else:
--> 727             result = self.forward(*input, **kwargs)
    728         for hook in itertools.chain(
    729                 _global_forward_hooks.values(),

~/.local/lib/python3.7/site-packages/torch/nn/modules/conv.py in forward(self, input)
    421 
    422     def forward(self, input: Tensor) -> Tensor:
--> 423         return self._conv_forward(input, self.weight)
    424 
    425 class Conv3d(_ConvNd):

~/.local/lib/python3.7/site-packages/torch/nn/modules/conv.py in _conv_forward(self, input, weight)
    418                             _pair(0), self.dilation, self.groups)
    419         return F.conv2d(input, weight, self.bias, self.stride,
--> 420                         self.padding, self.dilation, self.groups)
    421 
    422     def forward(self, input: Tensor) -> Tensor:

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

---------------------------------------------------------------------------
运行时错误回溯（上次最近调用）
在里面
8学习者=主动学习者(
9估算值=净额，
--->10 X_培训=X_初始，y_培训=y_初始，
11#X#u training=X#u initial，y#u training=y#u initial，
12 )
~/.local/lib/python3.7/site-packages/modAL/models/learner.py in_uuuuuinit_uuu（自我、估计、查询策略、X_训练、y_训练、bootstrap_uinit、on_u转换、**fit_kwargs）
80）->无：
81 super（），
--->82 X_训练、y_训练、引导训练、启动训练、启动训练、转换训练、**fit_kwargs）
83
84 def教学（self，X:modALinput，y:modALinput，引导：bool=False，仅新：bool=False，**适合）->无：
~/.local/lib/python3.7/site-packages/modAL/models/base.py in_uuuuuinit_uuu（自我、估计、查询策略、X_训练、y_训练、bootstrap_uinit、on_u变换、force_uall_u有限、**fit_kwargs）
70 self.y_培训=y_培训
71如果X_培训不是无：
--->72自适配至已知（自举=自举初始，**自适配）
73 self.Xt\u training=如果self.on\u已转换，则在不进行估计的情况下进行self.transform\u（self.X\u training）其他无
74
~/.local/lib/python3.7/site-packages/modAL/models/base.py in_-fit_-to_-known（self，bootstrap，**fit_-kwargs）
160         """
161如果不是自举：
-->162自我估计器拟合（自我X_训练、自我y_训练、**拟合kwargs）
163其他：
164 n_实例=self.X_training.shape[0]
拟合中的~/.local/lib/python3.7/site-packages/skorch/net.py（self，X，y，**拟合参数）
901 self.initialize（）
902
-->903自身部分配合（X，y，**配合参数）
904回归自我
905
局部拟合中的~/.local/lib/python3.7/site-packages/skorch/net.py（self、X、y、class、**拟合参数）
860自我通知（“列车开始时”，X=X，y=y）
861尝试：
-->862自拟合回路（X，y，**拟合参数）
863除键盘中断外：
864通行证
拟合循环中的~/.local/lib/python3.7/site-packages/skorch/net.py（self、X、y、epochs、**拟合参数）
774
775 self.run\u single\u epoch（数据集\u train，training=True，前缀=“train”，
-->776步骤fn=自列步骤，**配合参数）
777
778如果数据集_valid不是None：
运行单历元中的~/.local/lib/python3.7/site-packages/skorch/net.py（self、数据集、训练、前缀、步骤fn、**拟合参数）
810 yi_res=yi如果不是，则为_占位符\u y else无
811自我通知（“批处理开始时”，X=Xi，y=yi=res，培训=培训）
-->812步骤=步骤fn（Xi，yi，**拟合参数）
813.自我记录。记录批次（前缀+“\u损失”，步骤[“损失”]。项（）
814自我记录。记录批次（前缀+“\u批次大小”，获取长度（Xi））
在训练席中，局部/ LIB／Python 3.7/Stay-P包装／SkGun/NET.Py（自，XI，YI，** FITYPARAMS）
707返回步骤[“丢失”]
708
-->709自优化器步骤（步骤fn）
710返回步数累加器。获取步数（）
711
装饰上下文中的~/.local/lib/python3.7/site-packages/torch/autograd/grad\u mode.py（*args，**kwargs）
24定义上下文（*args，**kwargs）：
25和self.\uuuuu类\uuuuuuu（）
--->26返回函数（*args，**kwargs）
27返回模式（F，装饰背景）
28
步骤中的~/.local/lib/python3.7/site-packages/torch/optim/sgd.py（self，closure）
84如果关闭不是无：
85带火炬。启用梯度（）
--->86损失=关闭（）
87
88对于self.param_组中的组：
步骤_fn（）中的~/.local/lib/python3.7/site-packages/skorch/net.py
703 def步骤fn（）：
704 self.optimizer\u0\u grad（）
-->705步长=自整列步长（Xi，yi，**拟合参数）
706步骤蓄能器。存储步骤（步骤）
707返回步骤[“丢失”]
~//本地/ LIB／Python 3.7/Stay-P包装／SkGun/NET.Py在TrasePrimeStIGLL单机（自已，席，易，** FithPARAMS）
643         """
644自我模块列车（）
-->645 y_pred=自我推断（Xi，**拟合参数）
646损失=自我。获得损失（y_pred，yi，X=Xi，training=True）
647损失。向后（）
推断中的~/.local/lib/python3.7/site-packages/skorch/net.py（self，x，**fit_参数）
1046 x_dict=self._merge_x_和_fit_参数（x，fit_参数）
1047返回自我模块（**x_dict）
->1048返回自我模块（x，**拟合参数）
1049
1050定义获取预测非线性（自）：
~/.local/lib/python3.7/site-packages/torch/nn/modules/module.py in\u call\u impl（self，*input，**kwargs）
725结果=self.\u slow\u forward（*输入，**kwargs）
726其他：
-->727结果=自转发（*输入，**kwargs）
728用于itertools.chain中的挂钩(
729 _全局_向前_hooks.values（），
~/al/model.py正向（自，x）
51
52 def前进档（自身，x）：
--->53 conv1=self.conv1（x）
54 conv2=self.conv2（conv1）
55 conv3=self.conv3（conv2）
调用impl中的~/.local/lib/python3.7/site-packages/torch/nn/modules/module.py