invalid index of a 0-dim tensor

[tju-sun-lab]

直接跑生成的script报错
indi-gen00-no00.py
Files already downloaded and verified
Files already downloaded and verified
/home/nature/anaconda3/envs/nas/lib/python3.8/site-packages/torch/nn/functional.py:718: UserWarning: Named tensors and all their associated APIs are an experimental feature and subject to change. Please do not use them for anything important until they are released as stable. (Triggered internally at /pytorch/c10/core/TensorImpl.h:1156.)
return torch.max_pool2d(input, kernel_size, stride, padding, dilation, ceil_mode)
Exception occurs, file:indi-gen00-no00, pid:18314...invalid index of a 0-dim tensor. Use tensor.item() in Python or tensor.item<T>() in C++ to convert a 0-dim tensor to a number

以下是indi-gen00-no00.py文件内部内容：
"""
2022-04-13 19:46:58
"""
from future import print_function
import torch
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F
import torch.backends.cudnn as cudnn
import torch.optim as optim
import data_loader
import os
from datetime import datetime
import multiprocessing
from utils import StatusUpdateTool

class ResNetBottleneck(nn.Module):
expansion = 1

def __init__(self, in_planes, planes, stride=1):
    super(ResNetBottleneck, self).__init__()
    self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=1, bias=False)
    self.bn1 = nn.BatchNorm2d(planes)
    self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
    self.bn2 = nn.BatchNorm2d(planes)
    self.conv3 = nn.Conv2d(planes, self.expansion*planes, kernel_size=1, bias=False)
    self.bn3 = nn.BatchNorm2d(self.expansion*planes)

    self.shortcut = nn.Sequential()
    if stride != 1 or in_planes != self.expansion*planes:
        self.shortcut = nn.Sequential(
            nn.Conv2d(in_planes, self.expansion*planes, kernel_size=1, stride=stride, bias=False),
            nn.BatchNorm2d(self.expansion*planes)
        )

def forward(self, x):
    out = F.relu(self.bn1(self.conv1(x)))
    out = F.relu(self.bn2(self.conv2(out)))
    out = self.bn3(self.conv3(out))
    out += self.shortcut(x)
    out = F.relu(out)
    return out

class ResNetUnit(nn.Module):
def init(self, amount, in_channel, out_channel):
super(ResNetUnit, self).init()
self.in_planes = in_channel
self.layer = self._make_layer(ResNetBottleneck, out_channel, amount, stride=1)

def _make_layer(self, block, planes, num_blocks, stride):
    strides = [stride] + [1]*(num_blocks-1)
    layers = []
    for stride in strides:
        layers.append(block(self.in_planes, planes, stride))
        self.in_planes = planes * block.expansion
    return nn.Sequential(*layers)
def forward(self, x):
    out = self.layer(x)
    return out

class DenseNetBottleneck(nn.Module):
def init(self, nChannels, growthRate):
super(DenseNetBottleneck, self).init()
interChannels = 4*growthRate
self.bn1 = nn.BatchNorm2d(nChannels)
self.conv1 = nn.Conv2d(nChannels, interChannels, kernel_size=1,
bias=False)
self.bn2 = nn.BatchNorm2d(interChannels)
self.conv2 = nn.Conv2d(interChannels, growthRate, kernel_size=3,
padding=1, bias=False)

def forward(self, x):
    out = self.conv1(F.relu(self.bn1(x)))
    out = self.conv2(F.relu(self.bn2(out)))
    out = torch.cat((x, out), 1)
    return out

class DenseNetUnit(nn.Module):
def init(self, k, amount, in_channel, out_channel, max_input_channel):
super(DenseNetUnit, self).init()
self.out_channel = out_channel
if in_channel > max_input_channel:
self.need_conv = True
self.bn = nn.BatchNorm2d(in_channel)
self.conv = nn.Conv2d(in_channel, max_input_channel, kernel_size=1, bias=False)
in_channel = max_input_channel

    self.layer = self._make_dense(in_channel, k, amount)

def _make_dense(self, nChannels, growthRate, nDenseBlocks):
    layers = []
    for _ in range(int(nDenseBlocks)):
        layers.append(DenseNetBottleneck(nChannels, growthRate))
        nChannels += growthRate
    return nn.Sequential(*layers)
def forward(self, x):
    out = x
    if hasattr(self, 'need_conv'):
        out = self.conv(F.relu(self.bn(out)))
    out = self.layer(out)
    assert(out.size()[1] == self.out_channel)
    return out

class EvoCNNModel(nn.Module):
def init(self):
super(EvoCNNModel, self).init()

    #resnet and densenet unit
    self.op0 = ResNetUnit(amount=7, in_channel=3, out_channel=64)
    self.op1 = ResNetUnit(amount=7, in_channel=64, out_channel=256)
    self.op6 = DenseNetUnit(k=12, amount=10, in_channel=256, out_channel=248, max_input_channel=128)
    self.op7 = ResNetUnit(amount=7, in_channel=248, out_channel=128)
    self.op8 = ResNetUnit(amount=6, in_channel=128, out_channel=256)

    #linear unit
    self.linear = nn.Linear(1024, 10)


def forward(self, x):
    out_0 = self.op0(x)
    out_1 = self.op1(out_0)
    out_2 = F.avg_pool2d(out_1, 2)
    out_3 = F.avg_pool2d(out_2, 2)
    out_4 = F.max_pool2d(out_3, 2)
    out_5 = F.avg_pool2d(out_4, 2)
    out_6 = self.op6(out_5)
    out_7 = self.op7(out_6)
    out_8 = self.op8(out_7)
    out = out_8

    out = out.view(out.size(0), -1)
    out = self.linear(out)
    return out

class TrainModel(object):
def init(self):
trainloader, validate_loader = data_loader.get_train_valid_loader('../data_cifar10', batch_size=128, augment=True, valid_size=0.1, shuffle=True, random_seed=2312390, show_sample=False, num_workers=1, pin_memory=True)
#testloader = data_loader.get_test_loader('../data_cifar10', batch_size=128, shuffle=False, num_workers=1, pin_memory=True)
net = EvoCNNModel()
cudnn.benchmark = True
net = net.cuda()
criterion = nn.CrossEntropyLoss()
best_acc = 0.0
self.net = net
self.criterion = criterion
self.best_acc = best_acc
self.trainloader = trainloader
self.validate_loader = validate_loader
self.file_id = os.path.basename(file).split('.')[0]
#self.testloader = testloader
#self.log_record(net, first_time=True)
#self.log_record('+'*50, first_time=False)

def log_record(self, _str, first_time=None):
    dt = datetime.now()
    dt.strftime( '%Y-%m-%d %H:%M:%S' )
    if first_time:
        file_mode = 'w'
    else:
        file_mode = 'a+'
    f = open('./log/%s.txt'%(self.file_id), file_mode)
    f.write('[%s]-%s\n'%(dt, _str))
    f.flush()
    f.close()

def train(self, epoch):
    self.net.train()
    if epoch ==0: lr = 0.01
    if epoch > 0: lr = 0.1;
    if epoch > 148: lr = 0.01
    if epoch > 248: lr = 0.001
    optimizer = optim.SGD(self.net.parameters(), lr=lr, momentum = 0.9, weight_decay=5e-4)
    running_loss = 0.0
    total = 0
    correct = 0
    for _, data in enumerate(self.trainloader, 0):
        inputs, labels = data
        inputs, labels = Variable(inputs.cuda()), Variable(labels.cuda())
        optimizer.zero_grad()
        outputs = self.net(inputs)
        loss = self.criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.data[0]*labels.size(0)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels.data).sum()
    self.log_record('Train-Epoch:%3d,  Loss: %.3f, Acc:%.3f'% (epoch+1, running_loss/total, (correct/total)))

def test(self, epoch):
    self.net.eval()
    test_loss = 0.0
    total = 0
    correct = 0
    for _, data in enumerate(self.validate_loader, 0):
        inputs, labels = data
        inputs, labels = Variable(inputs.cuda()), Variable(labels.cuda())
        outputs = self.net(inputs)
        loss = self.criterion(outputs, labels)
        test_loss += loss.data[0]*labels.size(0)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels.data).sum()
    if correct/total > self.best_acc:
        self.best_acc = correct/total
        #print('*'*100, self.best_acc)
    self.log_record('Validate-Loss:%.3f, Acc:%.3f'%(test_loss/total, correct/total))


def process(self):
    total_epoch = StatusUpdateTool.get_epoch_size()
    for p in range(total_epoch):
        self.train(p)
        self.test(total_epoch)
    return self.best_acc

class RunModel(object):
@classmethod
def do_work(self, gpu_id, file_id):
os.environ['CUDA_VISIBLE_DEVICES'] = gpu_id
best_acc = 0.0
try:
m = TrainModel()
m.log_record('Used GPU#%s, worker name:%s[%d]'%(gpu_id, multiprocessing.current_process().name, os.getpid()), first_time=True)
best_acc = m.process()
#import random
#best_acc = random.random()
except BaseException as e:
print('Exception occurs, file:%s, pid:%d...%s'%(file_id, os.getpid(), str(e)))
m.log_record('Exception occur:%s'%(str(e)))
finally:
m.log_record('Finished-Acc:%.3f'%best_acc)

        f = open('./populations/after_%s.txt'%(file_id[4:6]), 'a+')
        f.write('%s=%.5f\n'%(file_id, best_acc))
        f.flush()
        f.close()

if name == 'main':
RunModel.do_work(gpu_id='0', file_id='indi-gen00-no00')

[1234565556]

cifar.py中的loss.data[0]改成loss.item()