咬树羊

Pytorch学习

B站小土堆教程小土堆

查看pytorch是否可用 pycharm的一个技巧，在函数的括号里按ctrl+P可以看要写哪些参数。

import torch
print( torch.cuda.is_available() )

如何在pytorch环境中安装jupyter notebook和使用教程

学习和使用中的两个常用的辅助查询函数
dir():打开package库看看里面有什么，例如dir(torch)，看看torch里有什么
help():说明书，例如help(torch.cuda.is_available)

pytorch加载数据

Dataset （一般来说Dataset都自己写，然后继承自Dataset）

提供一种方式去获取数据及其label

如何获取每一个数据及其label

告诉我们总共有多少的数据

from torch.utils.data import Dataset

读取一张图片

路径的话用相对路径比较好，因为这样假如换电脑换系统跑代码，绝对路径会发生变化，但只要项目文件不变，相对路径就不会变。另外要注意使用相对路径要保证在同一目录下，如果不是同一目录就要加../，. / 代表目前所在的目录； . . / 代表上一层目录； / 代表根目录。win系统下路径斜杠最好换成/，这样就不会有转义符了。

#读取一张图片的代码
from PIL import Image

img_path = "D:\\Python\Projects_all\\小土堆课程\\hymenoptera_data\\train\\ants\\0013035.jpg" 
                          #win系统记得加两个斜杠\\,表示转义
img = Image.open(img_path) #根据路径读取图片给img变量，可以用python控制台，里面可以显示很多变量信息
print(img.size) #查看图片尺寸，好像并不能看到通道数
img.show()      #打开图片

读取一个文件夹里的所有图片的文件名，并放到一个列表

from PIL import Image
import os

dir_path = "D:\\Python\\Projects_all\\小土堆课程\\hymenoptera_data\\train\\ants" 
            #win系统要加双斜杠，转义符号
img_path_list = os.listdir(dir_path)  #把文件夹里的所有东西的名字变成一个列表
print(img_path_list)  
img0_path = dir_path + "\\" + img_path_list[0]  #第一张图片的路径，手动写路径
img0_path = os.path.join(dir_path,img_path_list[0]) 
            #这个函数可以根据不同系统自动合并路径，两种方法，第二种更好
img0 = Image.open(img0_path)  #读取第一张图片
img0.show()               #打开 查看第一张图片

img0_path = os.path.join(dir_path,img_path_list[0]) #这个函数可以根据不同系统自动合并路径，不同系统斜杠不同

创建数据集（一般来说Dataset都自己写，然后继承自Dataset）

from torch.utils.data import Dataset
from PIL import Image
import os

class MyData(Dataset):  #创建一个MyData类，继承自Dataset类，这样就继承了Dataset的一部分资源，自己也可以添加一些资源
    def __init__(self,root_dir,label_dir):
        self.root_dir = root_dir
        self.label_dir = label_dir
        self.dir_path = os.path.join(self.root_dir, self.label_dir)
        self.img_path = os.listdir(self.dir_path)  #把文件里的所有东西的名字做成列表

    def __getitem__(self, idx):
        img_name = self.img_path[idx]  #找到对应索引号的图片名字
        img_idx_path = os.path.join(self.root_dir, self.label_dir, img_name) #写出完整路径
        img = Image.open(img_idx_path)  #读取图片
        label = self.label_dir  #图片标签
        return img, label

    def __len__(self):
        return len(self.img_path)

root_dir = "D:\\Python\\Projects_all\\小土堆课程\hymenoptera_data\\train"
ants_label_dir = "ants"
bees_label_dir = "bees"
ants_dataset = MyData(root_dir, ants_label_dir)
bees_dataset = MyData(root_dir, bees_label_dir)

print(len(ants_dataset)) #输出124
print(len(bees_dataset)) #输出121

img0, label = ants_dataset[0]
img0.show() #显示蚂蚁数据集的第一张图片

train_dataset = ants_dataset + bees_dataset  #两个数据集合并了，
           # 试了下必须用MyData(Dataset)继承Dataset才行，普通类实例化出来的是不行的
print(len(train_dataset)) #输出245

from torch.utils.data import Dataset可以合并数据集

Dataloader （拆分成多个batch）（输出的tensor都是NCHW维度的）

为后面的网络提供不同的数据形式。DataLoader是一个可迭代的数据装载器，组合了数据集和采样器，并在给定数据集上提供可迭代对象。可以完成对数据集中多个对象的集成。官方文档

CLASS DataLoader
torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=None, sampler=None,
batch_sampler=None, num_workers=0, collate_fn=None, pin_memory=False,
drop_last=False, timeout=0, worker_init_fn=None, multiprocessing_context=None,
generator=None, *, prefetch_factor=2, persistent_workers=False, pin_memory_device='')

先导概念介绍：转自
Epoch：所有训练样本都已输入到模型中，称为一个epoch
Iteration：一批样本（batch_size）输入到模型中，称为一个Iteration
Batchsize：一批样本的大小，决定一个epoch有多少个Iteration
常用的主要有以下五个参数：
dataset（数据集）：需要提取数据的数据集， Dataset对象
batch_size（批大小）：每一次装载样本的个数，int型
shuffle（洗牌）：进行新一轮epoch时是否要重新洗牌，Boolean型
num_workers：是否多进程读取机制
drop_last：当样本数不能被batchsize整除时，是否舍弃最后一批数据

官方文档

DataLoader的使用

使用CIFAR10的测试数据集来完成DataLoader的使用。

导入并实例化DataLoader

创建一个dataloader,设置批大小为4，每一个epoch重新洗牌，不进行多进程读取机制，不舍弃不能被整除的批次。

#导入数据集的包
import torchvision.datasets
#导入dataloader的包
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
#创建测试数据集
test_dataset = torchvision.datasets.CIFAR10(root="./CIRFA10",train=False,transform=torchvision.transforms.ToTensor())
#创建一个dataloader,设置批大小为4，每一个epoch重新洗牌，不进行多进程读取机制，不舍弃不能被整除的批次
test_dataloader = DataLoader(dataset=test_dataset,batch_size=4,shuffle=True,num_workers=0,drop_last=False)

数据集中数据的读取

由于数据集中的数据已经被我们转换成了tensor型，我们用dataset[0]输出第一张图片，使用shape属性输出tensor类型的大小，target代表图片的标签。

img,target = test_dataset[0]
print(img.shape,target)
输出：torch.Size([3，32，32]) 3  图片有RGB3个通道，大小为32*32，标签target为3。

DataLoader中数据的读取

在dataset中，每一个数据样本元组由一张图片对象img和一个标签target组成；

而dataloader中会分别对一个批次中的图片和标签进行打包，因此dataloader中，每一个对象元组由batchsize张图片对象imgs和batchsize个标签targets组成。（注意取数据的时候并不是按顺序取的，采样器sampler默认是随机采样，也就是说抓取四张图片的时候是随机取的）

对一个batchsize批次中的所有图片对象进行打包，形成一个对象，我们叫它imgs

对一个batchsize批次中所有的标签进行打包，形成一个对象，我们叫它targets

我们需要通过for循环来取出loader中的对象，loader中的对象个数=数据集中对象个数/batch_size，故应为10000/4=2500个对象。

#导入数据集的包
import torchvision.datasets
#导入dataloader的包
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
#创建测试数据集
test_dataset = torchvision.datasets.CIFAR10(root="./CIRFA10",train=False,transform=torchvision.transforms.ToTensor())
#创建一个dataloader,设置批大小为4，每一个epoch重新洗牌，不进行多进程读取机制，不舍弃不能被整除的批次
test_dataloader = DataLoader(dataset=test_dataset,batch_size=4,shuffle=True,num_workers=0,drop_last=False)
 
#测试数据集中第一张图片对象
img,target = test_dataset[0]
print(img.shape,target)
 
#打印数据集中图片数量
print(len(test_dataset))
 
#loader中对象
for data in test_dataloader:
    imgs,targets = data
    print(imgs.shape)
    print(targets)
 
#dataloader中对象个数
print(len(test_dataloader))

loader中的对象格式：

imgs的维度变成了4*3*32*32，即四张图片，每张图片3个通道，每张图片大小为32*32。

targets里有4个target，分别是四张图片的标签target，组合到一起了。

使用tensorboard可视化效果

修改数据集的batchsize为64，writer中调用的方法为add_images()，因为需要读取的图片有多张。

#导入数据集的包
import torchvision.datasets
#导入dataloader的包
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
#创建测试数据集
test_dataset = torchvision.datasets.CIFAR10(root="./CIRFA10",train=False,transform=torchvision.transforms.ToTensor())
#创建一个dataloader,设置批大小为64，每一个epoch重新洗牌，不进行多进程读取机制，不舍弃不能被整除的批次
test_dataloader = DataLoader(dataset=test_dataset,batch_size=64,shuffle=True,num_workers=0,drop_last=False)
 
writer = SummaryWriter("log")
 
#loader中对象
step = 0
for data in test_dataloader:
    imgs,targets = data
    writer.add_images("loader",imgs,step)
    step+=1
 
writer.close()

结果如下所示，可以看到一个step中有64张图片。

改变shuffle

每一轮epoch之后就是分配完了一次数据，而shuffle决定了是否在新一轮epoch开始时打乱所有图片的属性进行分配。

在代码中epoch就是最外层的循环，假设我们的epoch=2，即需要分配两次数据：

shuffle=TRUE代表第一轮循环结束后会打乱数据集中所有图片的顺序重新进行分配。

shuffle=FALSE代表第一轮循环结束后不打乱数据集中所有图片的顺序，还是按原顺序进行分配。

#导入数据集的包
import torchvision.datasets
#导入dataloader的包
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
 
#创建测试数据集
test_dataset = torchvision.datasets.CIFAR10(root="./CIRFA10",train=False,transform=torchvision.transforms.ToTensor())
#创建一个dataloader,设置批大小为64，每一个epoch重新洗牌，不进行多进程读取机制，不舍弃不能被整除的批次
test_dataloader = DataLoader(dataset=test_dataset,batch_size=64,shuffle=True,num_workers=0,drop_last=True)
 
writer = SummaryWriter("log")
 
#loader中对象
 
for epoch in range(2):
    step = 0
    for data in test_dataloader:
        imgs, targets = data
        writer.add_images("Epoch:{}".format(epoch), imgs, step)
        step += 1
 
writer.close()

可以看到shuffle=True时epoch=0和epoch=1的每一个step中的图片不同了，说明每一轮大循环开始前都在数据集中重新打乱了顺序。

import os os库的用法

img_path_list = os.listdir(dir_path) #把文件夹里的所有东西的名字变成一个列表 os.listdir用法，如何找到文件里的jpg

os.listdir(path)返回文件列表的顺序是任意的，sort排序方法

img0_path = os.path.join(dir_path,img_path_list[0]) #这个函数可以根据不同系统自动合并路径

TensorBoard

conda install tensorboard 安装

from torch.utils.tensorboard import SummaryWriter

writer.add_scalar( ) 遇到报错或者不知道参数可以点进去看看函数注释

from torch.utils.tensorboard import SummaryWriter

writer = SummaryWriter("logs") # 把对应的事件文件存到logs目录里，如果没有会自动创建

# writer.add_image()
# y = 2x
for i in range(100):
    writer.add_scalar("y=2x", 2*i, i) #第一个参数是图表标题，第二个参数是y轴数值，第三个
                              #参数是步数，相对于x轴。具体参数可以ctrl+左键 点进去看看
writer.close()

代码写好之后先run一下，然后当前目录下就会多一个logs目录，里面存了tensorboard保存的事件文件。

接下来用终端terminal打开这个事件文件，

tensorboard --logdir=D:\Python\Projects_all\小土堆课程\代码\logs

logdir后面是事件文件所在的目录，绝对路径和相对路径都行但是要正确。然后打开http://localhost:6006/ 这个链接就行了。

tensorboard --logdir=D:\Python\Projects_all\小土堆课程\代码\logs --port=6007

用的人太多的话也可以修改端口的。

注意：对于标题一样的图，tensorboard会保存上一次运行的数据，也就是说图上会有上次的数据和这次的数据，全部乱套了。解决方法：一、更换标题，重新运行，刷新tensorboard图表界面，会生成新的图表；二、删除logs下面所有的事件文件，然后重新运行，并且重新进入终端输入命令。

writer.add_image( ) 遇到报错或者不知道参数可以点进去看看函数注释

可接受的图像格式：img_tensor (torch.Tensor, numpy.array, or string/blobname): Image data

from PIL import Image
img_path = "D:\Python\Projects_all\小土堆课程\hymenoptera_data\\train\\ants\\0013035.jpg"
img = Image.open(img_path)
print(type(img))

可见用PIL这个包来读取图片并不满足tensorboard的格式输入要求。

可以利用Opencv读取图片，获得numpy型图片数据。

这里小土堆直接用numpy对图片格式进行了转化。

from torch.utils.tensorboard import SummaryWriter
from PIL import Image
import numpy as np

writer = SummaryWriter("logs") # 把对应的事件文件存到logs目录里，如果没有会自动创建
img_path = "D:\Python\Projects_all\小土堆课程\hymenoptera_data\\train\\ants\\0013035.jpg"
img_PIL = Image.open(img_path)
img_array = np.array(img_PIL)
print(img_array.shape)
# print(np.transpose(2, 0, 1))  # [H, W, C] -> [C, H, W]

writer.add_image("test", img_array, global_step= 1, dataformats="HWC")  # 如果想换一张图片显示，要么就是换标题，
                                                            # 要么不换标题改一下global_step，会有一个滑动的效果
# y = 2x
for i in range(100):
    writer.add_scalar("y=x", 4*i, i) #第一个参数是图表标题，第二个参数是y轴数值，第三个
                              #参数是步数，相对于x轴。具体参数可以ctrl+左键 点进去看看
writer.close()

运行，然后在terminal中输入tensorboard --logdir=D:\Python\Projects_all\小土堆课程\代码\logs。打开链接就能看到图片了。

torchvision

torchvision 中的 transforms

from torchvision import transforms

transforms是一个处理图片的工具箱。

ToTensor

用PIL和cv2读取的图片都是HWC格式的(0~255)，ToTensor会自动转换成CHW格式(0~1)。

class ToTensor:
"""Convert a ``PIL Image`` or ``numpy.ndarray`` to tensor. """

用PIL的Image来读取图片读取出来是RGB格式，HWC格式, 0~255

from PIL import Image
from torchvision import transforms

img_path = "../hymenoptera_data/train/ants/0013035.jpg"
img_PIL = Image.open(img_path)
tensor_trans = transforms.ToTensor()
tensor_img = tensor_trans(img_PIL)
print(tensor_img.shape)
输出：torch.Size([3, 512, 768])

用opencv的CV2的imread来读取图片读取出来是BGR格式，HWC格式，0-255

opencv读出来的图片是numpy格式,opencv读取时路径中不可以有中文 opencv读取图片的方法

import cv2
from torchvision import transforms
img_path = "../hymenoptera_data/train/ants/0013035.jpg"
img_cv2 = cv2.imread(img_path)
tensor_trans = transforms.ToTensor()
tensor_img = tensor_trans(img_cv2)
print(tensor_img.shape)
输出：torch.Size([3, 512, 768])

用tensorboard来显示tensor格式的图片

from torch.utils.tensorboard import SummaryWriter
import cv2
from torchvision import transforms
img_path = "../hymenoptera_data/train/ants/0013035.jpg"
img_cv2 = cv2.imread(img_path)
tensor_trans = transforms.ToTensor()
tensor_img = tensor_trans(img_cv2)

writer = SummaryWriter("logs")
writer.add_image("tensor_image", tensor_img)
writer.close()

然后在python console输入命令打开tensorboard查看。

Normalize输入图片归一化

输入必须是tensor，图片tensor的数据范围是0-1。

公式是output[channel] = (input[channel] - mean[channel]) / std[channel]

trans_norm = transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]) #均值和方差，图片的三个通道都要归一化
img_norm_PIL = trans_norm(tensor_img_PIL_RGB) #输入必须是tensor类型，注意格式是RGB
img_norm_cv2 = trans_norm(tensor_img_cv2_RGB)

第一张图经过了归一化处理，第二张图是原图

Resize修改图片尺寸

输入必须是PIL读取的图片

如果输入的参数是一个序列，即长和宽两个整数，则图像会按该长和宽进行resize。

如果输入的参数是一个整数x，将图片短边缩放至x，长宽比保持不变。

新版的Resize的输入图形类型可以是PIL型或者tensor型

注意：输出图像可能根据其类型不同而不同:当下采样时，PIL图像的插值和张量略有不同，因为PIL应用了抗锯齿。这可能会导致显著的差异在网络的性能中。因此，最好是训练和服务一个具有相同输入的模型类型。转自

trans_resize = transforms.Resize((512, 512))
img_resize = trans_resize(img_PIL_RGB)  # 必须输入PIL读取的图片，输出的也是PIL格式的图片
print(img_PIL_RGB.size)  输出：(768, 512)
print(img_resize.size)   输出：(512, 512)

Compose组合

可以把几个tranforms组合在一起使用，相当于一个组合器，可以对输入图片一次进行多个transforms的操作。

Compose()用法：Compose()中的参数需要是一个列表，Python中，列表的表示形式为[数据1，数据2，...]，在Compose中，数据需要是 transforms类型，所以得到，Compose([transforms参数1， transforms参数2,...])。

Compose中传入的参数需要是一个列表，列表中的数据类型是transforms型。

参数1的输出类型必须与参数2的输入类型匹配。（因为compose的工作顺序是从左到右的，第一个参数transform介绍之后再进行第二个transform的操作，所以需要前一个的输出和后一个的输入匹配。）

我们结合上面resize的学习进行一个compose的使用，这次resize的参数只输入一个数字，300，即会等比例缩放为短边为300大小的图片。

compose负责把ToTensor和resize组合起来，一步到位实现PIL图形到resize后的tensor图形的转换。

注：
为了测试参数顺序对compose的影响，代码中我写了2个compose，分别调换了ToTensor和resize的顺序，结果完全一致，这是因为ToTensor的输出tensor可以作为resize的输入，而resize的输出PIL也可以作为ToTensor的输入，因此无影响。转自

from PIL import Image
from torch.utils.tensorboard import SummaryWriter
from torchvision import transforms
 
writer = SummaryWriter("logs")
img_path = "image/dog.jpg"
#创建PIL对象
img_PIL = Image.open(img_path)
#创建totensor和resize工具
trans_totensor_tool =transforms.ToTensor()
trans_resize_tool =transforms.Resize(300)
#compose
trans_compose_tool1 = transforms.Compose([trans_totensor_tool,trans_resize_tool])
trans_compose_tool2 = transforms.Compose([trans_resize_tool,trans_totensor_tool])
#图形转换
img_tensor_resized = trans_compose_tool1(img_PIL)
 
writer.add_image("compose",img_tensor_resized)
writer.add_image("compose",img_tensor_resized,1)
 
writer.close()

RandomCrop 随机裁剪

作用：把图像按照随机位置进行裁剪。

参数需要输入想要裁剪成的图片大小。

如果输入的是序列（h,w），会按照该长和宽进行裁剪。

如果输入的是一个整数x，则会按照（x,x）的大小裁剪。

结合Compose进行使用，完成10张大小为512*512的图片的随机裁剪。

from PIL import Image
from torch.utils.tensorboard import SummaryWriter
from torchvision import transforms
 
writer = SummaryWriter("log")
img_path = "image/dog.jpg"
#创建PIL对象
img_PIL = Image.open(img_path)
#创建工具
trans_totensor_tool = transforms.ToTensor()
trans_randomcrop_tool = transforms.RandomCrop(512)
#compose
trans_compose_tool = transforms.Compose([trans_totensor_tool,trans_randomcrop_tool])
for i in range(10):
    img_tensor_ramdomcroped = trans_compose_tool(img_PIL)
    writer.add_image("randomcrop",img_tensor_ramdomcroped,i)
 
writer.close()

总结

关注输入和输出类型

多看官方文档

关注方法需要什么参数

不知道返回值的时候 Print( ) Print(type( )) debug

torchvision中的标准数据集Datasets

torchvision官方提供了一些标准数据集，可以直接在代码里写然后下载使用，官方文档。

Datasets模块提供了需要常用的数据集以及其具体的使用方法，比如下图所示的图像分类中常用的CIFAR10数据集，图像检测中常用的COCO数据集等。

以CIFAR10为例

CIFAR-10是一个更接近普适物体的彩色图像的小型数据集。一共包含10 个类别的RGB 彩色图片：飞机（ airplane ）、汽车（ automobile ）、鸟类（ bird ）、猫（ cat ）、鹿（ deer ）、狗（ dog ）、蛙类（ frog ）、马（ horse ）、船（ ship ）和卡车（ truck ）。每个图片的尺寸为32 × 32 ，每个类别有6000个图像，数据集中一共有50000 张训练图片和10000 张测试图片。

需要设定的5个参数：

1. root（字符串型）：把数据集下载到的位置路径。

2. train（布尔型）：是否把该数据集作为训练数据集使用。

True: 作为训练数据集创建

False:不作为训练数据集，作为测试数据集创建

3. transform：图像需要进行的变换操作，一般使用compose把所需的transforms结合起来。

4. target_transform：对于标签需要做的变换

5. download（布尔型）：是否下载数据集。

True：把数据集下载到root指定的对应位置；如果数据集以及进行过下载，则不会再一次下载

False：不下载数据集

数据集下载

pycharm在线下载（下载速度较快时）

1. 导入torchvision包，然后依次创建训练数据集和测试数据集。注意：训练数据集的train参数要设置为True，测试数据集的train设置为False

import torchvision
#创建训练数据集
train_set = torchvision.datasets.CIFAR10(root="./dataset3",train=True,download=True)
#创建测试数据集
test_set = torchvision.datasets.CIFAR10(root="./dataset3",train=False,download=True)

2. 点击运行，等待一段时间后显示下载成功

3. 观察项目包目录，可以发现自动创建了名为dataset3的文件夹，下载的解压文件和解压好的数据集都在其中。

第三方下载

如果在pycharm中下载速度很慢的话，可以找到pycharm所用的下载链接，然后自己使用迅雷等下载软件进行快速下载。

如何找到下载链接？

把鼠标移动到想要下载的数据集名称上，然后Ctrl+C，进入该数据集的帮助文档。

2. 可以看到对应的下载文件名和下载链接。

3. 使用迅雷或者浏览器下载，然后把下载过后的压缩文件按照root中定义的路径创建文件夹，然后把文件放入文件夹中，注意，自己创建的文件夹一定要和root中定义的文件夹姓名相同才行，否则后期扫描不到该数据集。

4. 运行上面在线下载中定义的语句，可以发现程序不会再次下载数据集文件，而是会帮你解压好数据集。

数据集的下载总结

无论是否需要在线下载数据集，都推荐把download参数值设为True。
因为程序可以帮你自动完成下载解压工作，就算自己下载过文件，也可以提供解压功能，因此更加方便。

CIFAR10的具体使用

数据集对象的显示（PIL型）

import torchvision
#创建训练数据集
train_set = torchvision.datasets.CIFAR10(root="./dataset3",train=True,download=True)
#创建测试数据集
test_set = torchvision.datasets.CIFAR10(root="./dataset3",train=False,download=True)
 
#1. 查看数据集的图片
#输出所有类别
print(test_set.classes)
#输出数据集第一张图片的类型
print(test_set[0])
#输出图片的PIL型格式和标签
img,label = test_set[0]
print(label,test_set.classes[label])
img.show()

1. 数据集所有类别的查看
图片有十个类，对应的类别名称存储在dataset.classes列表中。
2. 数据集中单个具体对象的查看
想要输出数据集中具体的某一张图片，使用下标调用方式dataset[x]即可显示第x+1张图片；输出的对象类型为一个元组，里面第一项是PIL类型的图片，第二项是图片的标签。
3. 数据集中图片对象和标签的定义
可以使用 img,label = dataset[x] 的方式接收对象中的图片和label，然后可以用print进行对label的输出，也可以用 dataset. classes[label]的格式进行对该类别名称的显示。
4. 数据集中图片的可视化
使用img.show()方法进行图片的可视化显示

把数据集中的图片对象转换为tensor型

转换所需transform的定义

因为需要完成数据集中所有图片类型从PIL到tensor的转换，我们需要用到transforms工具，也需要设定数据集中的transform参数。

我们在数据集定义的语句之前定义我们需要的transform。在这里我们只需要一个ToTensor即可。

下面代码给出使用compose定义transform和不使用compose的两个版本，都可以完成成功运行。

使用compose：

import torchvision
#定义transforms
dataset_transform = torchvision.transforms.Compose([
    #定义totensor
    torchvision.transforms.ToTensor()
])
#创建训练数据集
train_set = torchvision.datasets.CIFAR10(root="./dataset3",train=True,transform=dataset_transform,download=True)
#创建测试数据集
test_set = torchvision.datasets.CIFAR10(root="./dataset3",train=False,transform=dataset_transform,download=True)

不使用compose：

import torchvision
#定义transforms
from torch.utils.tensorboard import SummaryWriter
 
trans_totensor_tool = torchvision.transforms.ToTensor()
#创建训练数据集
train_set = torchvision.datasets.CIFAR10(root="./dataset3",train=True,transform=trans_totensor_tool,download=True)
#创建测试数据集
test_set = torchvision.datasets.CIFAR10(root="./dataset3",train=False,transform=trans_totensor_tool,download=True)

torchvision中现有网络模型的使用与修改

VGG地址可以分类1000个类别，因为ImageNet就是1000类。

pretrained为True指权重预训练好了已经；progress为True开启下载进度条。

因为ImageNet太大了，所以用CIFAR10数据集来演示，但是CIFAR10只有10个类别，所以需要对VGG网络结构进行修改。两种方法：

在VGG的全连接层最后一层把1000改成10

在VGG的全连接层的最后一层后面再加一层，输出是10

VGG的模型代码中分为feature和classifier。

import torchvision
from torch import nn

vgg16_flase = torchvision.models.vgg16(pretrained = False) # 不下载预训练权重
vgg16_ture = torchvision.models.vgg16(pretrained = True) # 下载预训练权重，运行就会自动下载权重了
print(vgg16_ture) # 看看模型结构

train_data = torchvision.datasets.CIFAR10('data', train=True, transform=torchvision.transforms.ToTensor(), download=True)

#添加新的一层
vgg16_ture.add_module('add_linear', nn.Linear(1000, 10)) # 在提特征层和分类层外面加
vgg16_ture.classifier.add_module('add_linear', nn.Linear(1000, 10)) # 加到分类层里面
print(vgg16_ture)

#修改
vgg16_flase.classifier[6] = nn.Linear(4096, 10) # 把模型打印出来再修改比较直观
print(vgg16_flase)

RGB格式和BGR格式之间的互相转换

cv2.cvtColor(img_PIL_RGB_np, cv2.COLOR_RGB2BGR) 转换函数

opencv读出来的图片是numpy格式,opencv读取时路径中不可以有中文

from PIL import Image
import cv2
from torchvision import transforms
import numpy as np

img_path = "../hymenoptera_data/train/ants/0013035.jpg"
img_PIL_RGB = Image.open(img_path)  # RGB 格式 HWC 0~255
img_cv2_BGR = cv2.imread(img_path)  # BGR 格式 HWC 0~255

# 如果想用cv2显示图片，图片必须是BGR格式的才能正常显示
img_PIL_RGB_np = np.array(img_PIL_RGB)  # 512X768x3 HWC  变成numpy格式
img_PIL_BGR_np = cv2.cvtColor(img_PIL_RGB_np, cv2.COLOR_RGB2BGR)  # 把RGB转换成BGR
cv2.imshow("img_PIL_BGR", img_PIL_BGR_np)  # cv2显示的图片必须是BGR格式的才能正常显示
cv2.imshow("img_cv2_RGB", img_PIL_RGB_np)  # RGB的是显示不正常的
cv2.imshow("img_cv2_BGR", img_cv2_BGR)
cv2.waitKey(0)  # 一直显示图片，直到按下任意键才关掉继续执行程序。里面的参数是显示的时间，单位ms

tensor_trans = transforms.ToTensor() # 会自动把HWC变成CHW，把0-255变成0-1，但是不会改变RGB和BGR格式
tensor_img_PIL_RGB = tensor_trans(img_PIL_RGB)

img_cv2_RGB = cv2.cvtColor(img_cv2_BGR, cv2.COLOR_BGR2RGB)  # BGR 转换成 RGB  HWC

def bgr2rgb(image):  # 自己写的BGR转换成RGB格式的函数，用numpy切片索引实现
    # 输入图片是HWC
    b_channel = image[:, :, 0].copy()  # copy表述b_channel现在和image没有关系了，image怎么变都影响不了b_channel了
    r_channel = image[:, :, 2].copy()
    image[:, :, 0] = r_channel   # 不copy的话这里image变了，b_channel会跟着改变
    image[:, :, 2] = b_channel
    return image

img_cv2_RGB = bgr2rgb(img_cv2_BGR)  # 用自己写的函数来BGR 转换成 RGB

tensor_img_cv2_RGB = tensor_trans(img_cv2_RGB)
print(tensor_img_PIL_RGB)
print(tensor_img_cv2_RGB)

PNG格式的图片需要去掉透明度通道

PNG图片HWC的C有4个通道，其中一个是透明度通道。

import numpy as np
from PIL import Image
import cv2

img_PIL = Image.open("0324204803.png") # 用PIL打开有4个通道
img_np = np.array(img_PIL)
print(img_np.shape)   # 输出(275, 115, 4)

img_cv = cv2.imread("0324204803.png") # 用cv2不加任何参数打开会变成3通道，(275, 115, 3)
img_cv = cv2.imread("0324204803.png",cv2.IMREAD_UNCHANGED) #用cv2加参数打开是4通道
cv2.imshow("img_cv", img_cv) # 我感觉cv2打开应该是BGR，但是显示是正常的
cv2.waitKey(0)
print(img_cv.shape) # 输出(275, 115, 4)

PNG格式图片4通道变RGB3通道方法

img_PIL = Image.open("0324204803.png") # 4通道(275, 115, 4)
img_PIL = img_PIL.convert('RGB')
img_np = np.array(img_PIL)
print(img_np.shape) # 输出(275, 115, 3)

如果原来就是RGB3通道，那加上这个.convert('RGB')也没事。

或者直接用opencv不加任何参数，读进来会变成3通道，但不一定是RGB

img_cv = cv2.imread("0324204803.png") # 用cv2不加任何参数打开会变成3通道，(275, 115, 3)

神经网络基本骨架 torch.nn.Module 官方文档

我们自己定义的神经网络需要继承nn.Module类，需要重写以下两个方法：

init方法：初始化

forward方法：前向传播

在官方文档给出的示例中，在init方法中进行了卷积操作，在forward方法中进行了ReLu非线性处理操作，代码如下所示。

对输入的x进行第一次卷积，再进行第一次非线性操作；

再第二次进行卷积，然后第二次非线性操作。

import torch.nn as nn
import torch.nn.functional as F
 
class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.conv1 = nn.Conv2d(1, 20, 5) # 卷积核
        self.conv2 = nn.Conv2d(20, 20, 5)
 
    def forward(self, x):
        x = F.relu(self.conv1(x))
        return F.relu(self.conv2(x))

自定义搭建神经网络

自定义名为Ysy的神经网络，继承自nn.Module

重写init和forward两个方法，在forward中定义该神经网络的规则，即输入+1为输出

实例化神经网络

把tensor类型的值x放入神经网络中进行输出

成功输出结果为 x+1

import torch
from torch import nn

class Ysy(nn.Module):
    def __init__(self):
        super(Ysy, self).__init__()
 
    def forward(self,input):
        output = input + 1;
        return output
 
# 创建神经网络
ysy = Ysy()
# 输入的值为x，tensor型，数值为1
x = torch.tensor(1.0)
# 输出为output
output = ysy(x)
print(output)

这里在计算的时候并没有调用forward方法，学长说就理解成nn.Module里面的__call__里面调用了forward就行。

神经网络之卷积操作

两种2d卷积的实现方式

torch.nn Conv2d是类

CLASS torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros', device=None, dtype=None)

torch.nn.functional conv2d是函数

torch.nn.functional.conv2d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1) → Tensor

import torch.nn.functional as F

torch.nn.functional.conv2d方法介绍

使用该方法需要引入的参数

torch.nn.functional.conv2d( input, weight, bias=None, stride=1, padding=0,
dilation=1, groups=1) → Tensor

https://pytorch.org/docs/stable/generated/torch.nn.functional.conv2d.html#torch.nn.functional.conv2d

weight就是卷积核。

stride步长参数可以是元组，一个是H方向的步长，一个是W方向的步长。

padding可以是一个元组，纵向和横向padding的参数。

关于对input和weight的shape详解

方法中对input和weight要求的shape都需要是4维的。

input的shape要求：

minibatch：batch中的样例个数

in_channels：每个样例数据的通道数

iH：每个样例的高（行数）

iW：每个样例的宽（列数）

weight的shape要求：

out_channels：卷积核的个数

in_channels/groups：每个卷积核的通道数

kH：每个卷积核的高（行数）

kW：每个卷积核的宽（列数）

正常定义的tensor型shape为二维，即只有长和宽，因此需要使用reshape方法进行尺寸重定义。

import torch
import torch.nn.functional as F

# 输入
input = torch.tensor([[1,2,0,3,1],
                      [0,1,2,3,1],
                      [1,2,1,0,0],
                      [5,2,3,1,1],
                      [2,1,0,1,1]])
# 卷积核
kernel = torch.tensor([[1,2,1],
                       [0,1,0],
                       [2,1,0]])
print(input.shape)
print(kernel.shape)
 
# 重新定义尺寸，把尺寸改成四个数，1个batchsize，1个通道，长和宽和之前一样
input = torch.reshape(input,(1,1,5,5))
kernel = torch.reshape(kernel,(1,1,3,3))
 
print(input.shape)
print(kernel.shape)
 
#stride=1或2时的输出
output1 = F.conv2d(input,kernel,stride=1)
print(output1)
output2 = F.conv2d(input,kernel,stride=2)
print(output2)
 
# padding=1或2时的
output3 = F.conv2d(input,kernel,stride=1,padding=1)
print(output3)
output4 = F.conv2d(input,kernel,stride=1,padding=2)
print(output4)

torch.nn.Conv2d

CLASS torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros', device=None, dtype=None)

参数介绍

in_channels ( int ) – Number of channels in the input image，输入图片的通道数
out_channels ( int ) – Number of channels produced by the convolution，输出图片的通道数, 代表卷积核的个数，使用n个卷积核输出的特征矩阵深度即channel就是n
kernel_size ( int or tuple ) – Size of the convolving kernel，卷积核的大小
e.g. if kernel size = 3, 则卷积核的大小是3*3
stride ( int or tuple , optional) – Stride of the convolution. Default: 1，步径大小
padding ( int , tuple or str , optional) – Padding added to all four sides of the input. Default: 0
padding_mode ( str , optional) – 'zeros', 'reflect', 'replicate' or 'circular'. Default: 'zeros'
dilation ( int or tuple , optional) – Spacing between kernel elements. Default: 1
groups ( int , optional) – Number of blocked connections from input channels to output channels. Default: 1
bias ( bool , optional) – If True, adds a learnable bias to the output. Default: True

输出的尺寸大小

dilation：空洞卷积，进行卷积操作时会隔n个取一个。

import torch
import torchvision
from torch.nn import Conv2d
from torch.utils.data import DataLoader
# 数据集下载
from torch.utils.tensorboard import SummaryWriter
 
dataset = torchvision.datasets.CIFAR10(root=".\CIFAR10", train=False, transform=torchvision.transforms.ToTensor(),
                                       download=True)
# 数据加载器
dataloader = DataLoader(dataset, batch_size=64)
 
class Ysy(torch.nn.Module):
    def __init__(self):
        super(Ysy, self).__init__()
        # 卷积层
        self.conv1 = Conv2d(in_channels=3, out_channels=6, kernel_size=3, stride=1, padding=0)
 
    def forward(self, x):
        x = self.conv1(x)
        return x
 
ysy = Ysy()

writer = SummaryWriter("logs")
step = 0
for data in dataloader:
    imgs, labels = data
    # 卷积操作
    output = ysy(imgs) # 卷积核权重是随机生成的
    print(imgs.shape)
    print(output.shape)
    writer.add_images("input", imgs, step)
 
    output = torch.reshape(output, (-1, 3, 30, 30)) #输出有6个通道但是为了可视化以下强行reshape成3个通道，没什么卵用
    writer.add_images("output", output, step)
    step = step + 1

writer.close()

ReflectionPad2d--利用输入边界的反射来padding输入张量链接

最大池化（下采样）

MaxPool2d是下采样；MaxUnpool是上采样

CLASS torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)

stride的默认大小为池化核的大小

ceil_mode：

遇到这种不足9个数的情况时是否要对这6个数进行池化，默认False就不管了，True就要池化这6个数。

MaxPool2d不支持输入的tensor的数据类型是long，会报错。

最大池化的作用和目的

作用：最大限度的保留图片特征，同时减少数据量,加速训练速度。

import torch
from torch.nn import MaxPool2d
#输入的矩阵 
input = torch.tensor([
    [1,2,0,3,1],
    [0,1,2,3,1],
    [1,2,1,0,0],
    [5,2,3,1,1],
    [2,1,0,1,1]
],dtype=torch.float32)
 
input = torch.reshape(input,(-1,1,5,5))
print(input.shape)
 
class Ysy(torch.nn.Module):
    def __init__(self):
        super(Ysy, self).__init__()
        # 设置池化
        self.maxpool1 = MaxPool2d(kernel_size=3,ceil_mode=False)
 
    def forward(self,input):
        output = self.maxpool1(input)
        return output
 
ysy = Ysy()
output = ysy(input)
print(output)

import torch
import torchvision.datasets
from torch.nn import MaxPool2d
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10(root=".\CIFAR10",train=False,transform=torchvision.transforms.ToTensor(),download=True)
dataloader = DataLoader(dataset,batch_size=64)

class Ysy(torch.nn.Module):
    def __init__(self):
        super(Ysy, self).__init__()
        # 设置池化
        self.maxpool1 = MaxPool2d(kernel_size=3,ceil_mode=False)
 
    def forward(self,input):
        output = self.maxpool1(input)
        return output
 
writer = SummaryWriter("logs")
step = 0
ysy = Ysy()
 
for data in dataloader:
    imgs,labels=data
    writer.add_images("inputs",imgs,step)
    output = ysy(imgs)
    writer.add_images("output",output,step)
    step+=1
 
writer.close()

torch.cat([feature_B,feature_D],1)

一般卷积网络里的tensor的shape都是(N,C,H,W)，所以concatenate的时候想拼接通道就应该是dim=1，在C的维度进行拼接。

非线性激活

作用：非线性变换的主要目的就是给网中加入一些非线性特征，非线性越多才能训练出符合各种特征的模型。

ReLu

CLASStorch.nn.ReLU(inplace=False)

inplace代表是否替换/保留原输入的意思

inplace = True，代表确定替换，即不保留非线性激活之前的值，会把输入值直接替换为激活后的值。

inplace = False（默认），代表不替换，即保留非线性激活之前的值，会把输入值保留下来，再另存一个输出值。

import torch
from torch.nn import ReLU
 
input = torch.tensor([
    [1,-0.5],
    [-1,3]])
 
input= torch.reshape(input,(-1,1,2,2))
 
class Ysy(torch.nn.Module):
    def __init__(self):
        super(Ysy, self).__init__()
        # inplace默认为FALSE，可以不进行设置
        self.relu = ReLU()
 
    def forward(self,input):
        output = self.relu(input)
        return output
 
ysy = Ysy()
output = ysy(input)
print(output)

Sigmoid

CLASStorch.nn.Sigmoid(*args, **kwargs)

import torch
import torchvision.datasets
from torch.nn import ReLU, Sigmoid
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10(root=".\CIFAR10",train=True,transform=torchvision.transforms.ToTensor(),download=True)
dataloader = DataLoader(dataset,batch_size=64)

class Ysy(torch.nn.Module):
    def __init__(self):
        super(Ysy, self).__init__()
        # inplace默认为FALSE，可以不进行设置
        self.relu = ReLU()
        #设置sigmoid激活
        self.sigmoid1 = Sigmoid()
 
    def forward(self,input):
        output = self.sigmoid1(input)
        return output
 
ysy = Ysy()
 
writer = SummaryWriter("logs")
step = 0
for data in dataloader:
    imgs,labels = data
    writer.add_images("inputs",imgs,step)
    outputs = ysy(imgs)
    writer.add_images("outputs",outputs,step)
    step+=1
 
writer.close()

Batch-norm 官方文档

CLASS torch.nn.BatchNorm2d(num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True, device=None, dtype=None)

nn.BatchNorm2d(channel)

BN层里的参数也是可以学习的。

全连接层

基于公式y=wx+b计算，w为权重，x为输入，b为偏置值。

参数:
in_features，输入特征 ( int ) – size of each input sample，输入的tensor大小
out_features，输出特征 ( int ) – size of each output sample，输出的tensor大小
bias ( bool ) – If set to False, the layer will not learn an additive bias. Default: True

import torch
import torchvision.datasets
from torch.nn import Linear
from torch.utils.data import DataLoader
 
dataset = torchvision.datasets.CIFAR10(root="./CIFAR10", train=False, transform=torchvision.transforms.ToTensor(),
                                       download=True)
dataloader = DataLoader(dataset, batch_size=64)
 
class Ysy(torch.nn.Module):
    def __init__(self):
        super(Ysy, self).__init__()
        self.linear1 = Linear(196608, 10)
 
    def forward(self, input):
        output = self.linear1(input)
        return output
 
ysy = Ysy()
for data in dataloader:
    imgs, lables = data
    print(imgs.shape)
    input = torch.flatten(imgs) 或者 out = torch.reshape(imgs, (1, 1, 1, -1))
    print(input.shape)  # 这里的展平有点问题，不应该把batch的所有图片展平到一起，应该分开展平
    output = ysy(input)
    print(output.shape)

展平特征用这个更多CLASS torch.nn.Flatten(start_dim=1, end_dim=- 1)

input = torch.randn(32, 1, 5, 5)
# With default parameters
m = nn.Flatten()
output = m(input)
output.size()  # torch.Size([32, 25])
# With non-default parameters
m = nn.Flatten(0, 2)
output = m(input)
output.size()  # torch.Size([160, 5])

Sequential的使用

构建一个序列化的container，可以把想要在神经网络中添加的操作都放进去，按顺序进行执行。

Example

把卷积、非线性激活、卷积、非线性激活使用sequantial进行组合，一起放在构建的model中。

model = nn.Sequential(
          nn.Conv2d(1,20,5),
          nn.ReLU(),
          nn.Conv2d(20,64,5),
          nn.ReLU()
        )
 
# Using Sequential with OrderedDict. This is functionally the
# same as the above code
model = nn.Sequential(OrderedDict([
          ('conv1', nn.Conv2d(1,20,5)),
          ('relu1', nn.ReLU()),
          ('conv2', nn.Conv2d(20,64,5)),
          ('relu2', nn.ReLU())
        ]))

实战神经网络搭建以及sequential的使用

不使用sequential

import torch.nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear
 
class Maweiyi(torch.nn.Module):
    def __init__(self):
        super(Maweiyi, self).__init__()
        self.conv1 = Conv2d(in_channels=3, out_channels=32, kernel_size=5, padding=2)
        self.maxpool1 = MaxPool2d(kernel_size=2)
        self.conv2 = Conv2d(in_channels=32, out_channels=32, kernel_size=5, padding=2)
        self.maxpool2 = MaxPool2d(kernel_size=2)
        self.conv3 = Conv2d(in_channels=32, out_channels=64, kernel_size=5, padding=2)
        self.maxpool3 = MaxPool2d(kernel_size=2)
        self.flatten = Flatten()
        self.linear1 = Linear(in_features=1024, out_features=64)
        self.linear2 = Linear(in_features=64, out_features=10)
 
    def forward(self, x):
        x = self.conv1(x)
        x = self.maxpool1(x)
        x = self.conv2(x)
        x = self.maxpool2(x)
        x = self.conv3(x)
        x = self.maxpool3(x)
        x = self.linear1(x)
        x = self.linear2(x)
        return x

使用sequential

class Maweiyi(torch.nn.Module):
    def __init__(self):
        super(Maweiyi, self).__init__()
        self.model1 = Sequential(
            Conv2d(in_channels=3, out_channels=32, kernel_size=5, padding=2),
            MaxPool2d(kernel_size=2),
            Conv2d(in_channels=32, out_channels=32, kernel_size=5, padding=2),
            MaxPool2d(kernel_size=2),
            Conv2d(in_channels=32, out_channels=64, kernel_size=5, padding=2),
            MaxPool2d(kernel_size=2),
            Flatten(),
            Linear(in_features=1024, out_features=64),
            Linear(in_features=64, out_features=10)
        )
 
    def forward(self, x):
         x = self.model1(x)
         return x

tensorboard SummaryWriter中的add_gragh可视化神经网络模型

import torch.nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
from torch.utils.tensorboard import SummaryWriter
 
class Maweiyi(torch.nn.Module):
    def __init__(self):
        super(Maweiyi, self).__init__()
        self.model1 = Sequential(
            Conv2d(in_channels=3, out_channels=32, kernel_size=5, padding=2),
            MaxPool2d(kernel_size=2),
            Conv2d(in_channels=32, out_channels=32, kernel_size=5, padding=2),
            MaxPool2d(kernel_size=2),
            Conv2d(in_channels=32, out_channels=64, kernel_size=5, padding=2),
            MaxPool2d(kernel_size=2),
            Flatten(),
            Linear(in_features=1024, out_features=64),
            Linear(in_features=64, out_features=10)
        )
 
    def forward(self, x):
         x = self.model1(x)
         return x

maweiyi = Maweiyi()
print(maweiyi)
 
input = torch.ones((64,3,32,32))
output = maweiyi(input)
print(output.shape)
 
writer = SummaryWriter("logs")
writer.add_graph(maweiyi,input)
writer.close()

损失函数

L1loss nn.L1Loss 绝对值误差

CLASS torch.nn.L1Loss(size_average=None, reduce=None, reduction='mean')

import torch
from torch.nn import L1Loss
 
inputs = torch.tensor([1,2,3],dtype=torch.float32)
targets = torch.tensor([1,2,5],dtype=torch.float32)
inputs = torch.reshape(inputs,(1,1,1,3))
targets = torch.reshape(targets,(1,1,1,3))
loss2 = L1Loss(reduction="sum")
result2 = loss2(inputs,targets)
print(result2)

MSE损失函数（均方误差）MSELoss

CLASS torch.nn.MSELoss(size_average=None, reduce=None, reduction='mean')

import torch
from torch.nn import L1Loss, MSELoss
 
inputs = torch.tensor([1,2,3],dtype=torch.float32)
targets = torch.tensor([1,2,5],dtype=torch.float32)
 
inputs = torch.reshape(inputs,(1,1,1,3))
targets = torch.reshape(targets,(1,1,1,3))
 
loss_mse1 = MSELoss()
result1 = loss_mse1(inputs,targets)
print(result1)

使用交叉熵损失函数CrossEntropyLoss

注意这个交叉熵函数里面包括了softmax最后的归一化处理，所以输入给它的数得是没经过softmax归一化的数据。

CLASS torch.nn.CrossEntropyLoss(weight=None, size_average=None, ignore_index=- 100, reduce=None, reduction='mean', label_smoothing=0.0)

这张图用softmax的交叉熵来演示，至于为什么写的这么复杂，是因为这里写的[0.1，0.2，0.3]并不是softmax归一化之后的概率，而是输入给softmax的数（得分），因此损失函数也要加一个softmax归一化，softmax的损失函数就是-log y_hat。

参数说明

输入输出说明

import torch.nn
from torch import nn
import torchvision.datasets
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
 
dataset = torchvision.datasets.CIFAR10(root="./CIFAR10",train=False,transform=torchvision.transforms.ToTensor(),download=True)
dataloader = DataLoader(dataset,batch_size=1)

class Maweiyi(torch.nn.Module):
    def __init__(self):
        super(Maweiyi, self).__init__()
        self.model1 = Sequential(
            Conv2d(in_channels=3, out_channels=32, kernel_size=5, padding=2),
            MaxPool2d(kernel_size=2),
            Conv2d(in_channels=32, out_channels=32, kernel_size=5, padding=2),
            MaxPool2d(kernel_size=2),
            Conv2d(in_channels=32, out_channels=64, kernel_size=5, padding=2),
            MaxPool2d(kernel_size=2),
            Flatten(),
            Linear(in_features=1024, out_features=64),
            Linear(in_features=64, out_features=10)
        )
 
    def forward(self, x):
         x = self.model1(x)
         return x
 
maweiyi = Maweiyi()
# 使用交叉熵损失函数
loss_cross = nn.CrossEntropyLoss()
 
for data in dataloader:
    imgs,labels = data
    outputs = maweiyi(imgs)
    results = loss_cross(outputs,labels)
    results.backward()  # 反向传播

优化器，梯度下降

import torch
import torchvision
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential, ReLU, Sigmoid
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10(root="dataset", train=False, transform=torchvision.transforms.ToTensor()
                                       ,download=False)
dataloader = DataLoader(dataset, batch_size=1)

class ZYJ(nn.Module):
    def __init__(self):
        super(ZYJ, self).__init__()
        self.model = Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            ReLU(),
            Conv2d(32, 32, 5, padding=2),
            Sigmoid(),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )
    def forward(self, input):
        output = self.model(input)
        return output

zyj = ZYJ()
loss = nn.CrossEntropyLoss()
optim = torch.optim.SGD(zyj.parameters(), lr=0.01)
for epoch in range(50):
    running_loss = 0.0

    for data in dataloader:
        imgs, targets = data
        output = zyj(imgs)  # 边计算，边创建计算图
        result_loss = loss(output, targets) #边计算，边创建计算图
        optim.zero_grad() # 梯度清零，pytorch默认梯度会累加，清除上一次的梯度
        result_loss.backward()  # 获得每个参数的梯度，后续用优化器进行优化参数
        optim.step() # 梯度下降，更新参数，默认会删除计算图
        running_loss = running_loss + result_loss # 把一个batch里的所有小块的loss加起来了
    print(running_loss)

Pytorch的动态图、自动求导

Pytorch的自动求导系统要注意：梯度不自动清零：就是每一次反向传播，梯度都会叠加上去。所以迭代的时候要清零。

模型的保存与加载

import torch
import torchvision
from torch import nn

vgg16 = torchvision.models.vgg16(pretraned = False)

#保存方式1，保存网络模型和权重
torch.save(vgg16, "vgg16_method1.pth") # 第二个参数是保存路径

#保存方式1，保存网络模型和权重→对应的模型加载
model = torch.load("vgg16_method1.pth")

#保存方式2，只保存权重，不保存模型 (官方推荐)
torch.save(vgg16.state_dict(), "vgg16_method2.pth")

#保存方式2，只保存权重，不保存模型 (官方推荐)→对应的模型加载
vgg16 = torchvision.models.vgg16(pretrained = False)
vgg16.load_state_dict(torch.load("vgg16_method2.pth"))
print(vgg16)

#保存方式1  注意陷阱！ 在加载模型的时候，需要有模型定义！
class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()
        self.model1 = nn.Sequential(
            nn.Linear(64, 10)
        )
    def forward(self, x):
        x = self.model1(x)
        return x

tudui = Tudui()
torch.save(tudui, "model/tudui_method.pth")  #按照保存方式1，保存模型和权重

# 加载模型
class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()
        self.model1 = nn.Sequential(
            nn.Linear(64, 10)
        )

    def forward(self, x):
        x = self.model1(x)
        return x

model = torch.load("model/tudui_method.pth") # 可以省略tudui = Tudui()实例化这一步，但是模型定义不能缺
print(model)
#不过一般都不会有这种问题，因为我们一般把模型放在一个单独的文件里 from model_save import *

保存和加载checkpoint

保存的checkpoint里面除了保存了权重还可能保存了优化器参数，epoch，loss等等参数。为啥我保存的权重文件那么大？如何保存与加载checkpoints

保存checkpoints

EPOCH = 5
PATH = "model.pt"
LOSS = 0.4

torch.save({
            'epoch': EPOCH,
            'model_state_dict': net.state_dict(),
            'optimizer_state_dict': optimizer.state_dict(),
            'loss': LOSS,
            }, PATH)

加载checkpoints

model = Net()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

checkpoint = torch.load(PATH)
model.load_state_dict(checkpoint['model_state_dict'])
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
epoch = checkpoint['epoch']
loss = checkpoint['loss']
 
model.eval()
# - or -
model.train()

pytorch模型的保存和加载、checkpoint pytorch实现加载保存查看checkpoint文件

完整的模型小项目

用上面这个简单模型给CIFAR10数据集分类，10个类别。

通常模型都单独放在一个python文件里一般是model

model.py

import torch
from torch import nn

#搭建神经网络
class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()
        self.model = nn.Sequential(
            nn.Conv2d(3, 32, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 32, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Flatten(),
            nn.Linear(1024, 64),
            nn.Linear(64, 10)
        )

    def forward(self, x):
        x = self.model(x)
        return x

if __name__ == '__main__': # 测试一下模型对不对
     tudui = Tudui()
     input = torch.ones((64, 3, 32, 32))
     output = tudui(input)
     print(output.shape) # shape和size功能一样

model.py和train.py必须在同一目录下

train.py （CPU训练）

import torch
import torchvision
from torch import nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from model import *

#准备数据集
train_data = torchvision.datasets.CIFAR10('data', train=True, transform=torchvision.transforms.ToTensor(), download=True)
test_data = torchvision.datasets.CIFAR10('data', train=False, transform=torchvision.transforms.ToTensor(), download=True)

#数据集长度
train_data_size = len(train_data)
test_data_size = len(test_data)
print("训练数据集长度：{}".format(train_data_size))
print("测试数据集长度：{}".format(test_data_size))

#加载数据集（Dataloader）
train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)

#创建网络模型
tudui = Tudui()

#损失函数
loss_fn = nn.CrossEntropyLoss()

#优化器
#learning_rate = 0.01
learning_rate = 1e-2
optimizer = torch.optim.SGD(tudui.parameters(), lr=learning_rate)

#参数
total_train_step = 0
total_test_step = 0
epoch = 10

#添加tensorbooard
writer = SummaryWriter("logs/trainlogs")

for i in range(epoch):
    print("-----第{}轮训练-----".format(i+1))

    #训练开始
    tudui.train() # 让模型进入训练状态
    for data in train_dataloader:
        imgs, targets = data
        outputs = tudui(imgs)
        loss = loss_fn(outputs, targets)

        #优化器调优
        optimizer.zero_grad() #梯度清零
        loss.backward() # 求梯度
        optimizer.step() # 梯度下降

        total_train_step = total_train_step + 1
        if total_train_step % 100 == 0:
            print("训练次数：{}，Loss：{}".format(total_train_step, loss.item()))
            writer.add_scalar("train_loss", loss.item(), total_train_step)

    #一轮训练过后我要看看模型训练的效果如何，所以要在验证集上评估一下
    tudui.eval() # 让模型进入验证评估状态
    total_test_loss = 0
    total_accuracy = 0
    with torch.no_grad(): # 去掉梯度，只有前向推理
        for data in test_dataloader:
            imgs, targets = data
            outputs = tudui(imgs)
            loss = loss_fn(outputs, targets) #看一下验证集上的loss
            total_test_loss = total_test_loss + loss.item()#把所有验证集batch的loss加起来
            accuracy = (outputs.argmax(1) == targets).sum() #求准确率
            total_accuracy = total_accuracy + accuracy #整体验证集的准确率，但是我觉得应该不能是直接累加

    print("整体验证集的loss：{}".format(total_test_loss))
    print("验证集正确率: {}".format(total_accuracy / test_data_size))
    total_test_step = total_test_step + 1
    writer.add_scalar("test_loss", total_test_loss, total_test_step)
    writer.add_scalar("test_accuracy", total_accuracy / test_data_size, total_test_step)

    torch.save(tudui, "model/tudui_{}.pth".format(i))
    # torch.save(tudui.state_dict(), "tudui_{}.pth".format(i))
writer.close()

一维或零维张量.item( )方法是，取一个张量里面的具体元素值并返回该值，可以将一个零维张量转换成int型或者float型，在计算loss，accuracy时常用到。

张量.argmax(1)的用法，返回最大值对应的序号

import torch

output = torch.tensor([[0.2, 0.8],
                       [0.4,0.6]])
print(output.argmax(0)) # tensor([1, 0])竖着找最大值的序号
print(output.argmax(1)) # tensor([1, 1])横着找最大值的序号

tudui.train() # 让模型进入训练状态

对BN和dropout有作用，其他的好像没什么用

tudui.eval() # 让模型进入验证评估状态

对BN和dropout有作用，其他的好像没什么用

利用GPU来训练

方法一：

在这些东西后面加.cuda( )

网络模型 tudui = tudui.cuda( ) tudui是模型

数据（输入数据，标签） imgs = imgs.cuda() targets = targets.cuda() 是在训练的for循环里加

损失函数 loss_fn = loss_fn.cuda()

师兄说只要是tensor张量和模型就可以加.cuda

import torch
import torchvision
from torch import nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

from model import *

#准备数据集
train_data = torchvision.datasets.CIFAR10('data', train=True, transform=torchvision.transforms.ToTensor(), download=True)
test_data = torchvision.datasets.CIFAR10('data', train=False, transform=torchvision.transforms.ToTensor(), download=True)

#数据集长度
train_data_size = len(train_data)
test_data_size = len(test_data)
print("训练数据集长度：{}".format(train_data_size))
print("测试数据集长度：{}".format(test_data_size))

#加载数据集（Dataloader）
train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)

#创建网络模型
tudui = Tudui()
if torch.cuda.is_available():#1、网络模型后面加.cuda
    tudui = tudui.cuda()

#损失函数
loss_fn = nn.CrossEntropyLoss()
if torch.cuda.is_available():#2、损失函数后面加.cuda
    loss_fn = loss_fn.cuda()

#优化器
#learning_rate = 0.01
learning_rate = 1e-2
optimizer = torch.optim.SGD(tudui.parameters(), lr=learning_rate)

#参数
total_train_step = 0
total_test_step = 0
epoch = 10

#添加tensorbooard
writer = SummaryWriter("logs/trainlogs")

for i in range(epoch):
    print("-----第{}轮训练-----".format(i+1))

    #训练开始
    tudui.train()#模型进入训练状态
    for data in train_dataloader:
        imgs, targets = data
        if torch.cuda.is_available():#3、数据后面加.cuda
            imgs = imgs.cuda()
            targets = targets.cuda()
        outputs = tudui(imgs)
        loss = loss_fn(outputs, targets)

        #优化器调优
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        total_train_step = total_train_step + 1
        if total_train_step % 100 == 0:
            print("训练次数：{}，Loss：{}".format(total_train_step, loss.item()))
            writer.add_scalar("train_loss", loss.item(), total_train_step)

    #验证集评估
    tudui.eval()#模型进入评估状态
    total_test_loss = 0
    total_accuracy = 0
    with torch.no_grad():
        for data in test_dataloader:
            imgs, targets = data
            if torch.cuda.is_available():#3、数据后面加.cuda
                imgs = imgs.cuda()
                targets = targets.cuda()
            outputs = tudui(imgs)
            loss = loss_fn(outputs, targets)
            total_test_loss = total_test_loss + loss.item()
            accuracy = (outputs.argmax(1) == targets).sum()
            total_accuracy = total_accuracy + accuracy

    print("测试集loss：{}".format(total_test_loss))
    print("测试集正确率: {}".format(total_accuracy / test_data_size))
    total_test_step = total_test_step + 1
    writer.add_scalar("test_loss", total_test_loss, total_test_step)
    writer.add_scalar("test_accuracy", total_accuracy / test_data_size, total_test_step)

    torch.save(tudui, "model/tudui_{}.pth".format(i))

writer.close()

方法二：（常用，可以选择显卡）

#定义训练的设备

device = torch.device("cuda")

device = torch.device("cuda:0") # 对于单显卡来说这两句话是没有区别的

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

tudui = tudui.to(device)

loss_fn = loss_fn.to(device)

imgs = imgs.to(device)

targets = targets.to(device)

import torch
import torchvision
from torch import nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

from model import *

#定义训练的设备
#device = torch.device("cpu")
device = torch.device("cuda:0")
#device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

#准备数据集
train_data = torchvision.datasets.CIFAR10('data', train=True, transform=torchvision.transforms.ToTensor(), download=True)
test_data = torchvision.datasets.CIFAR10('data', train=False, transform=torchvision.transforms.ToTensor(), download=True)

#数据集长度
train_data_size = len(train_data)
test_data_size = len(test_data)
print("训练数据集长度：{}".format(train_data_size))
print("测试数据集长度：{}".format(test_data_size))

#加载数据集（Dataloader）
train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)

#创建网络模型
tudui = Tudui()
tudui = tudui.to(device)

#损失函数
loss_fn = nn.CrossEntropyLoss()
loss_fn = loss_fn.to(device)

#优化器
#learning_rate = 0.01
learning_rate = 1e-2
optimizer = torch.optim.SGD(tudui.parameters(), lr=learning_rate)

#参数
total_train_step = 0
total_test_step = 0
epoh = 10

#添加tensorbooard
writer = SummaryWriter("logs/trainlogs")

for i in range(epoh):
    print("-----第{}轮训练-----".format(i+1))

    #训练开始
    tudui.train()#模型状态
    for data in train_dataloader:
        imgs, targets = data
        imgs = imgs.to(device)
        targets = targets.to(device)
        outputs = tudui(imgs)
        loss = loss_fn(outputs, targets)

        #优化器调优
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        total_train_step = total_train_step + 1
        if total_train_step % 100 == 0:
            print("训练次数：{}，Loss：{}".format(total_train_step, loss.item()))
            writer.add_scalar("train_loss", loss.item(), total_train_step)

    #测试
    tudui.eval()#模型状态
    total_test_loss = 0
    total_accuracy = 0
    with torch.no_grad():
        for data in test_dataloader:
            imgs, targets = data
            imgs = imgs.to(device)
            targets = targets.to(device)
            outputs = tudui(imgs)
            loss = loss_fn(outputs, targets)
            total_test_loss = total_test_loss + loss.item()
            accuracy = (outputs.argmax(1) == targets).sum()
            total_accuracy = total_accuracy + accuracy

    print("测试集loss：{}".format(total_test_loss))
    print("测试集正确率: {}".format(total_accuracy / test_data_size))
    total_test_step = total_test_step + 1
    writer.add_scalar("test_loss", total_test_loss, total_test_step)
    writer.add_scalar("test_accuracy", total_accuracy / test_data_size, total_test_step)

    torch.save(tudui, "model/tudui_{}.pth".format(i))

writer.close()

模型正向推理

模型推理(测试、demo)，利用已经训练好的模型，然后给它提供输入。

import torch
import torchvision
from PIL import Image
from model import *

img_path = "test_imgs/1.jpg"
image = Image.open(img_path)
image = image.convert('RGB') # 变成3通道

transform = torchvision.transforms.Compose([torchvision.transforms.Resize((32, 32)),
                                            torchvision.transforms.ToTensor()])
image = transform(image)

# class Tudui(nn.Module):
#     def __init__(self):
#         super(Tudui, self).__init__()
#         self.model = nn.Sequential(
#             nn.Conv2d(3, 32, 5, 1, 2),
#             nn.MaxPool2d(2),
#             nn.Conv2d(32, 32, 5, 1, 2),
#             nn.MaxPool2d(2),
#             nn.Conv2d(32, 64, 5, 1, 2),
#             nn.MaxPool2d(2),
#             nn.Flatten(),
#             nn.Linear(1024, 64),
#             nn.Linear(64, 10)
#         )
# 
#     def forward(self, x):
#         x = self.model(x)
#         return x

model = torch.load("model/tudui_9.pth", map_location=torch.device('cpu'))
#如果权重是在GPU上训练的，现在要在CPU上做前向推理，那么就要加上这个参数map_location=torch.device('cpu')

image = torch.reshape(image, (1, 3, 32, 32)) #模型的输入必须有一个batchsize
model.eval() #进入推理状态，防止有BN或者Dropout推理出现问题
with torch.no_grad(): # 节约内存和性能
    output = model(image)
print(output)
print(output.argmax(1)) # 返回概率最大的类别序号
所有类别序号：
'airplane'=0，'automobile'=1，'brid'=2，'cat'=3，'deer'=4，
'dog'=5，'frog'=6，'horse'=7，'ship'=8，'truck'=9

开源项目

运行python文件除了在pycharm里运行以外，还可以通过指令在终端直接运行。小土堆最后一节课简单讲了

我的理解是前面的python train.py是让我的代码运行起来，后面的dataroot等等是一些参数传入进去，如果想省事简单一点，就修改代码里的参数，全部加一个default默认值，这样就不需要指定参数传入了，自动使用默认值。

你可能感兴趣的:(深度学习自学,python,学习)

情绪觉察日记第37天露露_e800
今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
铭刻于星（四十二）随风至
69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
UI学习——cell的复用和自定义cell Magnetic_h ui 学习
目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
理解Gunicorn：Python WSGI服务器的基石范范0825 ipython linux 运维
理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
学点心理知识，呵护孩子健康静候花开_7090
昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值）研学随笔 arcgis 经验分享
我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数广龙宇一起学Rust #Rust设计模式 rust 设计模式开发语言
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录 leetcode 算法职场和发展
重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
Python数据分析与可视化实战指南 William数据分析 python python 数据
在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
python os.environ 江湖偌大 python 深度学习
os.environ['TF_CPP_MIN_LOG_LEVEL']='0'#默认值，输出所有信息os.environ['TF_CPP_MIN_LOG_LEVEL']='1'#屏蔽通知信息（INFO）os.environ['TF_CPP_MIN_LOG_LEVEL']='2'#屏蔽通知信息和警告信息（INFO\WARNING）os.environ['TF_CPP_MIN_LOG_LEVEL']='
Python中os.environ基本介绍及使用方法鹤冲天Pro #Python python 服务器开发语言
文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
Pyecharts数据可视化大屏：打造沉浸式数据分析体验我的运维人生信息可视化数据分析数据挖掘运维开发技术共享
Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
2019-12-22-22:30 涓涓1016
今天是冬至，写下我的日更，是因为这两天的学习真的是能量的满满，让我看到了自己，未来另外一种可能性，也让我看到了这两年这几年的过程中我所接受那些痛苦的来源。一切的根源和痛苦都来自于人生，家庭，而你的原生家庭，你的爸爸和妈妈，是因为你这个灵魂在那一刻选择他们作为你的爸爸和妈妈来的，所以你得接受他，你得接纳他，他就是因为他的存在而给你的学习和成长带来这些痛苦，那其实是你必然要经历的这个过程，当你去接纳的
Python教程：一文了解使用Python处理XPath 旦莫 Python进阶 python 开发语言
目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 python os.environ
>>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
将cmd中命令输出保存为txt文本文件落难Coder Windows cmd window
最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
四章-32-点要素的聚合彩云飘过
本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
使用Faiss进行高效相似度搜索 llzwxh888 faiss python
在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
python是什么意思中文-在python中%是什么意思编程大乐趣
Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
GitHub上克隆项目 bigbig猩猩 github
从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Python python 开发语言大数据数据分析数据挖掘
大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
python八股文面试题分享及解析(1) Shawn________ python
#1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
人工智能时代，程序员如何保持核心竞争力？ jmoych 人工智能
随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
每日算法&面试题，大厂特训二十八天——第二十天（树）肥学 ⚡算法题⚡面试题每日精进 java 算法数据结构
目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
Python快速入门 —— 第三节：类与对象孤华暗香 Python快速入门 python 开发语言
第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
pyecharts——绘制柱形图折线图 2224070247 信息可视化 python java 数据可视化
一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
阶段总结反思轻争
马上就要进入10月份了，今天做一下前段时间的总结和反思。前段时间，日更、英语、健身、护肤坚持的比较好。阅读、书法坚持的不好。1.中间被迫停更半个多月，其余时间一直在坚持日更挑战。偶尔也有不想写的时候，就做一下摘抄。因为阅读（输入）没跟上来，所以写作（输出）质量有待进一步加强。2.英语做到了一周至少学习5天，每次不少于30分钟，但是小班课没有跟上更新速度，下一步要争取利用零碎时间补听小班课。3.减肥
TOMCAT在POST方法提交参数丢失问题 357029540 java tomcat jsp
摘自http://my.oschina.net/luckyi/blog/213209 昨天在解决一个BUG时发现一个奇怪的问题，一个AJAX提交数据在之前都是木有问题的，突然提交出错影响其他处理流程。检查时发现页面处理数据较多，起初以为是提交顺序不正确修改后发现不是由此问题引起。于是删除掉一部分数据进行提交，较少数据能够提交成功。恢复较多数据后跟踪提交FORM DATA ，发现数
在MyEclipse中增加JSP模板删除-2008-08-18 ljy325 jsp xml MyEclipse
在D:\Program Files\MyEclipse 6.0\myeclipse\eclipse\plugins\com.genuitec.eclipse.wizards_6.0.1.zmyeclipse601200710\templates\jsp 目录下找到Jsp.vtl，复制一份，重命名为jsp2.vtl,然后把里面的内容修改为自己想要的格式，保存。然后在 D:\Progr
JavaScript常用验证脚本总结 eksliang JavaScript javaScript表单验证
转载请出自出处：http://eksliang.iteye.com/blog/2098985 下面这些验证脚本，是我在这几年开发中的总结，今天把他放出来，也算是一种分享吧，现在在我的项目中也在用！包括日期验证、比较，非空验证、身份证验证、数值验证、Email验证、电话验证等等...! &nb
微软BI（4） 18289753290 微软BI SSIS
1） Q:查看ssis里面某个控件输出的结果： A MessageBox.Show(Dts.Variables["v_lastTimestamp"].Value.ToString()); 这是我们在包里面定义的变量 2):在关联目的端表的时候如果是一对多的关系，一定要选择唯一的那个键作为关联字段。 3) Q：ssis里面如果将多个数据源的数据插入目的端一
定时对大数据量的表进行分表对数据备份酷的飞上天空大数据量
工作中遇到数据库中一个表的数据量比较大，属于日志表。正常情况下是不会有查询操作的，但如果不进行分表数据太多，执行一条简单sql语句要等好几分钟。。分表工具：linux的shell + mysql自身提供的管理命令原理：使用一个和原表数据结构一样的表，替换原表。 linux shell内容如下： =======================开始
本质的描述与因材施教永夜-极光感想随笔
不管碰到什么事,我都下意识的想去探索本质,找寻一个最形象的描述方式。我坚信,世界上对一件事物的描述和解释,肯定有一种最形象,最贴近本质,最容易让人理解 &
很迷茫。。。随便小屋随笔
小弟我今年研一，也是从事的咱们现在最流行的专业（计算机）。本科三流学校，为了能有个更好的跳板，进入了考研大军，非常有幸能进入研究生的行业（具体学校就不说了，怕把学校的名誉给损了）。先说一下自身的条件，本科专业软件工程。主要学习就是软件开发，几乎和计算机没有什么区别。因为学校本身三流，也就是让老师带着学生学点东西，然后让学生毕业就行了。对专业性的东西了解的非常浅。就那学的语言来说
23种设计模式的意图和适用范围 aijuans 设计模式
Factory Method 意图定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method 使一个类的实例化延迟到其子类。　　适用性当一个类不知道它所必须创建的对象的类的时候。　　当一个类希望由它的子类来指定它所创建的对象的时候。　　当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。 Abstr
Java中的synchronized和volatile aoyouzi java volatile synchronized
说到Java的线程同步问题肯定要说到两个关键字synchronized和volatile。说到这两个关键字，又要说道JVM的内存模型。JVM里内存分为main memory和working memory。 Main memory是所有线程共享的，working memory则是线程的工作内存，它保存有部分main memory变量的拷贝，对这些变量的更新直接发生在working memo
js数组的操作和this关键字百合不是茶 js 数组操作 this关键字
js数组的操作; 一:数组的创建: 1、数组的创建 var array = new Array();　//创建一个数组 var array = new Array([size]);　//创建一个数组并指定长度，注意不是上限，是长度 var arrayObj = new Array([element0[, element1[, ...[, elementN]]]
别人的阿里面试感悟 bijian1013 面试分享工作感悟阿里面试
原文如下：http://greemranqq.iteye.com/blog/2007170 一直做企业系统，虽然也自己一直学习技术，但是感觉还是有所欠缺，准备花几个月的时间，把互联网的东西，以及一些基础更加的深入透析，结果这次比较意外，有点突然，下面分享一下感受吧！ &nb
淘宝的测试框架Itest Bill_chen spring maven 框架单元测试 JUnit
Itest测试框架是TaoBao测试部门开发的一套单元测试框架，以Junit4为核心，集合DbUnit、Unitils等主流测试框架，应该算是比较好用的了。近期项目中用了下，有关itest的具体使用如下： 1.在Maven中引入itest框架： <dependency> <groupId>com.taobao.test</groupId&g
【Java多线程二】多路条件解决生产者消费者问题 bit1129 java多线程
package com.tom; import java.util.LinkedList; import java.util.Queue; import java.util.concurrent.ThreadLocalRandom; import java.util.concurrent.locks.Condition; import java.util.concurrent.loc
汉字转拼音pinyin4j 白糖_ pinyin4j
以前在项目中遇到汉字转拼音的情况，于是在网上找到了pinyin4j这个工具包，非常有用，别的不说了，直接下代码： import java.util.HashSet; import java.util.Set; import net.sourceforge.pinyin4j.PinyinHelper; import net.sourceforge.pinyin
org.hibernate.TransactionException: JDBC begin failed解决方案 bozch ssh 数据库异常 DBCP
org.hibernate.TransactionException: JDBC begin failed: at org.hibernate.transaction.JDBCTransaction.begin(JDBCTransaction.java:68) at org.hibernate.impl.SessionImp
java-并查集（Disjoint-set）-将多个集合合并成没有交集的集合 bylijinnan java
import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Map; import java.ut
Java PrintWriter打印乱码 chenbowen00 java
一个小程序读写文件，发现PrintWriter输出后文件存在乱码，解决办法主要统一输入输出流编码格式。读文件： BufferedReader 从字符输入流中读取文本，缓冲各个字符，从而提供字符、数组和行的高效读取。可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。通常，Reader 所作的每个读取请求都会导致对基础字符或字节流进行相应的读取请求。因
[天气与气候]极端气候环境 comsci 环境
如果空间环境出现异变...外星文明并未出现,而只是用某种气象武器对地球的气候系统进行攻击,并挑唆地球国家间的战争,经过一段时间的准备...最大限度的削弱地球文明的整体力量,然后再进行入侵...... 那么地球上的国家应该做什么样的防备工作呢? &n
oracle order by与union一起使用的用法 daizj UNION oracle order by
当使用union操作时，排序语句必须放在最后面才正确，如下：只能在union的最后一个子查询中使用order by，而这个order by是针对整个unioning后的结果集的。So：如果unoin的几个子查询列名不同，如 Sql代码 select supplier_id, supplier_name from suppliers UNI
zeus持久层读写分离单元测试 deng520159 单元测试
本文是zeus读写分离单元测试,距离分库分表,只有一步了.上代码: 1.ZeusMasterSlaveTest.java package com.dengliang.zeus.webdemo.test; import java.util.ArrayList; import java.util.List; import org.junit.Assert; import org.j
Yii 截取字符串(UTF-8) 使用组件 dcj3sjt126com yii
1.将Helper.php放进protected\components文件夹下。 2.调用方法： Helper::truncate_utf8_string($content,20,false); //不显示省略号 Helper::truncate_utf8_string($content,20); //显示省略号 &n
安装memcache及php扩展 dcj3sjt126com PHP
安装memcache tar zxvf memcache-2.2.5.tgz cd memcache-2.2.5/ /usr/local/php/bin/phpize (?) ./configure --with-php-confi
JsonObject 处理日期 feifeilinlin521 java json JsonOjbect JsonArray JSONException
写这边文章的初衷就是遇到了json在转换日期格式出现了异常 net.sf.json.JSONException: java.lang.reflect.InvocationTargetException 原因是当你用Map接收数据库返回了java.sql.Date 日期的数据进行json转换出的问题话不多说直接上代码 &n
Ehcache（06）——监听器 234390216 监听器 listener ehcache
监听器 Ehcache中监听器有两种，监听CacheManager的CacheManagerEventListener和监听Cache的CacheEventListener。在Ehcache中，Listener是通过对应的监听器工厂来生产和发生作用的。下面我们将来介绍一下这两种类型的监听器。
activiti 自带设计器中chrome 34版本不能打开bug的解决 jackyrong Activiti
在acitivti modeler中，如果是chrome 34，则不能打开该设计器，其他浏览器可以，经证实为bug，参考 http://forums.activiti.org/content/activiti-modeler-doesnt-work-chrome-v34 修改为，找到 oryx.debug.js 在最头部增加 if (!Document.
微信收货地址共享接口-终极解决 laotu5i0 微信开发
最近要接入微信的收货地址共享接口，总是不成功，折腾了好几天，实在没办法网上搜到的帖子也是骂声一片。我把我碰到并解决问题的过程分享出来，希望能给微信的接口文档起到一个辅助作用，让后面进来的开发者能快速的接入，而不需要像我们一样苦逼的浪费好几天，甚至一周的青春。各种羞辱、谩骂的话就不说了，本人还算文明。如果你能搜到本贴，说明你已经碰到了各种 ed
关于人才 netkiller.github.com 工作面试招聘 netkiller 人才
关于人才每个月我都会接到许多猎头的电话，有些猎头比较专业，但绝大多数在我看来与猎头二字还是有很大差距的。与猎头接触多了，自然也了解了他们的工作，包括操作手法，总体上国内的猎头行业还处在初级阶段。总结就是“盲目推荐，以量取胜”。目前现状许多从事人力资源工作的人，根本不懂得怎么找人才。处在人才找不到企业，企业找不到人才的尴尬处境。企业招聘，通常是需要用人的部门提出招聘条件，由人
搭建 CentOS 6 服务器 - 目录 rensanning centos
(1) 安装CentOS ISO（desktop/minimal）、Cloud（AWS/阿里云）、Virtualization（VMWare、VirtualBox）详细内容 (2) Linux常用命令 cd、ls、rm、chmod...... 详细内容 (3) 初始环境设置用户管理、网络设置、安全设置...... 详细内容 (4) 常驻服务Daemon
【求助】mongoDB无法更新主键 toknowme mongodb
Query query = new Query(); query.addCriteria(new Criteria("_id").is(o.getId())); &n
jquery 页面滚动到底部自动加载插件集合 xp9802 jquery
很多社交网站都使用无限滚动的翻页技术来提高用户体验，当你页面滑到列表底部时候无需点击就自动加载更多的内容。下面为你推荐 10 个 jQuery 的无限滚动的插件： 1. jQuery ScrollPagination jQuery ScrollPagination plugin 是一个 jQuery 实现的支持无限滚动加载数据的插件。 2. jQuery Screw S

Pytorch学习

pytorch加载数据

Dataset （一般来说Dataset都自己写，然后继承自Dataset）

读取一张图片

读取一个文件夹里的所有图片的文件名，并放到一个列表

创建数据集（一般来说Dataset都自己写，然后继承自Dataset）

Dataloader （拆分成多个batch）（输出的tensor都是NCHW维度的）

DataLoader的使用

导入并实例化DataLoader

数据集中数据的读取

DataLoader中数据的读取

使用tensorboard可视化效果

改变shuffle

import os os库的用法

TensorBoard

writer.add_scalar( ) 遇到报错或者不知道参数可以点进去看看函数注释

writer.add_image( ) 遇到报错或者不知道参数可以点进去看看函数注释

torchvision

torchvision 中的 transforms

ToTensor

用PIL的Image来读取图片 读取出来是RGB格式，HWC格式, 0~255

用opencv的CV2的imread来读取图片 读取出来是BGR格式，HWC格式，0-255

用tensorboard来显示tensor格式的图片

Normalize输入图片归一化

Resize修改图片尺寸

Compose组合

RandomCrop 随机裁剪

总结

torchvision中的标准数据集Datasets

数据集下载

pycharm在线下载（下载速度较快时）

第三方下载

数据集的下载总结

CIFAR10的具体使用

数据集对象的显示（PIL型）

把数据集中的图片对象转换为tensor型

转换所需transform的定义

torchvision中现有网络模型的使用与修改

RGB格式和BGR格式之间的互相转换

PNG格式的图片需要去掉透明度通道

PNG格式图片4通道变RGB3通道方法

神经网络基本骨架 torch.nn.Module 官方文档

自定义搭建神经网络

神经网络之卷积操作

两种2d卷积的实现方式

torch.nn.functional.conv2d方法介绍

使用该方法需要引入的参数

关于对input和weight的shape详解

input的shape要求：

weight的shape要求：

torch.nn.Conv2d

最大池化（下采样）

torch.cat([feature_B,feature_D],1)

非线性激活

ReLu

Sigmoid

Batch-norm 官方文档

全连接层

Sequential的使用

Example

实战神经网络搭建以及sequential的使用

tensorboard SummaryWriter中的add_gragh可视化神经网络模型

损失函数

L1loss nn.L1Loss 绝对值误差

MSE损失函数（均方误差）MSELoss

使用交叉熵损失函数CrossEntropyLoss

优化器，梯度下降

模型的保存与加载

保存和加载checkpoint

保存checkpoints

加载checkpoints

完整的模型小项目

model.py

train.py （CPU训练）

张量.argmax(1)的用法，返回最大值对应的序号

tudui.train() # 让模型进入训练状态

tudui.eval() # 让模型进入验证评估状态

利用GPU来训练

方法一：

方法二：（常用，可以选择显卡）

用PIL的Image来读取图片读取出来是RGB格式，HWC格式, 0~255

用opencv的CV2的imread来读取图片读取出来是BGR格式，HWC格式，0-255