pytorch自定义初始化权重后模型loss一直在2点几
class Net(nn.Module):

    def __init__(self):
        super(Net,self).__init__()
        self.conv1 = nn.Conv2d(3,64,3,padding=1,bias=False)
        self.conv2 = nn.Conv2d(64,64,3,padding=1,bias=False)
        self.pool1 = nn.MaxPool2d(2, 2)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu1 = nn.ReLU()

        self.conv3 = nn.Conv2d(64,128,3,padding=1,bias=False)
        self.conv4 = nn.Conv2d(128, 128, 3,padding=1,bias=False)
        self.pool2 = nn.MaxPool2d(2, 2, padding=1)
        self.bn2 = nn.BatchNorm2d(128)
        self.relu2 = nn.ReLU()

        self.conv5 = nn.Conv2d(128,128, 3,padding=1,bias=False)
        self.conv6 = nn.Conv2d(128, 128, 3,padding=1,bias=False)
        self.conv7 = nn.Conv2d(128, 128, 1,padding=1,bias=False)
        self.pool3 = nn.MaxPool2d(2, 2, padding=1)
        self.bn3 = nn.BatchNorm2d(128)
        self.relu3 = nn.ReLU()

        self.conv8 = nn.Conv2d(128, 256, 3,padding=1,bias=False)
        self.conv9 = nn.Conv2d(256, 256, 3, padding=1,bias=False)
        self.conv10 = nn.Conv2d(256, 256, 1, padding=1,bias=False)
        self.pool4 = nn.MaxPool2d(2, 2, padding=1)
        self.bn4 = nn.BatchNorm2d(256)
        self.relu4 = nn.ReLU()

        self.conv11 = nn.Conv2d(256, 512, 3, padding=1,bias=False)
        self.conv12 = nn.Conv2d(512, 512, 3, padding=1,bias=False)
        self.conv13 = nn.Conv2d(512, 512, 1, padding=1,bias=False)
        self.pool5 = nn.MaxPool2d(2, 2, padding=1)
        self.bn5 = nn.BatchNorm2d(512)
        self.relu5 = nn.ReLU()

        self.fc14 = nn.Linear(512*4*4,1024)
        self.drop1 = nn.Dropout2d()
        self.fc15 = nn.Linear(1024,1024)
        self.drop2 = nn.Dropout2d()
        self.fc16 = nn.Linear(1024,10)


    def forward(self,x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = self.pool1(x)
        x = self.bn1(x)
        x = self.relu1(x)


        x = self.conv3(x)
        x = self.conv4(x)
        x = self.pool2(x)
        x = self.bn2(x)
        x = self.relu2(x)

        x = self.conv5(x)
        x = self.conv6(x)
        x = self.conv7(x)
        x = self.pool3(x)
        x = self.bn3(x)
        x = self.relu3(x)

        x = self.conv8(x)
        x = self.conv9(x)
        x = self.conv10(x)
        x = self.pool4(x)
        x = self.bn4(x)
        x = self.relu4(x)

        x = self.conv11(x)
        x = self.conv12(x)
        x = self.conv13(x)
        x = self.pool5(x)
        x = self.bn5(x)
        x = self.relu5(x)
        # print(" x shape ",x.size())
        x = x.view(-1,512*4*4)
        x = F.relu(self.fc14(x))
        x = self.drop1(x)
        x = F.relu(self.fc15(x))
        x = self.drop2(x)
        x = self.fc16(x)

        return x

model = Net()
#model = torch.nn.DataParallel(model)
if t.cuda.is_available():
    model.cuda()
print(model)
# torchvision输出的是PILImage,值的范围是[0, 1].
# 我们将其转化为tensor数据,并归一化为[-1, 1]。
transform = transforms.Compose([transforms.ToTensor(),
                                transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
                                ])
# 训练集,将相对目录./data下的cifar-10-batches-py文件夹中的全部数据(50000张图片作为训练数据)加载到内存中,若download为True时,会自动从网上下载数据并解压
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=False, transform=transform)
# 将训练集的50000张图片划分成12500份,每份4张图,用于mini-batch输入。shffule=True在表示不同批次的数据遍历时,打乱顺序。num_workers=2表示使用两个子进程来加载数据
trainloader = torch.utils.data.DataLoader(trainset, batch_size=100, shuffle=False, num_workers=1)
#测试集,将相对目录./data下的cifar-10-batches-py文件夹中的全部数据(10000张图片作为测试数据)加载到内存中,若download为True时,会自动从网上下载数据并解压
testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=False, transform=transform)
# 将测试集的10000张图片划分成2500份,每份4张图,用于mini-batch输入。
testloader = torch.utils.data.DataLoader(testset, batch_size=50,
                                         shuffle=False, num_workers=1)
criterion = nn.CrossEntropyLoss()#叉熵损失函数
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)#使用SGD(随机梯度下降)优化,学习率为0.001,动量为0.9
for epoch in range(1):  # 遍历数据集10次
    running_loss = 0.0
    # enumerate(sequence, [start=0]),i序号,data是数据
    for i, data in enumerate(trainloader, 0):
    #for i in range(1000):
        # get the inputs
        #data is list
        inputs, labels = data  # data的结构是:[4x3x32x32的张量,长度4的张量]
        # wrap them in Variable
        inputs = Variable(inputs)
        labels=Variable(labels)# 把input数据从tensor转为variable
        if t.cuda.is_available():
            inputs=inputs.cuda()
            labels=labels.cuda()
        #inputs,labels= inputs.type(torch.FloatTensor),labels.type(torch.FloatTensor)
        # zero the parameter gradients
        optimizer.zero_grad()  # 将参数的grad值初始化为0
        # forward + backward + optimize
        outputs = model(inputs)
        loss = criterion(outputs, labels)  # 将output和labels使用叉熵计算损失
        loss.backward()  # 反向传播
        optimizer.step()  # 用SGD更新参数
        # 每2000批数据打印一次平均loss值
        running_loss += loss.item()  # loss本身为Variable类型,所以要使用data获取其Tensor,因为其为标量,所以取0  或使用loss.item()
        if i % 500 == 499:  # 每2000批打印一次
            print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 500))
            running_loss = 0.0
print('Finished Training')
start = time.clock()#.time
correct = 0
total = 0
for data in testloader:
    images, labels = data
    images=images.cuda()
    labels=labels.cuda()
    outputs = model(Variable(images))
    print(outputs.shape)
    _, predicted = torch.max(outputs.data, 1)
    total += labels.size(0)
    correct += (predicted == labels).sum()
print('Accuracy of the network on the 10000 test images: %d %%' % (
        100 * correct / total))
end = time.clock()#.time
print("Running time: %s Seconds"  % (end-start))

weight0=np.random.random((64,3,3,3))
weight0=nn.Parameter(torch.FloatTensor(weight0).cuda(),requires_grad=True)
#weight1=np.random.random((64,64,3,3),dtype=np.float32)
weight1=np.random.random((64,64,3,3))
weight1=nn.Parameter(torch.FloatTensor(weight1).cuda(),requires_grad=True)

weight2=np.random.random((128,64,3,3))
weight2=nn.Parameter(torch.FloatTensor(weight2).cuda(),requires_grad=True)


weight3=np.random.random((128,128,3,3))
weight3=nn.Parameter(torch.FloatTensor(weight3).cuda(),requires_grad=True)


weight4=np.random.random((128,128,3,3))
weight4=nn.Parameter(torch.FloatTensor(weight4).cuda(),requires_grad=True)


weight5=np.random.random((128,128,3,3))
weight5=nn.Parameter(torch.FloatTensor(weight5).cuda(),requires_grad=True)


weight6=np.random.random((128,128,1,1))
weight6=nn.Parameter(torch.FloatTensor(weight6).cuda(),requires_grad=True)


weight7=np.random.random((256,128,3,3))
weight7=nn.Parameter(torch.FloatTensor(weight7).cuda(),requires_grad=True)


weight8=np.random.random((256,256,3,3))
weight8=nn.Parameter(torch.FloatTensor(weight8).cuda(),requires_grad=True)


weight9=np.random.random((256,256,1,1))
weight9=nn.Parameter(torch.FloatTensor(weight9).cuda(),requires_grad=True)


weight10=np.random.random((512,256,3,3))
weight10=nn.Parameter(torch.FloatTensor(weight10).cuda(),requires_grad=True)


weight11=np.random.random((512,512,3,3))
weight11=nn.Parameter(torch.FloatTensor(weight11).cuda(),requires_grad=True)


weight12=np.random.random((512,512,1,1))
weight12=nn.Parameter(torch.FloatTensor(weight12).cuda(),requires_grad=True)



new_layer_id=0
for  m1 in model.modules():
    if isinstance(m1, nn.Conv2d):
        if (new_layer_id==0):
            m1.weight = weight0
        elif(new_layer_id==1):
            m1.weight= weight1
        elif(new_layer_id==2):
            m1.weight = weight2
        elif(new_layer_id==3):
            m1.weight = weight3
        elif(new_layer_id==4):
            m1.weight = weight4
        elif(new_layer_id==5): 
            m1.weight = weight5
        elif(new_layer_id==6):
            m1.weight = weight6
        elif(new_layer_id==7):
            m1.weight = weight7
        elif(new_layer_id==8):
            m1.weight = weight8
        elif(new_layer_id==9):
            m1.weight = weight9
        elif(new_layer_id==10):
            m1.weight = weight10
        elif(new_layer_id==11):
            m1.weight = weight11
        elif(new_layer_id==12):
            m1.weight = weight12
        new_layer_id=new_layer_id+1
    elif isinstance(m1, nn.BatchNorm2d):
        m1.weight = m1.weight
        m1.bias = m1.bias
    elif isinstance(m1, nn.Linear):
        m1.weight = m1.weight
        m1.bias = m1.bias

 #torchvision输出的是PILImage,值的范围是[0, 1].
# 我们将其转化为tensor数据,并归一化为[-1, 1]。
transform = transforms.Compose([transforms.ToTensor(),
                                transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
                                ])
# 训练集,将相对目录./data下的cifar-10-batches-py文件夹中的全部数据(50000张图片作为训练数据)加载到内存中,若download为True时,会自动从网上下载数据并解压
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=False, transform=transform)
# 将训练集的50000张图片划分成12500份,每份4张图,用于mini-batch输入。shffule=True在表示不同批次的数据遍历时,打乱顺序。num_workers=2表示使用两个子进程来加载数据
trainloader = torch.utils.data.DataLoader(trainset, batch_size=100, shuffle=False, num_workers=1)
#测试集,将相对目录./data下的cifar-10-batches-py文件夹中的全部数据(10000张图片作为测试数据)加载到内存中,若download为True时,会自动从网上下载数据并解压
testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=False, transform=transform)
# 将测试集的10000张图片划分成2500份,每份4张图,用于mini-batch输入。
testloader = torch.utils.data.DataLoader(testset, batch_size=50,
                                         shuffle=False, num_workers=1)
criterion1 = nn.CrossEntropyLoss()#叉熵损失函数
optimizer1 = optim.Adam(model.parameters(), lr=0.001)#使用SGD(随机梯度下降)优化,学习率为0.001,动量为0.9
#momentum=0.9

start = time.clock()#.time
correct = 0
total = 0
for data in testloader:
    images, labels = data
    images=images.cuda()
    labels=labels.cuda()
    outputs = model(Variable(images))
    _, predicted = torch.max(outputs.data, 1)
    total += labels.size(0)
    correct += (predicted == labels).sum()
print('Accuracy of the Newmodel1 on the 10000 test images: %d %%' % (
        100 * correct / total))
end = time.clock()#.time


print("Running time: %s Seconds"  % (end-start))

for epoch in range(20):  
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
    #for i in range(1000):
        inputs, labels = data  
        inputs = Variable(inputs)
        #print(inputs.shape)
        labels=Variable(labels)
        inputs=inputs.cuda()
        labels=labels.cuda()
        optimizer1.zero_grad()  
        outputs = model(inputs)
        loss = criterion1(outputs, labels)  
        loss.backward() 
        optimizer1.step()  
        running_loss += loss.item()  
        if i % 500 == 499:  
            print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 500))
Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!
其他相关推荐
pytorch自定义loss函数

大家好,在实现自定义的语义分割的loss函数的时候,遇到了问题,请大家帮忙一下, 这个自定义的loss函数的做法是,根据真实label(batchsize,h,w)的每个pixel的对应的class值,在网络的输出的预测值(batch-size,num-class,h,w)中,选出class对应的那个预测值,得到的就是真实label的每个pixel的class对应的预测值(batchsize,h,w),现在我自己按照我下面的方式想实现上述的目的,但是在pytorh中的loss函数,想要能够反向传播就必须所有的值都是Variable,现在发现的问题就在pytorch的tensor中的flatten函数会有问题,想问问大家有没有什么方式能够在tensor的方式下实现。

pytorch自定义loss,如何进行后向传播loss.backward()?

之前loss用自带的MSE,这样写的 ``` criterion = nn.MSELoss(size_average=False).cuda() ... loss = criterion(output, target) loss.backward() ``` 这样是没有问题的 *** 现在需要用自定义loss函数newLoss,因为要逐个像素进行loss运算(算法需要) ``` #this is in model.py class newLoss(nn.Module): def __init__(self): super(newLoss, self).__init__() def forward(self, output, gt): loss = 0 for row_out, row_gt : for pixel_out, pixel_gt : loss += something pixelwise return loss # this is in train.py newloss = newLoss() loss = newloss(output,gt) ``` 这样计算出来的loss是float类型的,下面的代码会报 ''AttributeError: 'float' object has no attribute 'backward'' 的错 ---- 我现在的做法是:把newloss数值加到原来的MSE类型loss上: ``` criterion = nn.MSELoss(size_average=False).cuda() ... loss = criterion(output, target) newloss= newLoss() loss += newloss(output,gt) loss.backward() ``` 这样写我新加的newloss在后向传播时能生效吗?

pytorch空权重运行,按理说是随机数,为何每次运行结果相同?

使用MSE和相关系数两个参数作为验证,使得模型空权重运行,按理说是随机初始化权重,但是运行几次发现两个评价指标没有变化,比如第一次的MSE是0.123,第二,第三次还是0.123这是什么原因呢?

求助:(Pytorch)resnet加载预训练好的模型finetune时conv、bn层权重均不更新,为什么呢?

在resnet先进行了预训练后,根据预训练权重进行剪枝,再加载剪枝后模型及权重后,对模型进行finetune时,发现conv、bn层的权重均没有更新。尝试改变学习率后对结果没有影响。 p.requires_grad: True net.stage_1[0].bn_a.track_running_stats: True net.stage_1[0].bn_a.training: False 上面的情况,finetune与train时都一致,没有变化。 finetune代码与train代码其实没有什么区别,只不过一个前者加载了个模型而已,为什么后者可以正常更新权重,前者却不可以?还可能是什么原因呢?

pytorch编写ResNet,在kernel权值初始化的时候,将小波赋值给初值,如何实现单个核的值符合小波分布呢??

我要处理的是一维信号,单个核的维度是1X1X5,假设有5个核,所有5个核的值就是权值,我现在会的是将这五个核的值全取出进行整体赋值,但这样赋值的话,是这5个核整体数值符合小波分布,而不是单个核的值符合小波分布,如何实现单个核的值符合小波分布呢?

tensorflow训练过程权重不更新,loss不下降,输出保持不变,只有bias在非常缓慢地变化?

模型里没有参数被初始化为0 ,学习率从10的-5次方试到了0.1,输入数据都已经被归一化为了0-1之间,模型是改过的vgg16,有四个输出,使用了vgg16的预训练模型来初始化参数,输出中间结果也没有nan或者inf值。是不是不能自定义损失函数呢?但输出中间梯度发现并不是0,非常奇怪。 **train.py的部分代码** ``` def train(): x = tf.placeholder(tf.float32, [None, 182, 182, 2], name = 'image_input') y_ = tf.placeholder(tf.float32, [None, 8], name='label_input') global_step = tf.Variable(0, trainable=False) learning_rate = tf.train.exponential_decay(learning_rate=0.0001,decay_rate=0.9, global_step=TRAINING_STEPS, decay_steps=50,staircase=True) # 读取图片数据,pos是标签为1的图,neg是标签为0的图 pos, neg = get_data.get_image(img_path) #输入标签固定,输入数据每个batch前4张放pos,后4张放neg label_batch = np.reshape(np.array([1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0]),[1, 8]) vgg = vgg16.Vgg16() vgg.build(x) #loss函数的定义在后面 loss = vgg.side_loss( y_,vgg.output1, vgg.output2, vgg.output3, vgg.output4) train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss, global_step=global_step) init_op = tf.global_variables_initializer() saver = tf.train.Saver() with tf.device('/gpu:0'): with tf.Session() as sess: sess.run(init_op) for i in range(TRAINING_STEPS): #在train.py的其他部分定义了batch_size= 4 start = i * batch_size end = start + batch_size #制作输入数据,前4个是标签为1的图,后4个是标签为0的图 image_list = [] image_list.append(pos[start:end]) image_list.append(neg[start:end]) image_batch = np.reshape(np.array(image_list),[-1,182,182,2]) _,loss_val,step = sess.run([train_step,loss,global_step], feed_dict={x: image_batch,y_:label_batch}) if i % 50 == 0: print("the step is %d,loss is %f" % (step, loss_val)) if loss_val < min_loss: min_loss = loss_val saver.save(sess, 'ckpt/vgg.ckpt', global_step=2000) ``` **Loss 函数的定义** ``` **loss函数的定义(写在了Vgg16类里)** ``` class Vgg16: #a,b,c,d都是vgg模型里的输出,是多输出模型 def side_loss(self,yi,a,b,c,d): self.loss1 = self.f_indicator(yi, a) self.loss2 = self.f_indicator(yi, b) self.loss3 = self.f_indicator(yi, c) self.loss_fuse = self.f_indicator(yi, d) self.loss_side = self.loss1 + self.loss2 + self.loss3 + self.loss_fuse res_loss = tf.reduce_sum(self.loss_side) return res_loss #损失函数的定义,标签为0时为log(1-yj),标签为1时为log(yj) def f_indicator(self,yi,yj): b = tf.where(yj>=1,yj*50,tf.abs(tf.log(tf.abs(1 - yj)))) res=tf.where(tf.equal(yi , 0.0), b,tf.abs(tf.log(tf.clip_by_value(yj, 1e-8, float("inf"))))) return res ```

pytorch训练LSTM模型的代码疑问

原博文链接地址:https://blog.csdn.net/Sebastien23/article/details/80574918 其中有不少代码完全看不太懂,想来这里求教下各位大神~~ ``` class Sequence(nn.Module): def __init__(self): super(Sequence,self).__init__() self.lstm1 = nn.LSTMCell(1,51) self.lstm2 = nn.LSTMCell(51,51) self.linear = nn.Linear(51,1) #上面三行代码是设置网络结构吧?为什么用的是LSTMCell,而不是LSTM?? def forward(self,inputs,future= 0): #这里的前向传播名称必须是forward,而不能随意更改??因为后面的模型调用过程中,并没有看到该方法的实现 outputs = [] h_t = torch.zeros(inputs.size(0),51) c_t = torch.zeros(inputs.size(0),51) h_t2 = torch.zeros(inputs.size(0),51) c_t2 = torch.zeros(inputs.size(0),51) #下面的代码中,LSTM的原理是要求三个输入:前一层的细胞状态、隐藏层状态和当前层的数据输入。这里却只有2个输入?? for i,input_t in enumerate(inputs.chunk(inputs.size(1),dim =1)): h_t,c_t = self.lstm1(input_t,(h_t,c_t)) h_t2,c_t2 = self.lstm2(h_t,(h_t2,c_t2)) output = self.linear(h_t2) outputs +=[output] for i in range(future): h_t,c_t = self.lstm1(output,(h_t,c_t)) h_t2,c_t2 = self.lstm2(h_t,(h_t2,c_t2)) output = self.linear(h_t2) outputs +=[output] #下面将所有的输出在第一维上相拼接,并剪除维度为2的数据??目的是什么? outputs = torch.stack(outputs,1).squeeze(2) return outputs ```

训练模型 loss没有变化 哪里出错了

![图片说明](https://img-ask.csdn.net/upload/201902/20/1550603855_716468.jpg) ![图片说明](https://img-ask.csdn.net/upload/201902/20/1550603869_798720.jpg) ![图片说明](https://img-ask.csdn.net/upload/201902/20/1550603889_814072.jpg)

求助:(pytorch)resnet加载预训练模型finetune的时候无法更新bn层、conv层

在预训练过resnet模型,并剪枝后,加载剪枝后的模型并加载权重重训练时,bn层、conv层的权重完全没用更新,这是为什么呢?也尝试修改了学习率,没有区别,依然不更新 net.stage_1[0].bn_a.track_running_stats: True net.stage_1[0].bn_a.training: False 这是其中一层bn层的track_running_stats与training的情况,与正常预训练时的情况完全没用区别。

Windows安装PyTorch出现import不成功

使用pip安装pytorch显示安装成功,在cmd中查看torch和torchvision版本号均能看到,但在cmd中测试import torch时显示ModuleNotFoundError,想请教是哪里出了问题? 以下是截图: ![图片说明](https://img-ask.csdn.net/upload/202001/06/1578284725_642134.jpg) ![图片说明](https://img-ask.csdn.net/upload/202001/06/1578285995_53048.jpg)

请问,如何优化pytorch的模型预测速度

Namespace(backbone='resnet', batchSize=4, epoch_size=3, gpu_id='0', lr=1e-07, nAveGrad=1, nEpochs=100, nTestInterval=1, nThreads=1, phaseprediction='prediction', phasetest='test', phasetrain='train', resume_epoch=0, snapshot=3, testBatch=1, useTest=True, wd=0.0005) ------------ Options ------------- backbone: resnet batchSize: 4 epoch_size: 3 gpu_id: 0 gpu_ids: [0] lr: 1e-07 nAveGrad: 1 nEpochs: 100 nTestInterval: 1 nThreads: 1 phaseprediction: prediction phasetest: test phasetrain: train resume_epoch: 0 snapshot: 3 testBatch: 1 useTest: True wd: 0.0005 -------------- End ---------------- Constructing DeepLabv3+ model... Number of classes: 2 Output stride: 16 Number of Input Channels: 3 这是相关的参数设置,gpu:为2080ti,cuda:10.0 预测单张图片(1024*768)的速度很慢,要7-10s,有什么方法可以缩短时间到1-2s

训练时,loss一直变大是哪里错了?

self.loss2 = tf.losses.mean_squared_error(reward,pred) self.lr2 = tf.train.exponential_decay(self.lr2_start, self.global_step2, self.lr2_decay_step,self.lr2_decay_rate, staircase=False, name="learning_rate2") self.opt2 = tf.train.RMSPropOptimizer(learning_rate=self.lr2,name='opt2') self.grads2 = self.opt2.compute_gradients(self.loss2,var_list=tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,scope="critic")) self.grads2 = [(tf.clip_by_value(grad, -1., 1.), var) for grad, var in self.grads2 if grad is not None] self.train_step2 = self.opt2.apply_gradients(self.grads2,global_step=self.global_step2) 这个loss2的值会一直向负无穷变化,是我哪里写错了么

pytorch 的Cross Entropy Loss 输入怎么填?

以识别一个四位数的验证码为例,批次取为100,标签用one_hot 表示,则标签的size为[100,4,10],input也为[100,4,10],请问loss用torch.nn.CrossEntropyLoss时,输入的input和target分别应为多少? 另外,用其他几种损失函数时,以四位验证码为例,输入该各是多少?

pytorch利用反卷积的尺寸问题

大家好,新手入门语义分割,在利用pytorch实现Linknet的时候,在编码层最后输出的尺寸为6×10(上一层为12× 20),文中规定反卷积核的尺寸为k为3× 3,步长s = 2,利用反卷积求输出尺寸的大小为N(out) = (N(in)-1)× s +k -2p,如果按照这个核的尺寸大小进行计算的话,输出的大小就不会是我想要的12× 20,而是11× 19(padding=1)或13 ×21(padding=0),问了学长说是卷积的核的尺寸一般都为奇数最好不要修改,(论文里的也是奇数3 ×3 的),这个好像说是用keras框架写就不会有这个问题,但是现在我用的是pytorch,请问这个应该如何解决?

pytorch加载model发现key的值有差异,能不能修改

用pytorch加载别人训练的模型时候, RuntimeError: Error(s) in loading state_dict for PSMNet: Missing key(s) in state_dict: "feature_extraction.firstconv.0.0.weight", "feature_extraction.firstconv.0.1.weight",。。。。。 Unexpected key(s) in state_dict: "module.feature_extraction.firstconv.0.0.weight", "module.feature_extraction.firstconv.0.1.weight", ![图片说明](https://img-ask.csdn.net/upload/201904/12/1555047581_366964.jpg) 发现每个在模型里的参数都多个了module. 保存的格式是 ``` torch.save({ 'epoch': epoch, 'state_dict': model.state_dict(), 'train_loss': total_train_loss / len(TrainImgLoader), }, savefilename) ``` 读取的代码是 ``` state_dict = torch.load(basic.loadmodel) model.load_state_dict(state_dict['state_dict']) ``` 请问能不能做到将模型的key值从 module.feature_extraction.firstconv.0.1.weight 修改到 feature_extraction.firstconv.0.1.weight

有关pytorch中梯度为None的情况

一直在用现成的框架写东西,这几天有空心血来潮想自己写个简单的神经网络,结果不知道怎么回事backward到第二步的时候w1.grad和w2.grad都是None 求各位解答: ``` import torch import numpy as np N, D_in, H, D_out = 64, 1000, 100, 10 learning_rate = 1e-6 x = torch.randn(N, D_in) y = torch.randn(N, D_out) w1 = torch.randn(D_in, H) w2 = torch.randn(H, D_out) learning_rate = 1e-6 for it in range(500): w1=w1.requires_grad_() w2=w2.requires_grad_() # Forward pass y_pred = x.mm(w1).clamp(min=0).mm(w2) # compute loss loss = (y_pred - y).pow(2).sum() # computation graph print(it, loss.item()) # Backward pass loss.backward() w1=(w1-learning_rate*w1.grad) w2=(w2-learning_rate*w2.grad) ```

pytorch安装后不能import

pytorch安装成功了,但是在spyder中不能import,在终端进入python前需要输入“source activate my_root” 后进入python才能import,是什么原因?有什么解决办法? 本人Linux萌新一枚,望解释详细一点 ![图片说明](https://img-ask.csdn.net/upload/201801/24/1516773572_423018.png)

pytorch的MNIST代码中loss输出的疑问

MNIST的训练集一共**60000**个,我设置**mini-batch=128**,分成**469批** ``` python train_dataset = mnist.MNIST('./data', train=True, transform=transform, download=False) test_dataset = mnist.MNIST('./data', train=False, transform=transform) print(train_dataset) train_loader = DataLoader(train_dataset, batch_size=train_batch_size, shuffle=True) test_loader = DataLoader(test_dataset, batch_size=test_batch_size, shuffle=False)[/code] ``` 我看教程给的代码,里面loss的计算如下 ```python out = model(img) loss = criterion(out, label) optimizer.zero_grad() loss.backward() optimizer.step() train_loss += loss.item() _, pred = out.max(1) num_correct = (pred == label).sum().item() acc = num_correct / img.shape[0] train_acc += acc ``` 最后输出 ```python print('epoch:{},Train Loss:{:.4f}, Train Acc: {:.4f},Test Loss: {:.4f}, Test Acc: {:.4f}'.format(epoch, train_loss / len(train_loader), train_acc / len(train_loader),eval_loss / len(test_loader), eval_acc / len(test_loader)) ``` 其中len(train\_loader)=**469**,损失函数使用的是交叉熵函数,每个循环的loss都是当前批次的loss总和,没有除以N。我想请问为什么最后输出的loss不是除以6000/128,而是len(train\_loader),毕竟6000不能被128整除,所以最后一个批次的数量是达不到128的,那么这一批的loss肯定也只是6000-128\*468=**96**个数据的和,这样再除以469的话难免会有一些误差。acc也是同理 我特地找了下pytorch官方的案例,里面是把所有数据的loss加起来,最后除以总数,如下 ```python test_loss += F.nll_loss(output, target, reduction='sum').item() # sum up batch loss pred = output.argmax(dim=1, keepdim=True) # get the index of the max log-probability correct += pred.eq(target.view_as(pred)).sum().item() test_loss /= len(test_loader.dataset) print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format( test_loss, correct, len(test_loader.dataset), 100. * correct / len(test_loader.dataset))) ``` 我这里的代码是来自《Python深度学习:基于Pytorch》,是不是在最后的计算方法上不够严谨呢,还是说这点误差可以忽略不计 大家都是怎么计算loss和acc的呢

Python可以这样学(第一季:Python内功修炼)

董付国系列教材《Python程序设计基础》、《Python程序设计(第2版)》、《Python可以这样学》配套视频,讲解Python 3.5.x和3.6.x语法、内置对象用法、选择与循环以及函数设计与使用、lambda表达式用法、字符串与正则表达式应用、面向对象编程、文本文件与二进制文件操作、目录操作与系统运维、异常处理结构。

获取Linux下Ftp目录树并逐步绑定到treeview

在linux下抓取目录树,双击后获取该节点子节点(逐步生成)。另外有两个类,一个是windows下的(一次性获取目录树),一个是linux下的(足部获取目录树)

NS网络模拟和协议仿真源代码

NS网络模拟和协议仿真源代码,包含代码说明及协议分析

简单的NS3网络模拟仿真(计算机网络作业)

简单的NS3网络模拟仿真,内附有PPT演示。论文评述。以及简单的安装教程。

手把手实现Java图书管理系统(附源码)

【超实用课程内容】 本课程演示的是一套基于Java的SSM框架实现的图书管理系统,主要针对计算机相关专业的正在做毕设的学生与需要项目实战练习的java人群。详细介绍了图书管理系统的实现,包括:环境搭建、系统业务、技术实现、项目运行、功能演示、系统扩展等,以通俗易懂的方式,手把手的带你从零开始运行本套图书管理系统,该项目附带全部源码可作为毕设使用。 【课程如何观看?】 PC端:https://edu.csdn.net/course/detail/27513 移动端:CSDN 学院APP(注意不是CSDN APP哦) 本课程为录播课,课程2年有效观看时长,大家可以抓紧时间学习后一起讨论哦~ 【学员专享增值服务】 源码开放 课件、课程案例代码完全开放给你,你可以根据所学知识,自行修改、优化

三个项目玩转深度学习(附1G源码)

从事大数据与人工智能开发与实践约十年,钱老师亲自见证了大数据行业的发展与人工智能的从冷到热。事实证明,计算机技术的发展,算力突破,海量数据,机器人技术等,开启了第四次工业革命的序章。深度学习图像分类一直是人工智能的经典任务,是智慧零售、安防、无人驾驶等机器视觉应用领域的核心技术之一,掌握图像分类技术是机器视觉学习的重中之重。针对现有线上学习的特点与实际需求,我们开发了人工智能案例实战系列课程。打造:以项目案例实践为驱动的课程学习方式,覆盖了智能零售,智慧交通等常见领域,通过基础学习、项目案例实践、社群答疑,三维立体的方式,打造最好的学习效果。

150讲轻松搞定Python网络爬虫

【为什么学爬虫?】 &nbsp; &nbsp; &nbsp; &nbsp;1、爬虫入手容易,但是深入较难,如何写出高效率的爬虫,如何写出灵活性高可扩展的爬虫都是一项技术活。另外在爬虫过程中,经常容易遇到被反爬虫,比如字体反爬、IP识别、验证码等,如何层层攻克难点拿到想要的数据,这门课程,你都能学到! &nbsp; &nbsp; &nbsp; &nbsp;2、如果是作为一个其他行业的开发者,比如app开发,web开发,学习爬虫能让你加强对技术的认知,能够开发出更加安全的软件和网站 【课程设计】 一个完整的爬虫程序,无论大小,总体来说可以分成三个步骤,分别是: 网络请求:模拟浏览器的行为从网上抓取数据。 数据解析:将请求下来的数据进行过滤,提取我们想要的数据。 数据存储:将提取到的数据存储到硬盘或者内存中。比如用mysql数据库或者redis等。 那么本课程也是按照这几个步骤循序渐进的进行讲解,带领学生完整的掌握每个步骤的技术。另外,因为爬虫的多样性,在爬取的过程中可能会发生被反爬、效率低下等。因此我们又增加了两个章节用来提高爬虫程序的灵活性,分别是: 爬虫进阶:包括IP代理,多线程爬虫,图形验证码识别、JS加密解密、动态网页爬虫、字体反爬识别等。 Scrapy和分布式爬虫:Scrapy框架、Scrapy-redis组件、分布式爬虫等。 通过爬虫进阶的知识点我们能应付大量的反爬网站,而Scrapy框架作为一个专业的爬虫框架,使用他可以快速提高我们编写爬虫程序的效率和速度。另外如果一台机器不能满足你的需求,我们可以用分布式爬虫让多台机器帮助你快速爬取数据。 &nbsp; 从基础爬虫到商业化应用爬虫,本套课程满足您的所有需求! 【课程服务】 专属付费社群+每周三讨论会+1v1答疑

cuda开发cutilDLL

包括cutil32.dll、cutil32D.dll、cutil32.lib、cutil32D.lib,以及附带的glew32.lib/freeglut.lib

深度学习原理+项目实战+算法详解+主流框架(套餐)

深度学习系列课程从深度学习基础知识点开始讲解一步步进入神经网络的世界再到卷积和递归神经网络,详解各大经典网络架构。实战部分选择当下最火爆深度学习框架PyTorch与Tensorflow/Keras,全程实战演示框架核心使用与建模方法。项目实战部分选择计算机视觉与自然语言处理领域经典项目,从零开始详解算法原理,debug模式逐行代码解读。适合准备就业和转行的同学们加入学习! 建议按照下列课程顺序来进行学习 (1)掌握深度学习必备经典网络架构 (2)深度框架实战方法 (3)计算机视觉与自然语言处理项目实战。(按照课程排列顺序即可)

Tensorflow与python3.7适配版本

tensorflow与python3.7匹配的最新库,更新了python3.7以后可以自行下载,或者去国外python的扩展包下载界面自行下载。

4小时玩转微信小程序——基础入门与微信支付实战

这是一个门针对零基础学员学习微信小程序开发的视频教学课程。课程采用腾讯官方文档作为教程的唯一技术资料来源。杜绝网络上质量良莠不齐的资料给学员学习带来的障碍。 视频课程按照开发工具的下载、安装、使用、程序结构、视图层、逻辑层、微信小程序等几个部分组织课程,详细讲解整个小程序的开发过程

专为程序员设计的数学课

<p> 限时福利限时福利,<span>15000+程序员的选择!</span> </p> <p> 购课后添加学习助手(微信号:csdn590),按提示消息领取编程大礼包!并获取讲师答疑服务! </p> <p> <br> </p> <p> 套餐中一共包含5门程序员必学的数学课程(共47讲) </p> <p> 课程1:《零基础入门微积分》 </p> <p> 课程2:《数理统计与概率论》 </p> <p> 课程3:《代码学习线性代数》 </p> <p> 课程4:《数据处理的最优化》 </p> <p> 课程5:《马尔可夫随机过程》 </p> <p> <br> </p> <p> 哪些人适合学习这门课程? </p> <p> 1)大学生,平时只学习了数学理论,并未接触如何应用数学解决编程问题; </p> <p> 2)对算法、数据结构掌握程度薄弱的人,数学可以让你更好的理解算法、数据结构原理及应用; </p> <p> 3)看不懂大牛代码设计思想的人,因为所有的程序设计底层逻辑都是数学; </p> <p> 4)想学习新技术,如:人工智能、机器学习、深度学习等,这门课程是你的必修课程; </p> <p> 5)想修炼更好的编程内功,在遇到问题时可以灵活的应用数学思维解决问题。 </p> <p> <br> </p> <p> 在这门「专为程序员设计的数学课」系列课中,我们保证你能收获到这些:<br> <br> <span> </span> </p> <p class="ql-long-24357476"> <span class="ql-author-24357476">①价值300元编程课程大礼包</span> </p> <p class="ql-long-24357476"> <span class="ql-author-24357476">②应用数学优化代码的实操方法</span> </p> <p class="ql-long-24357476"> <span class="ql-author-24357476">③数学理论在编程实战中的应用</span> </p> <p class="ql-long-24357476"> <span class="ql-author-24357476">④程序员必学的5大数学知识</span> </p> <p class="ql-long-24357476"> <span class="ql-author-24357476">⑤人工智能领域必修数学课</span> </p> <p> <br> 备注:此课程只讲程序员所需要的数学,即使你数学基础薄弱,也能听懂,只需要初中的数学知识就足矣。<br> <br> 如何听课? </p> <p> 1、登录CSDN学院 APP 在我的课程中进行学习; </p> <p> 2、登录CSDN学院官网。 </p> <p> <br> </p> <p> 购课后如何领取免费赠送的编程大礼包和加入答疑群? </p> <p> 购课后,添加助教微信:<span> csdn590</span>,按提示领取编程大礼包,或观看付费视频的第一节内容扫码进群答疑交流! </p> <p> <img src="https://img-bss.csdn.net/201912251155398753.jpg" alt=""> </p>

实现简单的文件系统

实验内容: 通过对具体的文件存储空间的管理、文件的物理结构、目录结构和文件操作的实现,加深对文件系统内部功能和实现过程的理解。 要求: 1.在内存中开辟一个虚拟磁盘空间作为文件存储器,在其上实现一个简

机器学习初学者必会的案例精讲

通过六个实际的编码项目,带领同学入门人工智能。这些项目涉及机器学习(回归,分类,聚类),深度学习(神经网络),底层数学算法,Weka数据挖掘,利用Git开源项目实战等。

四分之一悬架模型simulink.7z

首先建立了四分之一车辆悬架系统的数学模型,应用MATLAB/Simulink软件建立该系统的仿真模型,并输入路面激励为随机激励,控制不同的悬架刚度和阻尼,选用最优的参数得到车辆悬架的振动加速度变化曲线

MFC一站式终极全套课程包

该套餐共包含从C小白到C++到MFC的全部课程,整套学下来绝对成为一名C++大牛!!!

C++语言基础视频教程

C++语言基础视频培训课程:本课与主讲者在大学开出的程序设计课程直接对接,准确把握知识点,注重教学视频与实践体系的结合,帮助初学者有效学习。本教程详细介绍C++语言中的封装、数据隐藏、继承、多态的实现等入门知识;主要包括类的声明、对象定义、构造函数和析构函数、运算符重载、继承和派生、多态性实现等。 课程需要有C语言程序设计的基础(可以利用本人开出的《C语言与程序设计》系列课学习)。学习者能够通过实践的方式,学会利用C++语言解决问题,具备进一步学习利用C++开发应用程序的基础。

Java8零基础入门视频教程

这门课程基于主流的java8平台,由浅入深的详细讲解了java SE的开发技术,可以使java方向的入门学员,快速扎实的掌握java开发技术!

HoloLens2开发入门教程

本课程为HoloLens2开发入门教程,讲解部署开发环境,安装VS2019,Unity版本,Windows SDK,创建Unity项目,讲解如何使用MRTK,编辑器模拟手势交互,打包VS工程并编译部署应用到HoloLens上等。

C/C++学习指南全套教程

C/C++学习的全套教程,从基本语法,基本原理,到界面开发、网络开发、Linux开发、安全算法,应用尽用。由毕业于清华大学的业内人士执课,为C/C++编程爱好者的教程。

pokemmo的资源

pokemmo必须的4个rom 分别为绿宝石 火红 心金 黑白 还有汉化补丁 资源不错哦 记得下载

test_head.py

本文件主要是针对使用dlib的imglab标注工具标记的目标检测框和关键点检测而生成的xml文件, 转换为coco数据集格式.

Java面试史上最全的JAVA专业术语面试100问 (前1-50)

前言: 说在前面, 面试题是根据一些朋友去面试提供的,再就是从网上整理了一些。 先更新50道,下一波吧后面的也更出来。 求赞求关注!! 废话也不多说,现在就来看看有哪些面试题 1、面向对象的特点有哪些? 抽象、继承、封装、多态。 2、接口和抽象类有什么联系和区别? 3、重载和重写有什么区别? 4、java有哪些基本数据类型? 5、数组有没有length()方法?String有没有length()方法? 数组没有length()方法,它有length属性。 String有length()方法。 集合求长度用

2019 AI开发者大会

2019 AI开发者大会(AI ProCon 2019)是由中国IT社区CSDN主办的AI技术与产业年度盛会。多年经验淬炼,如今蓄势待发:2019年9月6-7日,大会将有近百位中美顶尖AI专家、知名企业代表以及千余名AI开发者齐聚北京,进行技术解读和产业论证。我们不空谈口号,只谈技术,诚挚邀请AI业内人士一起共铸人工智能新篇章!

linux“开发工具三剑客”速成攻略

工欲善其事,必先利其器。Vim+Git+Makefile是Linux环境下嵌入式开发常用的工具。本专题主要面向初次接触Linux的新手,熟练掌握工作中常用的工具,在以后的学习和工作中提高效率。

DirectX修复工具V4.0增强版

DirectX修复工具(DirectX Repair)是一款系统级工具软件,简便易用。本程序为绿色版,无需安装,可直接运行。 本程序的主要功能是检测当前系统的DirectX状态,如果发现异常则进行修复

20行代码教你用python给证件照换底色

20行代码教你用python给证件照换底色

2019 Python开发者日-培训

本次活动将秉承“只讲技术,拒绝空谈”的理念,邀请十余位身处一线的Python技术专家,重点围绕Web开发、自动化运维、数据分析、人工智能等技术模块,分享真实生产环境中使用Python应对IT挑战的真知灼见。此外,针对不同层次的开发者,大会还安排了深度培训实操环节,为开发者们带来更多深度实战的机会。

我以为我对Mysql事务很熟,直到我遇到了阿里面试官

太惨了,面试又被吊打

机器学习实战系列套餐(必备基础+经典算法+案例实战)

机器学习实战系列套餐以实战为出发点,帮助同学们快速掌握机器学习领域必备经典算法原理并结合Python工具包进行实战应用。建议学习顺序:1.Python必备工具包:掌握实战工具 2.机器学习算法与实战应用:数学原理与应用方法都是必备技能 3.数据挖掘实战:通过真实数据集进行项目实战。按照下列课程顺序学习即可! 课程风格通俗易懂,用最接地气的方式带领大家轻松进军机器学习!提供所有课程代码,PPT与实战数据,有任何问题欢迎随时与我讨论。

相关热词 c#对文件改写权限 c#中tostring c#支付宝回掉 c#转换成数字 c#判断除法是否有模 c# 横向chart c#控件选择多个 c#报表如何锁定表头 c#分级显示数据 c# 不区分大小写替换
立即提问
相关内容推荐