• pytorch入门1

    参考来自PyTorch从入门到放弃（目录） - 二十三岁的有德 - 博客园 (cnblogs.com)

    torch.cat(inputs, dimension=0) → Tensor

    链接（dim=0是列链接，1是航链接）

    torch.chunk(tensor, chunks, dim=0)

    切割，cat的反向操作

    torch.gather(input, dim, index, out=None) → Tensor

    沿着不同维度取出tensor的值：

    ’

     torch.index_select(input, dim, index, out=None) → Tensor

    切片，针对不同维度

     torch.nonzero(input, out=None) → LongTensor

    返回不是0的下标

    利用torch解决线性回归问题：

    1. import numpy as np
    2. import torch
    3. import torch.nn as nn
    4. x=np.arange(1,12,dtype=np.float32).reshape(-1,1)
    5. y=2*x+3
    6. class LinearRegressionModel(nn.Module):
    7.     def __init__(self,input_dim,output_dim):
    8.           super().__init__()
    9.           self.linear=nn.Linear(input_dim,output_dim)
    10.     def forward(self,inp):
    11.         out=self.linear(inp)
    12.         return out
    13. regression_model=LinearRegressionModel(1,1)
    14. device=torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    15. regression_model.to(device)
    16. epochs=20
    17. learning_rate=0.01
    18. optimizer=torch.optim.SGD(regression_model.parameters(),learning_rate)
    19. criterion=nn.MSELoss()
    20. for epoch in range(epochs):
    21.     inputs=torch.from_numpy(x).to(device)
    22.     labels=torch.from_numpy(y).to(device)
    23.     optimizer.zero_grad()
    24.     outputs=regression_model(inputs)
    25.     loss=criterion(outputs,labels)
    26.     loss.backward()
    27.     optimizer.step()
    28.  
    29.     if epoch%10==0:
    30.         print("epoch:",epoch,"loss:",loss.item())
    31.  
    32. predict=regression_model(torch.from_numpy(x).requires_grad()).data.numpy()
    33. torch.save(regression_model.state_dict(),"model.pk1")
    34. result=regression_model.load_state_dict(torch.load("model.pk1"))

    用nn手写网络lenet网络

    1. import torch as t
    2. import torch.nn as nn
    3. import torch.nn.functional as F
    4. from  torch.autograd import Variable as V
    5. from matplotlib import pyplot as plt
    6. from IPython import display
    7.  
    8. class Net(nn.Module):
    9.     def __init__(self):
    10.         super(Net,self).__init__()
    11.         self.conv1=nn.Conv2d(1,6,5)
    12.         self.conv2=nn.Conv2d(6,16,5)
    13.  
    14.         self.fc1=nn.Linear(16*5*5,120)
    15.         self.fc2=nn.Linear(120,84)
    16.         self.fc3=nn.Linear(84,10)
    17.  
    18.     def forward(self,x):
    19.         x=self.conv1(x)
    20.         x=F.relu(x)
    21.         x=F.max_pool2d(x,(2,2))
    22.         x=self.conv2(x)
    23.         x=F.relu(x)
    24.         x=F.max_pool2d(x,2)
    25.  
    26.         x=x.view(x.size()[0],-1)
    27.         x=F.relu(self.fc1(x))
    28.         x=F.relu(self.fc2(x))
    29.         x=self.fc3(x)
    30.  
    31.         return x
    32. net=Net()
    33. print(net)
    34.

     

    练习：

    1. input=V(t.randn(1,1,32,32))
    2. out=net(input)
    3. output=net(input)
    4. target=V(t.arange(0,10)).view(1,10).float()
    5. criterion=nn.MSELoss()
    6. loss=criterion(output,target)
    7. optimizer=optim.SGD(net.parameters(),lr=0.01)
    8. optimizer.zero_grad()
    9. output=net(input)
    10. loss=criterion(output,target)
    11. loss.backward()
    12. optimizer.step()

    nn.Module

    全连接层

    1. import torch as t
    2. import torch.nn as nn
    3. import torch.nn.functional as F
    4. from  torch.autograd import Variable as V
    5. from matplotlib import pyplot as plt
    6. from IPython import display
    7. import torch.optim as optim
    8.  
    9. class Linear(nn.Module):
    10.     def __init__(self,in_features,out_features):
    11.         super(Linear,self).__init__()
    12.         self.w=nn.Parameter(t.randn(in_features,out_features))
    13.         self.b=nn.Parameter(t.randn(out_features))
    14.     def forward(self,x):
    15.         x=x.mm(self.w)
    16.         return x+self.b.expand_as(x)
    17. layer=Linear(4,3)
    18. input=V(t.randn(2,4))
    19. output=layer(input)
    20. print(output)

    构建多层全连接网络：

    1. import torch as t
    2. import torch.nn as nn
    3. import torch.nn.functional as F
    4. from  torch.autograd import Variable as V
    5. from matplotlib import pyplot as plt
    6. from IPython import display
    7. import torch.optim as optim
    8. class Linear(nn.Module):
    9.     def __init__(self, in_features, out_features):  # 输入的数据维度，输出的数据维度
    10.         super(Linear,
    11.               self).__init__()  # 等价于 nn.Module.__init__(self)，继承父类的init构造函数
    12.         self.w = nn.Parameter(t.randn(in_features, out_features))
    13.         self.b = nn.Parameter(t.randn(out_features))
    14.  
    15.     def forward(self, x):
    16.         x = x.mm(self.w)
    17.         return x + self.b.expand_as(x)
    18.  
    19. class Perceptron(nn.Module):
    20.     def __init__(self,in_features,hidden_features,out_features):
    21.         super(Perceptron,self).__init__()
    22.         self.layer1=Linear(in_features,hidden_features)
    23.         self.layer2=Linear(hidden_features,out_features)
    24.     def forward(self,x):
    25.         x=self.layer1(x)
    26.         x=t.sigimoid(x)
    27.         x=self.layer2(x)
    28.         return x
    29. perceptron=Perceptron(3,4,1)
    30. for name,param in perceptron.named_parameters():
    31.     print(name,param.size())

     常用的神经网络层：

    1.显示图片（温客行yyds）

    1. import torch as t
    2. import torch.nn as nn
    3. import torch.nn.functional as F
    4. from  torch.autograd import Variable as V
    5. from matplotlib import pyplot as plt
    6. from IPython import display
    7. import torch.optim as optim
    8. from PIL import Image
    9. from torchvision.transforms import ToTensor,ToPILImage
    10. to_tensor=ToTensor()
    11. to_pil=ToPILImage()
    12. nick=Image.open('G:/3.bmp')
    13. nick.show()

    加锐化卷积

    1. import torch as t
    2. import torch.nn as nn
    3. import torch.nn.functional as F
    4. from  torch.autograd import Variable as V
    5. from matplotlib import pyplot as plt
    6. from IPython import display
    7. import torch.optim as optim
    8. from PIL import Image
    9. from torchvision.transforms import ToTensor,ToPILImage
    10. to_tensor=ToTensor()
    11. to_pil=ToPILImage()
    12. yeye=Image.open('G:/3.bmp')
    13. inp=to_tensor(yeye).unsqueeze(0)
    14. kernel=t.ones(3,3,3)/-9
    15. kernel[:,1,1]=1
    16.  
    17. conv=nn.Conv2d(
    18.     in_channels=3 ,  #彩色图
    19.     out_channels=1,
    20.     kernel_size=3,
    21.     stride=1,
    22.     bias=False
    23.  
    24.  
    25. )
    26. conv.weight.data=kernel.view(1,3,3,3)
    27. #输出通道数和卷积核数一样，1代表卷积核数，3代表输入数，后两个为卷积核尺寸
    28. out=conv(V(inp))
    29. y=to_pil(out.data.squeeze(0))
    30. y.show()

     加普通卷积

    1. import torch as t
    2. import torch.nn as nn
    3. import torch.nn.functional as F
    4. from  torch.autograd import Variable as V
    5. from matplotlib import pyplot as plt
    6. from IPython import display
    7. import torch.optim as optim
    8. from PIL import Image
    9. from torchvision.transforms import ToTensor,ToPILImage
    10. to_tensor=ToTensor()
    11. to_pil=ToPILImage()
    12. yeye=Image.open('G:/3.bmp')
    13. inp=to_tensor(yeye).unsqueeze(0)
    14. conv=nn.Conv2d(
    15.     in_channels=3,
    16.     out_channels=1,
    17.     kernel_size=3,
    18.     stride=1,
    19.     bias=False
    20.  
    21.  
    22. )
    23. out=conv(V(inp))
    24. y=to_pil(out.data.squeeze(0))
    25. y.show()

     通过Sequential 构建前馈传播网络

    三种：
     

    1. net1=nn.Sequential()
    2. net1.add_module('conv',nn.Conv2d(3,3,3))
    3. net1.add_module('batchnorm',nn.BatchNorm2d(3))
    4. net1.add_module('activation_layer',nn.ReLU())
    5. net2=nn.Sequential(nn.Conv2d(3,3,3),nn.BatchNorm2d(3),nn.ReLU())
    6.  
    7. from collections import OrderedDict
    8. net3=nn.Sequential(
    9.     OrderedDict([('conv1',nn.Conv2d(3,3,3)),
    10.                  ('bn1',nn.BatchNorm2d(3)),
    11.                  ('relu',nn.ReLU())])
    12. )

     通过 ModuleList 构建前馈传播网络

    1. modellist=nn.ModuleList([nn.Linear(3,4),nn.ReLU(),nn.Linear(4,2)])
    2. inp=V(t.rand(1,3))
    3. for model in modellist:
    4.     inp=model(inp)
    5. class MyModule(nn.Module):
    6.     def __init__(self):
    7.         super(MyModule,self).__init__()
    8.         self.list=[nn.Linear(3,4),nn.ReLU()]
    9.         self.module_list=nn.ModuleList([nn.Conv2d(3,3,3),nn.ReLU()])
    10.     def forward(self):
    11.         pass
    12. model=MyModule()
    13. print(model)

    循环神经网络层

    1. t.manual_seed(1000)
    2. inp=V(t.randn(2,3,4))#长度为2，batchsize为3，每个元素占4维
    3. lstm=nn.LSTM(4,3,1)#4维，3个隐藏元，1层
    4.  
    5.  
    6. h0=V(t.randn(1,3,3))
    7. c0=V(t.randn(1,3,3))
    8. out,hn=lstm(inp,(h0,c0))
    9. print(out)

     词向量在自然语言中应用十分广泛，torch 同样也提供了 Embedding 层

    1. embedding=nn.Embedding(4,5)
    2. embedding.weight.data=t.arange(0,20).view(4,5)
    3. with t.no_grad():
    4.     inp=V(t.arange(3,0,-1)).long()
    5.     output=embedding(inp)
    6.     print(output)

    损失函数

    1. score=V(t.randn(3,2))
    2. label=V(t.Tensor([1,0,1])).long()
    3. criterion=nn.CrossEntropyLoss()
    4. loss=criterion(score,label)
    5. print(loss)

    优化器：

    1. class Net(nn.Module):
    2.     def __init__(self):
    3.         super(Net,self).__init__()
    4.         self.features=nn.Sequential(nn.Conv2d(3,6,2),
    5.                                     nn.ReLU(),
    6.                                     nn.MaxPool2d(2,2),
    7.                                     nn.Conv2d(6,16,5),
    8.                                     nn.ReLU(),
    9.                                     nn.MaxPool2d(2,2))
    10.         self.classifier=nn.Sequential(nn.Linear(16*5*5,120),
    11.                                       nn.ReLU(),
    12.                                       nn.Linear(120,84),
    13.                                       nn.ReLU(),
    14.                                       nn.Linear(84,10))
    15.     def forward(self,x):
    16.         x=self.features(x)
    17.         x=x.view(-1,16*5*5)
    18.         x=self.classifier(x)
    19.         return x
    20. net=Net()
    21. optimizer=optim.SGD(params=net.parameters(),lr=0.01)
    22. optimizer.zero_grad()
    23. inp=V(t.randn(1,3,32,32))
    24. output=net(inp)
    25. output.backward(output)
    26. optimizer.step()
    1. #针对不同的网络设置不同学习率
    2. ptimizer=optim.SGD(
    3.     [
    4.         {
    5.             'params':net.features.parameters()
    6.             
    7.         },
    8.         {
    9.             'params':net.classifier.parameters(),
    10.             'lr':1e-2
    11.             
    12.         },
    13.     ],
    14.     lr=1e-5
    15. )

     nn.functional 和 nn.Module 的区别

    1. inp=V(t.randn(2,3))
    2. model=nn.Linear(3,4)
    3. output1=model(inp)
    4. output2=nn.functional.linear(inp,model.weight,model.bias)
    1. class MyLinear(nn.Module):
    2.     def __init__(self):
    3.         super(MyLinear,self).__init__()
    4.         self.weight=nn.Parameter(t.randn(3,4))
    5.         self.bias=nn.Parameter(t.zeros(3))
    6.  
    7.     def forward(self):
    8.         return F.linear(input,self.weight,self.bias)
    9.  
    10.

    搭建ResNet网络(torch实现）

    1. class ResidualBlock(nn.Module):
    2.     def __init__(self,inchannel,outchannel,stride=1,shortcut=None):
    3.         super(ResidualBlock,self).__init__()
    4.  
    5.         self.left=nn.Sequential(
    6.             nn.Conv2d(inchannel,outchannel,3,stride,1,bias=False),
    7.             nn.BatchNorm2d(outchannel),
    8.             nn.ReLU(inplace=True),
    9.             nn.Conv2d(outchannel,outchannel,3,1,1,bias=False),
    10.             nn.BatchNorm(outchannel)
    11.         )
    12.         self.right=shortcut
    13.     def forward(self,x):
    14.         out=self.left(x)
    15.         residual=x if self.right is None else self.right(x)
    16.         out=out+residual
    17.         out=F.relu(out)
    18.         return out
    19. class ResNet(nn.Module):
    20.     def __init__(self,num_classes=1000):
    21.         super(ResNet,self).__init__()
    22.         self.pre=nn.Sequential(
    23.             nn.conv2d(3,64,7,2,3,bias=False),
    24.             nn.BatchNorm2d(64),
    25.             nn.ReLU(inplace=True),
    26.             nn.MaxPool2d(3,2,1),
    27.         )
    28.         self.layer1=self._make_layer(64,128,3)
    29.         self.layer2=self._make_layer(128,256,4,stride=2)
    30.         self.layer3=self._make_layer(256,512,6,stride=2)
    31.         self.layer4=self._make_layer(512,512,3,stride=2)
    32.  
    33.  
    34.         self.fc=nn.Linear(512,num_classes)
    35.     def _make_layer(self,inchannel,outchannel,block_num,stride=1):
    36.         shortcut=nn.Sequential(
    37.             nn.Conv2d(inchannel,outchannel,1,stride,bias=False),
    38.             nn.BatchNorm2d(outchannel)
    39.         )
    40.         layers=[]
    41.         layers.append(ResidualBlock(inchannel,outchannel,stride,shortcut))
    42.         for i in range(1,block_num):
    43.  
    44.             layers.append(ResidualBlock(outchannel,outchannel))
    45.         return nn.Sequential(*layers)
    46.     def forward(self,x):
    47.         x=self.pre(x)
    48.         x=self.layer1(x)
    49.         x=self.layer2(x)
    50.         x=self.layer3(x)
    51.         x=self.layer4(x)
    52.  
    53.         x=F.avg_pool2d(x,7)
    54.         x=x.view(x.size(0),-1)
    55. res_net=ResNet()
    56. inp=t.autograd.Variable(t.randn(1,3,224,224))
    57. output=res_net(inp)

    torchvision 中的 resnet34网络调用

    1. from torchvision import models
    2. res_net=models.resnet34()
    3. inp=t.autograd.Variable(t.randn(1,3,224,224))
    4. output=res_net(inp)
    5. output.size()

    深度网络模型持久化

    tensor对象保存

    1. import torch as t
    2. a=t.Tensor(3,4)
    3. if t.cuda.is_available():
    4.     a=a.cuda(1)
    5.     t.save(a,'a.pth')
    6.  
    7.     b=t.load('a.pth')
    8.     c=t.load('a.pth',map_location=lambda storage,loc:storage)
    9.     d=t.load('a.pth',map_location={'cuda:1','cuda:0'})

    Module 对象的保存和加载

    1. import torch as t
    2. t.set_default_tensor_type('torch.FloatTensor')
    3. from torchvision.models import AlexNet
    4. model=AlexNet()
    5. model.state_dict().keys()
    6. t.save(model.state_dict(),'alexnet.pth')
    7. model.load_state_dict(t.load('alexnet.pth'))

    Optimizer 对象的保存和加载

    1. optimizer=t.optim.Adam(model.parameters(),lr=0.1)
    2. t.save(optimizer.state_dict(),'optimizer.pth')
    3. optimizer.load_state_dict(t.load('optimizer.pth'))

    深度学习程序架构设计

    模型定义
    数据处理和加载
    训练模型（Train & Validate）
    训练过程可视化
    测试（Test/Inference）

    1. checkpoints/
    2. data/
    3.     __init__.py
    4.     dataset.py
    5.     get_data.sh
    6.  
    7. models/
    8.     __init__.py
    9.     AlexNet.py
    10.     BasicModule.py
    11.     ResNet34.py
    12.     
    13. utils/
    14.     __init__.py
    15.     visualize.py
    16.     
    17. config.py
    18. main.py
    19. requirement.txt
    20. README.md

    比较复杂的可视化工具tensorboard和visdom

    使用的时候可以使用colab或者科学上网方法，不然链接会断

     数据集可以百度云盘获得

    编程实战_猫和狗二分类_深度学习项目架构

    1.数据加载

    1. class DogCat(data.Dataset):
    2.     def __init__(self,root,transforms=None,train=True,test=False):
    3.         self.test=test
    4.         imgs=[os.path.join(root,img)
    5.               for img in os.listdir(root)]
    6.         if self.test:
    7.             imgs=sorted(
    8.                 imgs,
    9.                 key=lambda x:int(x.split('.')[-2].split('/')[-1])
    10.  
    11.             )
    12.         else:
    13.             imgs=sorted(imgs,
    14.                         key=lambda x:int(x.split('.')[-2]))
    15.         imgs_num=len(imgs)
    16.         if self.test:
    17.             self.imgs=imgs
    18.         elif train:
    19.             self.imgs=imgs[:int(0.7*imgs_num)]
    20.         else:
    21.             self.imgs=imgs[int(0.7*imgs_num):]
    22.         if transforms is None:
    23.             normalize=T.Normalize(mean=[0.485,0.456,0.406],
    24.                                   std=[0.229,0.224,0.225])
    25.             if self.test or not train:#测试集和验证集
    26.                 self.transforms=T.Compose([
    27.                     T.Scale(224),
    28.                     T.CenterCrop(224),
    29.                     T.ToTensor(),
    30.                     normalize
    31.                 ])
    32.             else:#训练集
    33.                 self.transforms=T.Compose([
    34.                     T.Scale(256),
    35.                     T.RandomResizedCrop(224),
    36.                     T.RandomHorizontalFlip(),
    37.                     T.ToTensor(),
    38.                     normalize
    39.                 ])
    40.         def __getitm__(self,index):
    41.             #返回一张图片
    42.             img_path=self.imgs[index]
    43.             if self.text:
    44.                 label=self.imgs[index].split('.')[-2]
    45.                 label=int(label.split('/')[-1])
    46.             else :
    47.                 label=1 if 'dog' in img_path.split('/')[-1] else 0
    48.             data=Image.open(img_path)
    49.             data=self.transforms(data)
    50.             return data,label
    51.         def __len__(self):
    52.             return len(self.imgs)

    2.定义模型

    1. import time
    2. import torch as t
    3. class BasicModule(t.nn.Module):#封装save和load
    4.     def __init__(self):
    5.         super(BasicModule,self).__init__()
    6.         self.model_name=str(type(self))
    7.     def load(self,path):
    8.         self.load_state_dict(t.load(path))
    9.     def save(self,name=None):
    10.         #模型名字+时间
    11.         if name is None:
    12.             prefix='checkpoints/'+self.model_name+'.'
    13.             name=time.strftime(prefix+'%m%d_%H:%M:%S.pth')
    14.         t.save(self.state_dict(),name)
    15.         return name

    封装save和load

    配置文件

    1. class DefaultConfig(object):
    2.     env='default'
    3.     model='AlexNet'
    4.     train_data_root=' ./data/train/'
    5.     test_data_root='./data/test/'
    6.     load_model_path='checkpoints/model.pth'
    7.     batch_size=128
    8.     use_gpu=False
    9.     num_workers=4
    10.     print_freq=20
    11.     result_file='result.csv'
    12.     max_epoch=10
    13.     lr=0.1
    14.     lr_decay=0.95
    15.     weight_decay=1e-4

    main.py的代码组织结构

    在我们这个项目的 main.py 中主要包括以下四个函数，其中三个需要命令行执行，main.py 的代码组织结构如下所示：

    train:

    1. def train(**kwargs):
    2.  
    3.     opt.parse(kwargs)
    4.     vis=Visualizer(opt.env)
    5.  
    6.     #模型
    7.     model=opt.model()
    8.     if opt.load_model_path:
    9.         model.load(opt.laod_model_path)
    10.     if opt,use_gpu:model.cuda()
    11.     #数据
    12.     train_data=DogCat(opt.train_data_root,train=True)
    13.     val_data=DogCat(opt.train_data_root,train=False)
    14.     train_dataloader=Dataloader(train_data,
    15.                                 opt.batch_size,
    16.                                 shuffle=True,
    17.                                 num_workers=opt.num_workers)
    18.     val_dataloader = Dataloader(train_data,
    19.                                  opt.batch_size,
    20.                                  shuffle=False,
    21.                                  num_workers=opt.num_workers)
    22.  
    23.     #函数和优化器
    24.     criterion=torch.nn.CrossEntropyLoss()
    25.     lr=opt.lr
    26.     optimizer=t.optim.Adam(model.parameters(),
    27.                            lr=lr,
    28.                            weight_decay=opt.weight.decay)
    29.     #指标
    30.     loss_meter = meter.AverageValueMeter()  # 平均损失
    31.     confusion_matrix = meter.ConfusionMeter(2)  # 混淆矩阵
    32.     previous_loss = 1e100
    33.  
    34.     #训练
    35.     for epoch in range(opt.max_epoch):
    36.         loss_meter.reset()
    37.         confusion_matrix.reset()
    38.  
    39.         for ii,(data,label) in enumerate(train_dataloader):
    40.             inp=Variable(data)
    41.             target=Variable(label)
    42.  
    43.             if opt.use_gpu:
    44.                 inp=inp.cuda()
    45.                 target=target.cuda()
    46.             optimizer.zero_grad()
    47.             score=model(inp)
    48.             loss=criterion(score,target)
    49.             loss.backward()
    50.             optimizer.step()
    51.  
    52.             loss_meter.add(loss.data[0])
    53.             confusion_matrix.add(score.data, target.data)
    54.  
    55.             if ii % opt.print_freq == opt.print_freq - 1:
    56.                 vis.plot('loss', loss_meter.value()[0])
    57.  
    58.                 # 如果需要的话，进入 debug 模式
    59.                 if os.path.exists(opt.debug_file):
    60.                     ipdb.set_trace()
    61.  
    62.         model.save()
    63.         if loss_meter.value()[0] > previous_loss:
    64.             lr = lr * opt.lr_decay
    65.             for param_group in optimizer.param_groups:
    66.                 param_group['lr'] = lr
    67.  
    68.         previous_loss = loss_meter.value()[0]

    val

    1. def val(model,dataloader):
    2.     model.eval()
    3.     confusion_matrix = meter.ConfusionMeter(2)
    4.     for ii, data in enumerate(dataloader):
    5.         inp, label = data
    6.         val_inp = Variable(inp, volatile=True)
    7.         val_label = Variable(label.long(), volatile=True)
    8.         if opt.use_gpu:
    9.             val_inp = val_inp.cuda()
    10.             val_label = val_label.cuda()
    11.         score = model(val_inp)
    12.         confusion_matrix.add(score.data.squeeze(), label.long())
    13.  
    14.     # 把模型恢复为训练模式
    15.     model.train()
    16.     cm_value = confusion_matrix.value()
    17.     accuracy = 100. * (cm_value[0][0] + cm_value[1][1]) / (cm_value.sum())
    18.  
    19.     return confusion_matrix, accuracy

    测试

    1. def test(**kwargs):
    2.     opt.parse(kwargs)
    3.     model=getattr(models,opt.model)().eval()
    4.     if opt.load_model_path:
    5.         model.load(opt.load_model_path)
    6.     if opt.use_gpu: model.cuda()
    7.     train_data=DogCat(opt.test_data_root,test=True)
    8.     test_dataloader=DataLoader(train_data,
    9.                                batch_sampler=opt.batch_size,
    10.                                shuffle=False,
    11.                                num_workers=opt.num_workers
    12.     )
    13.     result=[]
    14.     for ii, (data, path) in enumerate(test_dataloader):
    15.         inp = Variable(data, volatile=True)
    16.         if opt.use_gpu: inp = inp.cuda()
    17.         score = model(inp)
    18.  
    19.         probability = probability = functional.softmax(score, dim=1)[:, 0].detach().tolist()
    20.         batch_results = [(path_, probability_) for path_, probability_ in zip(path, probability)]
    21.         results += batch_results
    22.  
    23.     write_csv(results, opt.result_file)
    24.     return results

  • 相关阅读:
    【uniapp】跨端开发问题记录
    一些框架使用总结
    Unity中Shader光照模型Phong的实现
    前后端交互之网络服务的基本概念
    华为OD机考算法题：字符串解密
    微服务3 Eureka注册中心
    iOS - Runloop在实际开发中的应用
    ORB-SLAM3复现过程中遇到的问题及解决办法
    windows下-mysql环境配置，以及使用navicat可视化数据库，便捷撰写sql语句。
    Linux操作系统的基础指令 III
  • 原文地址：https://blog.csdn.net/kling_bling/article/details/125942303