optimizer = optim.SGD(model.parameters(), lr = lr)
criterion = nn.MSELoss()
valid_loss_min = np.Inf
def train(model, device, train_loader, optimizer, epoch):
model.train()
for batch_idx, (img_data32,img_data64, target) in enumerate(train_loader):
img_data32,img_data64, target = Variable(img_data32.to(device)),Variable(img_data64.to(device)), Variable(target.to(device))
optimizer.zero_grad() # Gradient Zeroing
output = model(img_data32,img_data64)
loss = criterion(output,target.view(1, -1).float)
loss.backward()
optimizer.step() # Update gradient
if(batch_idx+1)%150 == 0:
print("saving model ...")
torch.save(model.state_dict(),'{}/gdrive/My Drive/RA/HEVC-CU/model_MSEloss_Adam_0.001.pt'.format(LOAD_DIR))
if(batch_idx+1)%100 == 0:
print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
epoch, batch_idx * len(img_data32), len(train_loader.dataset),
100. * batch_idx / len(train_loader), loss.item()))
def validation(model, device, validation_loader,epoch):
global valid_loss_min,startTick
model.eval()
print("start validation...")
validation_loss = 0
correct = 0
label = []
for i in range(16):
label.append(str(i))
with torch.no_grad():
for img_data32,img_data64, target in validation_loader:
img_data32,img_data64, target = img_data32.to(device),img_data64.to(device), target.to(device)
output = model(img_data32,img_data64)
validation_loss = criterion(output,target.view(1,-1).float)
for i,single_pred in enumerate(output):
pred_0 = torch.argmax(single_pred[0:4])
pred_1 = torch.argmax(single_pred[4:8])
pred_2 = torch.argmax(single_pred[8:12])
pred_3 = torch.argmax(single_pred[12:16])
pred = str(int(pred_0)) + str(int(pred_1)) + str(int(pred_2)) + str(int(pred_3))
target_0 = int(target[i,0])
target_1 = int(target[i,1])
target_2 = int(target[i,2])
target_3 = int(target[i,3])
if str(pred[0]) == str(target_0):
correct += 1
if str(pred[1]) == str(target_1):
correct += 1
if str(pred[2]) == str(target_2):
correct += 1
if str(pred[3]) == str(target_3):
correct += 1
validation_loss = validation_loss*BATCH_SIZE/len(validation_loader.dataset)
timeSpan = time.clock() - startTick # Calculation takes time
print('EPOCH:{} Time used:{} Validation set: Average loss: {:.4f}'.format(epoch,str(timeSpan),validation_loss))
print('\nAccuracy: {}/{} ({:.2f}%)\n'.format(correct, len(validation_loader.dataset)*4, 100. * correct / len(validation_loader.dataset)/4))
if validation_loss < valid_loss_min:
valid_loss_min = validation_loss
print("saving model ...")
torch.save(model.state_dict(),'{}/gdrive/My Drive/RA/HEVC-CU/model_MSEloss_Adam_0.001.pt'.format(LOAD_DIR))
for epoch in range(1, EPOCHS + 1):
train(model, DEVICE, train_loader, optimizer, epoch)
validation(model, DEVICE, validation_loader,epoch)
/usr/local/lib/python3.6/dist-packages/torch/nn/modules/loss.py:443: UserWarning: Using a target size (torch.Size([1, 16])) that is different to the input size (torch.Size([4, 16])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.
return F.mse_loss(input, target, reduction=self.reduction)
---------------------------------------------------------------------------
RuntimeError Traceback (most recent call last)
<ipython-input-147-c7589b926dae> in <module>()
1 for epoch in range(1, EPOCHS + 1):
----> 2 train(model, DEVICE, train_loader, optimizer, epoch)
3 validation(model, DEVICE, validation_loader,epoch)
3 frames
<ipython-input-144-a7cdc82e4f14> in train(model, device, train_loader, optimizer, epoch)
17 #loss = criterion(output[:,0:4], target[:,0].float)+criterion(output[:,4:8], target[:,1].float)+criterion(output[:,8:12], target[:,2].float)+criterion(output[:,12:16], target[:,3].float)
18 #loss = criterion(output,target.view(1,-1))
---> 19 loss = criterion(output,target.view(1, -1))
20 loss.backward()
21 optimizer.step() # Update gradient
/usr/local/lib/python3.6/dist-packages/torch/nn/modules/module.py in __call__(self, *input, **kwargs)
491 result = self._slow_forward(*input, **kwargs)
492 else:
--> 493 result = self.forward(*input, **kwargs)
494 for hook in self._forward_hooks.values():
495 hook_result = hook(self, input, result)
/usr/local/lib/python3.6/dist-packages/torch/nn/modules/loss.py in forward(self, input, target)
441 @weak_script_method
442 def forward(self, input, target):
--> 443 return F.mse_loss(input, target, reduction=self.reduction)
444
445
/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py in mse_loss(input, target, size_average, reduce, reduction)
2255 else:
2256 expanded_input, expanded_target = torch.broadcast_tensors(input, target)
-> 2257 ret = torch._C._nn.mse_loss(expanded_input, expanded_target, _Reduction.get_enum(reduction))
2258 return ret
2259
RuntimeError: Expected object of scalar type Float but got scalar type Long for argument #2 'target'
Раньше я использовал функцию кросс-энтропийной потери, но теперь я собираюсь использовать MSE, но я получил эту ошибку:
"AttributeError: 'builtin_function_or_method' объект не имеет атрибута 'size' "
Я тоже пробовал:
loss = criterion(output,target.view(1,-1))
validation_loss = criterion(output,target.view(1,-1))
, но я получаю эту ошибку:
RuntimeError: Ожидаемый объект скалярного типа Float, но получил скалярный тип Long для аргумента # 2 'target'
Буду признателен, если кто-нибудь поможет мне решить эту проблему.