深度学习之pytorch常用函数个人笔记

  • pytorch最基本的操作对象是Tensor(张量),它表示一个多维矩阵,类似于numpy的ndarrays,其可在GPU上使用可以加速计算,和numpy类型转换也非常方便

  • torch.nn为我们提供了成熟的层及一系列激活函数,可以像搭积木一样来非常快速的创建复杂的模型

  • 在pytorch中搭建模型的流程:定义类(该类要继承nn.Module),在类中实现两个方法:1.初始化函数:实现在搭建网络过程中所需要实现的网络层结构。2.在forward函数中定义正向传播的过程。

  • 创建一个层时,权重和偏置都会随机初始化

  • 经卷积后的矩阵尺寸大小计算公式为:N=(W-F+2P)/S+1

  • torch种Tensor的通道顺序:[batch,channel,height,width]

  • 复习一下CNN:1.卷积核的 层数 和 输入通道数 一致,卷积核的 个数 和 输出通道数 一致(卷积过程:每层卷积核分别和对应层的feature map进行卷积,同一通道相加)。2.池化层的目的:缩减参数以提高计算速度,提高feature map的鲁棒性(实验得知)

  • 最大池化下采样后高度和宽度就变成了原来的一半(池化层只会改变高和宽,不会改变feature map的深度)

  • 在模型测试的时候可以自定义一个随机的输入x作为输入图像,如:

> input = torch.rand([32,3,32,32]) //batch=32 channel=3````

> model = LeNet() //实例化模型

> output = model(input)

  • super函数是继承父类的某个函数(理解为先执行父类的某个函数,再执行下面的语句)

  • 定义卷积层的函数为nn.Conv2d,参数顺序为:深度、卷积核的个数、卷积核的大小,步距默认为1

  • 定义下采样层的函数为nn.MaxPool2d,参数顺序为:卷积核大小,步距,padding

  • 定义全连接层的函数为nn.Linear,全连接层的输入是一个一维的向量,因此需要将得到的特征矩阵给展平成一维向量

  • 最后一个全连接层的输出是需要根据自己的分类类别进行更改的

  • x = F.relu(self.conv1(x)) 的意思是输入经过第一个卷积层再经过relu激活函数

  • view函数起到的作用是reshape,view的参数的是改变后的shape,-1代表第一个维度(batch)是自动推理的,第二个参数就是展平

  • 一个最简单的模型LeNet网络的model.py文件代码如下:

class LeNet(nn.Module):
    def __init__(self):
        super(LeNet, self).__init__()
        self.conv1 = nn.Conv2d(3, 16, 5)
        self.pool1 = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(16, 32, 5)
        self.pool2 = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(32*5*5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):#x代表输入的数据,就是一个tensor
        x = F.relu(self.conv1(x))    # input(3, 32, 32) output(16, 28, 28)  #将输入经过第一个卷积层再经过relu激活函数
        x = self.pool1(x)            # output(16, 14, 14)
        x = F.relu(self.conv2(x))    # output(32, 10, 10)
        x = self.pool2(x)            # output(32, 5, 5)
        x = x.view(-1, 32*5*5)       # output(32*5*5) view函数起到的作用是reshape,view的参数的是改变后的shape,-1代表第一个维度(batch)是自动推理的,第二个参数就是展平
        x = F.relu(self.fc1(x))      # output(120)
        x = F.relu(self.fc2(x))      # output(84)
        x = self.fc3(x)              # output(10) 没有接softmax的原因:理论上确实需要,但实际训练网络计算交叉熵时在其内部已经实现了一个更加高效的sofymax方法,所以不需要添加了(内置了)
        return x
  • torchvision是pytorch的一个图形库,它服务于PyTorch深度学习框架的,主要用来构建计算机视觉模型。torchvision.transforms主要是用于常见的一些图形变换。以下是torchvision的构成:

> 1.torchvision.datasets: 一些加载数据的函数及常用的数据集接口;

> 2.torchvision.models: 包含常用的模型结构(含预训练模型),例如AlexNet、VGG、ResNet等;

> 3.torchvision.transforms: 常用的图片变换,例如裁剪、旋转等;

> 4.torchvision.utils: 其他的一些有用的方法。

> 其中的torchvision.transforms.Compose()类。这个类的主要作用是串联多个图片变换的操作,Compose里面的参数实际上就是个列表,而这个列表里面的元素就是你想要执行的transform操作

> transforms.Normalize:对数据按通道进行标准化,即先减均值,再除以标准差

> transforms.ToTensor:将PIL Image或者 ndarray 转换为tensor,并且归一化至[0-1]。注意:归一化至[0-1]是直接除以255,若自己的ndarray数据尺度有变化,则需要自行修改。

> transforms.Resize:缩放

> transforms.RandomResizedCrop:将给定图像随机裁剪为不同的大小和宽高比,然后缩放所裁剪得到的图像为制定的大小

> transforms.Grayscale:转为灰度图

> transforms.RandomHorizontalFlip:以给定的概率随机水平旋转给定的PIL的图像,默认为0.5;

> 关于:optimizer.zero_grad()---->将历史损失梯度清零 每计算一个batch就要调用一次optimizer.zero_grad(),如果不清除历史梯度,就会对计算的历史梯度进行累加通常,设置batchsize是根据硬件设备的条件,一般该值越大,训练的效果就会越好。但通常硬件设备由于内存等不足不可能用一个很大的batch去训练,就可以通过optimizer.zero_grad(),变相的实现一个很大的batch进行训练,也就是通过计算多个小的batch损失梯度,将其等效为一个大的batch的损失梯度进行反向传播

  • 通用的训练分类网络脚本 ,附带注释:

net = LeNet()
net.to(device)
loss_function = nn.CrossEntropyLoss()#定义损失函数,其内部已经内置了softmax
optimizer = optim.Adam(net.parameters(), lr=0.001)#定义优化器,参数一:所需要训练的参数(这里把网络中所有可训练的参数都进行训练);参数二:学习率
for epoch in range(5):
    running_loss = 0.0#用来累加在训练过程中的损失
    for step, data in enumerate(train_loader):#遍历训练集样本 enumerate() 函数返回数据和数据下标
        inputs, labels = data#将数据分离成输入的图像和其所对应的标签
        optimizer.zero_grad()
        outputs = net(inputs)#正向传播得到输出
        loss = loss_function(outputs, labels)#用定义的函数计算损失,参数为:网络预测的值,输入图片对应的真是标签
        loss.backward()#将loss进行反向传播
        optimizer.step()#进行参数的更新
        running_loss += loss.item()#每计算一个loss就将其追加到变量中
        if step % 500 == 499:#每隔五百步打印一次数据
            with torch.no_grad():#在接下来的计算过程中,都不会去计算每个节点的损失梯度,如果不用的话即使在测试集中也会计算损失梯度,会消耗更多的内存资源
                outputs = net(val_image)#验证集正向传播
                predict_y = torch.max(outputs, dim=1)[1]#寻找输出最大可能的标签类别 dim=1是在第一个维度寻找,因为第零个维度为batch
                #[1]代表只需要知道索引即可,不需要知道索引对应的最大值是多少
                #predict_y == val_label为将预测的标签类别和真实的标签类别进行比较,相同时返回true,不相同返回flase
                #sum()函数可以判断本次预测过程对了多少个样本
                #item()可以让tensor变量变成数值
                #最后再除以测试样本的数目,就得到了测试的准确率
                accuracy = (predict_y == val_label).sum().item() / val_label.size(0)
                print('[%d, %5d] train_loss: %.3f  test_accuracy: %.3f' %#打印一下训练过程中的信息:训练迭代轮数, 每一轮的多少步,五百步平均的训练损失(误差),测试样本的准确率
                      (epoch + 1, step + 1, running_loss / 500, accuracy))
                running_loss = 0.0
print('Finished Training')
save_path = './·····.pth'
torch.save(net.state_dict(), save_path)#将网络的所有参数进行保存
  • 通用的分类网络预测脚本,附带注释:

transform = transforms.Compose(
    [transforms.Resize((32, 32)),
     transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
net = LeNet()
net.load_state_dict(torch.load('Lenet.pth'))#载入保存的权重文件
im = Image.open('1.jpg')
im = transform(im)  # [C, H, W]                                                                                      
im = torch.unsqueeze(im, dim=0)  # [N, C, H, W] 转化成Tensor的格式,加一个维度
with torch.no_grad():#意思是不需要求损失梯度
    outputs = net(im)
    predict = torch.max(outputs, dim=1)[1].data.numpy()#找到输入图像对应的类别索引
print(classes[int(predict)])
  • nn.Sequential函数能够将一系列的层结构进行打包,组合成一个新的层结构,常用在模型初始化定义层结构中,相对于使用 self.conv1 = nn.Conv2d(3, 16, 5)语句会非常的高效方便。

  • nn.ReLU(inplace=True)语句中,inplace参数可以理解为是pytorch通过增加计算量,降低内存使用的一种方法,通过这个方法,可以在内存中载入更大的一个模型。

  • nn.Sequential结构示例:

class AlexNet(nn.Module):
    def __init__(self, num_classes=1000, init_weights=False):
        super(AlexNet, self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 48, kernel_size=11, stride=4, padding=2),  # input[3, 224, 224]  output[48, 55, 55]
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),                  # output[48, 27, 27]
            nn.Conv2d(48, 128, kernel_size=5, padding=2),           # output[128, 27, 27]
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),                  # output[128, 13, 13]
            nn.Conv2d(128, 192, kernel_size=3, padding=1),          # output[192, 13, 13]
            nn.ReLU(inplace=True),
            nn.Conv2d(192, 192, kernel_size=3, padding=1),          # output[192, 13, 13]
            nn.ReLU(inplace=True),
            nn.Conv2d(192, 128, kernel_size=3, padding=1),          # output[128, 13, 13]
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),                  # output[128, 6, 6]
        )
        self.classifier = nn.Sequential(
            nn.Dropout(p=0.5),
            nn.Linear(128 * 6 * 6, 2048),
            nn.ReLU(inplace=True),
            nn.Dropout(p=0.5),
            nn.Linear(2048, 2048),
            nn.ReLU(inplace=True),
            nn.Linear(2048, num_classes),
        )
        if init_weights:
            self._initialize_weights()

    def forward(self, x):
        x = self.features(x)
        x = torch.flatten(x, start_dim=1)
        x = self.classifier(x)
        return x

    def _initialize_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):#下面有介绍
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')#下面有介绍
                if m.bias is not None:
                    nn.init.constant_(m.bias, 0)
            elif isinstance(m, nn.Linear):
                nn.init.normal_(m.weight, 0, 0.01)
                nn.init.constant_(m.bias, 0)
  • self.modules()函数会返回网络中所有的层结构, isinstance()函数可以判断数据的类型

  • nn.init.kaiming_normal_和 nn.init.normal_都是初始化变量函数,后者是正态分布的方法给参数进行赋值,其实这些语句并不需要,写出来只是为了让大家学习,在torch中,会自动对卷积和全连接层是自动使用凯明方法初始化权重。

  • 通过Dropout方法能够使全连接层的节点按一定比例进行失活,防止过拟合。其中的Dropout一般放在全连接层与全连接层之间,nn.Dropout(p=0.5)中的p代表随机失活的神经元的比例,默认是0.5。

  • nn.Linear(2048, 2048)定义全连接层的函数分别为输入神经元个数和输出神经元个数。

  • torch.flatten方法可以从自定义的维度开始展平变量

  • device = torch.device(“cuda:0” if torch.cuda.is_available() else “cpu”)语句: torch.device可以指定训练过程中所使用的设备,括号里面语法的意思是如果当前设备有可使用的GPU,那么就使用第一块GPU,如果没有则使用CPU。

  • 解释一下os.path.abspath(os.path.join(os.getcwd(), “… /…”)) :os.getcwd()是获取当前文件所在的目录,…/…为返回上上层目录,os.path.join是拼接两个路径

  • torchvision.datasets.ImageFolder是pytorch加载数据集的函数,其默认你的数据集已经按类分好了文件夹,同一个文件夹下是同一类的照片。第二个参数是数据预处理,常用的语句如下:

data_transform = {
    "train": transforms.Compose([transforms.RandomResizedCrop(224),
                                 transforms.RandomHorizontalFlip(),
                                 transforms.ToTensor(),
                                 transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]),
    "val": transforms.Compose([transforms.Resize((224, 224)), 
                               transforms.ToTensor(),
                               transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])}

data_root = os.path.abspath(os.path.join(os.getcwd(), "../.."))  
image_path = data_root + "/data_set/flower_data/"  
train_dataset = datasets.ImageFolder(root=image_path + "/train",
                                     transform=data_transform["train"])
train_num = len(train_dataset)#打印训练集有多少张图片
flower_list = train_dataset.class_to_idx#返回一个字典,及分类的名称和其对应的索引
  • cla_dict = dict((val, key) for key, val in flower_list.items()) :该语句可以将上面的字典反转,方便后续操作

  • json_str = json.dumps(cla_dict, indent=4) :该语句可将cla_dict字典编码成json格式

  • torch.utils.data.DataLoader 可以将刚加载好的数据集以及所设定的batchsize和shuffle就可以随机的从样本中获取一批一批的数据,其参数num_workers(采用的线程个数)在window下只能设置为0,在linux下可设置为非零值(开启的线程数),以便加快数据的生成速度,从而提高训练的速度。注:shuffle=True是先打乱所有数据,再取batch。

  • net.train()和net.eval()会管理dropout和BN层,在训练过程中调用net.train()就会启用,在验证中调用net.eval()就会关闭dropout和BN

  • 在一些Python的工程项目中,我们会看到函数参数中会有冒号,有的函数后面会跟着一个箭头,如下所示:def make_features(cfg: list):,值得注意的是,类型建议符并非强制规定和检查,也就是说即使传入的实际参数与建议参数不符,也不会报错,只是方便共同开发时程序员理解函数的输入与输出。

  • 可变参数传入,在列表或者元组前面加一个*可以把list或tuple的元素变成可变参数传入函数中,如这样:nn.Sequential(*layers),当然函数的定义肯定是如下形式:def 函数名(*a):。

  • 可变参数允许你传入0个或任意个参数,这些可变参数在函数调用时自动组装为一个tuple,而关键字参数允许你传入0个或任意个含参数名的参数,这些关键字参数在函数内部自动组装为一个dict。和可变参数类似,也可以先组装出一个dict,也可以调用简化的写法:**extra。**extra表示把extra这个dict的所有key-value用关键字参数传入到函数的参数,函数参数将获得一个dict,如下所示:

net = vgg(model_name=model_name, num_classes=5, init_weights=True)
def vgg(model_name="vgg16", **kwargs):
	model = VGG(make_features(cfg), **kwargs)
	return model
  • torch.cat是将两个张量(tensor)按指定维度拼接在一起

  • nn.AdaptiveAvgPool2d是自适应平均池化函数,参数为输出特征矩阵的高和宽,无论输入特征矩阵的高和宽是什么样的大小,都能够指定的高和宽。

你可能感兴趣的:(深度学习+torch专栏,python,pytorch,图像处理,深度学习)