如何解决VGG with Shared Classified: RuntimeError: multi-target not supported at /pytorch/aten/src/THCUNN/generic/ClassNLLCriterion.cu:15
我有一个共享分类器的架构，适用于 MNIST。
我创建的架构考虑了 MNIST 的偶数和奇数之间的简单二进制分类。现在我试图将分类推广到所有数字，但我有这个错误：
RuntimeError: multi-target not supported at /pytorch/aten/src/THCUNN/generic/ClassNLLCriterion.cu:15
这是我的代码的链接：https://colab.research.google.com/drive/1ozkDlF_xH13NcsnPnE40d453EyycQzVl?usp=sharing
但是，这里有代码中最重要的部分：
VGG：
class VGGBlock(nn.Module):
def __init__(self,in_channels,out_channels,batch_norm=False):
super().__init__()
conv2_params = {'kernel_size': (3,3),'stride' : (1,1),'padding' : 1
}
noop = lambda x : x
self._batch_norm = batch_norm
self.conv1 = nn.Conv2d(in_channels=in_channels,out_channels=out_channels,**conv2_params)
#self.bn1 = nn.BatchNorm2d(out_channels) if batch_norm else noop
self.bn1 = nn.GroupNorm(64,out_channels) if batch_norm else noop
self.conv2 = nn.Conv2d(in_channels=out_channels,**conv2_params)
#self.bn2 = nn.BatchNorm2d(out_channels) if batch_norm else noop
self.bn2 = nn.GroupNorm(64,out_channels) if batch_norm else noop
self.max_pooling = nn.MaxPool2d(kernel_size=(2,2),stride=(2,2))
@property
def batch_norm(self):
return self._batch_norm
def forward(self,x):
x = self.conv1(x)
x = self.bn1(x)
x = F.relu(x)
x = self.conv2(x)
x = self.bn2(x)
x = F.relu(x)
x = self.max_pooling(x)
return x
class Classifier(nn.Module):
def __init__(self,num_classes=10):
super().__init__()
self.classifier = nn.Sequential(
nn.Linear(2048,2048),nn.ReLU(True),nn.Dropout(p=0.5),nn.Linear(2048,512),nn.Linear(512,num_classes)
)
def forward(self,x):
return self.classifier(x)
class VGG16(nn.Module):
def __init__(self,input_size,batch_norm=False):
super(VGG16,self).__init__()
self.in_channels,self.in_width,self.in_height = input_size
self.block_1 = VGGBlock(self.in_channels,64,batch_norm=batch_norm)
self.block_2 = VGGBlock(64,128,batch_norm=batch_norm)
self.block_3 = VGGBlock(128,256,batch_norm=batch_norm)
self.block_4 = VGGBlock(256,512,batch_norm=batch_norm)
@property
def input_size(self):
return self.in_channels,self.in_height
def forward(self,x):
x = self.block_1(x)
x = self.block_2(x)
x = self.block_3(x)
x = self.block_4(x)
# x = self.avgpool(x)
x = torch.flatten(x,1)
return x
我的自定义损失：
class CombinedLoss(nn.Module):
def __init__(self,loss_a,loss_b,loss_combo,_lambda=1.0):
super().__init__()
self.loss_a = loss_a
self.loss_b = loss_b
self.loss_combo = loss_combo
self.register_buffer('_lambda',torch.tensor(float(_lambda),dtype=torch.float32))
def forward(self,y_hat,y):
return self.loss_a(y_hat[0],y[0]) + self.loss_b(y_hat[1],y[1]) + self._lambda * self.loss_combo(y_hat[2],torch.cat(y,0))
训练函数：
def train(nets,loaders,optimizer,criterion,epochs=20,dev=None,save_param=False,model_name="valerio"):
# try:
nets = [n.to(dev) for n in nets]
model_a = module_unwrap(nets[0],True)
model_b = module_unwrap(nets[1],True)
model_c = module_unwrap(nets[2],True)
reg_loss = nn.MSELoss()
criterion.to(dev)
reg_loss.to(dev)
# Initialize history
history_loss = {"train": [],"val": [],"test": []}
history_accuracy = {"train": [],"test": []}
# Store the best val accuracy
best_val_accuracy = 0
# Process each epoch
for epoch in range(epochs):
# Initialize epoch variables
sum_loss = {"train": 0,"val": 0,"test": 0}
sum_accuracy = {"train": [0,0],"val": [0,"test": [0,0]}
progbar = None
# Process each split
for split in ["train","val","test"]:
if split == "train":
for n in nets:
n.train()
widgets = [
' [',pb.Timer(),'] ',pb.Bar(),' [',pb.ETA(),pb.Variable('ta','[Train Acc: {formatted_value}]')
]
progbar = pb.ProgressBar(max_value=len(loaders[split][0]),widgets=widgets,redirect_stdout=True)
else:
for n in nets:
n.eval()
# Process each batch
for j,((input_a,labels_a),(input_b,labels_b)) in enumerate(zip(loaders[split][0],loaders[split][1])):
input_a = input_a.to(dev)
input_b = input_b.to(dev)
labels_a = labels_a.long().to(dev)
labels_b = labels_b.long().to(dev)
labels_a = labels_a.unsqueeze(1)
labels_b = labels_b.unsqueeze(1)
inputs = torch.cat([input_a,input_b],axis=0)
labels = torch.cat([labels_a,labels_b])
labels = labels.unsqueeze(1)
# Reset gradients
optimizer.zero_grad()
# Compute output
features_a = nets[0](input_a)
features_b = nets[1](input_b)
features_c = nets[2](inputs)
pred_a = torch.squeeze(nets[3](features_a))
pred_b = torch.squeeze(nets[3](features_b))
pred_c = torch.squeeze(nets[3](features_c))
loss = criterion(pred_a,labels_a) + criterion(pred_b,labels_b) + criterion(pred_c,labels)
for n in model_a:
layer_a = model_a[n]
layer_b = model_b[n]
layer_c = model_c[n]
if (isinstance(layer_a,nn.Conv2d)):
loss += lambda_reg * reg_loss(combo_fn(layer_a.weight,layer_b.weight),layer_c.weight)
if (layer_a.bias is not None):
loss += lambda_reg * reg_loss(combo_fn(layer_a.bias,layer_b.bias),layer_c.bias)
# Update loss
sum_loss[split] += loss.item()
# Check parameter update
if split == "train":
# Compute gradients
loss.backward()
# Optimize
optimizer.step()
# Compute accuracy
#https://discuss.pytorch.org/t/bcewithlogitsloss-and-model-accuracy-calculation/59293/ 2
pred_labels_a = (pred_a >= 0.0).long() # Binarize predictions to 0 and 1
pred_labels_b = (pred_b >= 0.0).long() # Binarize predictions to 0 and 1
pred_labels_c = (pred_c >= 0.0).long() # Binarize predictions to 0 and 1
batch_accuracy_a = (pred_labels_a == labels_a).sum().item() / len(labels_a)
batch_accuracy_b = (pred_labels_b == labels_b).sum().item() / len(labels_b)
batch_accuracy_c = (pred_labels_c == labels).sum().item() / len(labels)
# Update accuracy
sum_accuracy[split][0] += batch_accuracy_a
sum_accuracy[split][1] += batch_accuracy_b
sum_accuracy[split][2] += batch_accuracy_c
if (split=='train'):
progbar.update(j,ta=batch_accuracy_c)
if (progbar is not None):
progbar.finish()
# Compute epoch loss/accuracy
epoch_loss = {split: sum_loss[split] / len(loaders[split][0]) for split in ["train","test"]}
epoch_accuracy = {split: [sum_accuracy[split][i] / len(loaders[split][0]) for i in range(len(sum_accuracy[split])) ] for split in ["train","test"]}
# # Store params at the best validation accuracy
# if save_param and epoch_accuracy["val"] > best_val_accuracy:
# # torch.save(net.state_dict(),f"{net.__class__.__name__}_best_val.pth")
# torch.save(net.state_dict(),f"{model_name}_best_val.pth")
# best_val_accuracy = epoch_accuracy["val"]
print(f"Epoch {epoch + 1}:")
# Update history
for split in ["train","test"]:
history_loss[split].append(epoch_loss[split])
history_accuracy[split].append(epoch_accuracy[split])
# Print info
print(f"\t{split}\tLoss: {epoch_loss[split]:0.5}\tVGG 1:{epoch_accuracy[split][0]:0.5}"
f"\tVGG 2:{epoch_accuracy[split][1]:0.5}\tVGG *:{epoch_accuracy[split][2]:0.5}")
if save_param:
torch.save({'vgg_a':nets[0].state_dict(),'vgg_b':nets[1].state_dict(),'vgg_star':nets[2].state_dict(),'classifier':nets[3].state_dict()},f'{model_name}.pth')
模型：
model1 = VGG16((1,32,32),batch_norm=True)
model2 = VGG16((1,batch_norm=True)
model3 = VGG16((1,batch_norm=True)
classifier = Classifier(num_classes=10)
nets = [model1,model2,model3,classifier]
和优化器
optimizer = torch.optim.SGD(parameters,lr = 0.01)
# Define a loss
criterion = nn.CrossEntropyLoss()
n_params = 0
我运行火车时出现的错误： 训练（网络，加载器，优化器，标准，epochs=50，dev=dev，save_param=True）
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。