Python语法与Pytorch基础

Python基础语法

函数

定义函数

• 定义函数

  def func():
  	print("Hello!")
  	
  
  func()

• 向函数传递信息

  def func(username):
      print("Hello, " + username.title() + "!")
      
  fun('tom')

实参与形参

• 关键字实参与默认值

  使用默认值时，在形参列表中需要先列出没有默认值的形参

  def describe(name，type='cat'):
  	print("My " + type.name + "'s name is '" + name.title() + ".")
      
  describe(name='tom')
  describe('tom')

返回值

• 返回简单值

  def get_name(first_name,last_name):
      full_name = first_name + '' + last_name
      return full_name.title()
  
  musician = get_formatted_name('jimi','hendrix')
  print(musician)

• 让实参变为可选的

  若参数可能没有传入，则将其默认值设为空

  def get_name(first_name,last_name,middle_name=''):
      if middle_name:
      	full_name = first_name + '' + middle_name + '' + last_name
      else:
          full_name = first_name + '' + last_name
      return full_name.title()
  
  musician = get_formatted_name('jimi','hendrix')
  musician = get_formatted_name('john','hooker','lee')

• 返回字典

  def build_person(first_name,last_name):
  	person = {'first':first_name, 'last':last_name}
      return person
  
  musician = build_person('jimi','hendrix')

传递列表

• 传递列表

  将列表传递给函数后，函数就能直接访问内容。

  def greet(names):
      for name in names:
          msg = "Hello " + name.title() + "!"
          print(msg)
          
  usernames = ['hannah','ty']
  greet(usernames)

• 在函数中修改列表

  将列表传递给函数后，函数对列表所做的修改都是永久性的。

  def func(unfinished,completed):
      while unfinished:
          current = unfinished.pop()
          completed.append(current)

• 禁止函数修改列表

  可以通过向函数传递列表副本，从而不改变列表。

  func(list_name[:])

传递任意数量的实参

• 传递任意数量的实参

  def make_pizza(*topping):
  	print("\nMaking a pizza needs:")
      for topping in toppings:
          print('- ' + topping)
          
  make_pizza('mushroom','green peppers','extra cheese')

• 结合使用位置实参和任意数量实参

  必须将接纳任意数量实参的形参放在最后，Python优先匹配位置实参和关键字实参，再将余下的实参收集到最后一个形参中。

  def make_pizza(size,*topping):
  	print("\nMaking a pizza needs:")
      for topping in toppings:
          print('- ' + topping)
          
  make_pizza(12,'mushroom','green peppers','extra cheese')

• 使用任意数量的关键字实参

  创建字典接收任意数量的键值对。

  def build_profile(first,last,**user_info):
      profile = {}
      profile['first_name'] = first
      profile['last_name'] = last
      for key,value in user_info.items():
          profile[key] = value
      return profile
  
  user_profile = build_profile('albert','einstein',location='princeton',field='physics')

模块、函数导入

# 导入整个模块
import module_name
module_name.func_name()

# 导入特定函数
from module_name import func_name
func_name()

# 使用as给函数指定别名
from module_name import func_name as fn
fn()

# 使用as给模块指定别名
import module_name as mn
mn.func_name()

# 导入模块中所有函数(不建议使用，因为当模块中函数存在重名时，会出现函数覆盖，可能引发错误)
from module_name import *
func_name()

类

类的创建与使用

• 类的创建

  class Dog():
  	def __init__(self,name,age):
  		self.name = name
  		self.age = age
  		
  	def sit(self):
  		print(self.name.title() + "is now sitting.")

方法__init__()在每次创建新实例时，Python都会自动运行它。其中形参self必不可少，且位于所有形参的最前面。Python在调用__init__()方法创建实例时，会自动传入实参self，让实例能访问类中的属性与方法。

• 根据类创建实例以及属性访问、方法调用

  my_dog = Dog('willie',6)
  my_dog.name
  my_dog.sit()

使用类和实例

• 通过方法修改属性的值

  class Car():
  	def __init__(self,model):
  		self.model = model
  		self.miles = 0
  	
  	def update(self,mileage)
  		self.miles = mileage
  		
  		
  # 调用
  my_car = Car('audi',2015)
  my_car.update(20)

继承

• 子类的方法__init__()

  定义子类时，必须在括号内指定父类的名称。super()函数将父类与子类关联起来，父类称为超类(superclass)。

  class Elecar(Car):
  	def __init__(self,model,year):
  		# 初始化父类属性
  		super().__init__(model,year)
  		self.battery_size = 70
  	
  my_tesla = Elecar('tesla',2016)

• 重写父类的方法

  可在子类中重写父类包含的方法，调用该方法时将忽略父类中的方法

• 将实例用作属性

  class Car():
  	pass
  	
  class Battery():
  	def __init__(self,battery_size=70):
  		self.battery_size = battery_size
  		
  	def describe(self):
  		print("This car has a " + str(self.battery_size) + "-kWh battery")
  		
  class Elecar(Car):
  	def __init__(self,model,year):
  		super().__init__(model,year)
  		self.battery = Battery()
  		
  		
  my_tesla = Elecar('tesla',2016)
  my_tesla.battery.describe()

命令行

argparse模块的使用

import argparse

# 创建解释器
parser = argparse.ArgmentParser(description="当前文件描述")

# 添加optional argument，默认是可选的，即可以不用填，有默认值
parser.add_argument("--a", type=int, default=5, help="operator A")

# 添加positional argument，默认是不可选的，即必须要填
parser.add_argument("a", type=int, help="xxx")

# 添加action argument，给定"store_true"后，命令行调用后为True，未调用为False
parser.add_argument("--verbose", action="store_true", default=0, help="Print Message")

# 解析命令行
args = parser.parse_args()

命令行的操作：

python test.py --help
python test.py --a=1 --verbose

Pytorch基础语法

Pytorch Documention:PyTorch documentation — PyTorch 2.0 documentation

深度学习基本概念

epoch与batch

• epoch - 指将整个训练数据集完整过一遍的次数。在每个epoch中，算法将使用训练数据集中的每个样本进行前向传播、计算损失、反向传播和参数更新。训练过程通常会通过多个epoch来不断迭代，以逐渐优化模型的性能。一个epoch的完成意味着模型已经使用了训练数据集中的所有样本进行了一次训练。
• batch - 指将训练数据集划分为小块进行训练的方式。由于训练数据集通常很大，无法一次性全部加载到内存中进行处理，所以将其划分为较小的批次进行训练。每个批次包含多个样本，通常是2的幂次方（如32、64、128等），以便更好地利用硬件加速器（如GPU）的并行计算能力。在每个batch中，模型将针对该批次中的样本进行前向传播、计算损失、反向传播和参数更新。

torchvision

torchvision概念

torchvision用于处理图像数据，主要包含以下四部分：

• torchvision - 提供各种经典网络、预训练好的模型，如Alex-Net、VGG、ResNet、Inception等。
• torchvison.datasets - 提供常用的数据集，设计上继承torch.utils.data.Dataset，主要包括：MNIST、CIFAR10/100、ImageNet、COCO等。
• torchvison.transforms - 提供常用的数据预处理操作，主要包括对tensor和PIL Image对象的操作。
• torchvision.utils - 工具类，如保存张量作为图像到磁盘，给一个小批量创建一个图像网格。

torchvision模型操作

模型加载

将参数pretrained(默认值为False)设为True可以加载预训练模型。

预训练模型的输入：

• RGB图像的mini-batch:(batch_size,3,H,W)，并且H和W不能低于224。
• 像素值必须在范围[0,1]间。

import torchvision.models as models

resnet18 = models.resnet18(pretrained=True)
vgg16 = models.vgg16(pretrained=True)

# 使用state_dict()来获取状态参数、缓存
pretrained_dict = vgg16.state_dict()

现有模型的修改

对预训练的模型可以进行结构的修改。如ResNet最后全连接层是分1000个类，可以修改为指定的类别数；或ResNet第一层卷积接收的通道是3， 我们可能输入图片的通道是4。

# 修改通道数
resnet.conv1 = nn.Conv2d(4, 64, kernel_size=7, stride=2, padding=3, bias=False)
# 这里的21即是分类
resnet.fc = nn.Linear(2048, 21)


from torchvision import models
from torch import nn
# 加载预训练好的模型，保存到 ~/.torch/models/ 下面
resnet34 = models.resnet34(pretrained=True, num_classes=1000)
# 默认是ImageNet上的1000分类，这里修改最后的全连接层为10分类问题
resnet34.fc = nn.Linear(512, 10)

网络模型的保存与读取

模型保存读取有两种方式，即保存模型结构与参数以及以字典形式保存模型参数。

# 保存方式1，模型结构+模型参数
torch.save(vgg16,"vgg16_method1.pth")

# 加载方式1
model = torch.load("vgg16_method1.pth")

# 保存方式2，模型参数
torch.save(vgg16.state_dict(),"vgg16_method2.pth")

# 加载方式2
model.load_state_dict(torch.model.load("vgg16_method2.pth"))

Dataset

Dataset概念

Dataset类的作用：提供一种方式去获取数据及其对应的真实标签。该类是一个抽象类，所有的数据集想要在数据与标签之间建立映射，都需要继承这个类，所有的子类都需要重写__getitem__方法，该方法根据索引值获取每一个数据并且获取其对应的标签，子类也可以重写__len__方法，返回数据集的大小

在Dataset类的子类中，有以下函数以实现部分功能：

• 获取每一个数据及其对应的标签，用于模型训练。
• 统计数据集中的数据数量，从而能确定迭代次数。

构建实例

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

class GetData(Dataset): # 继承Dataset类
    # 初始化为整个class提供全局变量，为后续方法提供一些量
    def __init__(self, root_dir, label_dir):
        self.root_dir = root_dir	# 获得根目录路径
        self.label_dir = label_dir	# 获得子目录路径
        self.path = os.path.join(self.root_dir, self.label_dir)	# 将路径拼接
        self.img_path_list = os.listdir(self.path)	# listdir方法会将路径下的所有文件名（包括后缀名）组成一个列表

    # 如果在类中定义了__getitem__()方法，那么他的实例对象就可以使用索引方法取值。
    def __getitem__(self, idx):
        img_name = self.img_path_list[idx]  # 只获取了文件名
        img_item_path = os.path.join(self.root_dir, self.label_dir, img_name) # 获取每个图片的路径位置
        # 读取图片
        img = Image.open(img_item_path)
        label = self.label_dir
        return img, label

    def __len__(self):
        return len(self.img_path)	# 返回数据数量

root_dir = "dataset/train"
ants_label_dir = "ants_image"
bees_label_dir = "bees_image"
ants_dataset = GetData(root_dir, ants_label_dir)
bees_dataset = GetData(root_dir, bees_label_dir)
img, lable = ants_dataset[0] # 返回一个元组，返回值就是__getitem__的返回值


# 获取整个训练集，就是对两个数据集进行了拼接
train_dataset = ants_dataset + bees_dataset

len1 = len(ants_dataset)  # 124
len2 = len(bees_dataset)  # 121
len = len(train_dataset) # 245

img1, label1 = train_dataset[123]  # 获取的是蚂蚁的最后一个
img2, label2 = train_dataset[124]  # 获取的是蜜蜂第一个

transforms

transforms概念

transforms主要用于对图像数据进行预处理。

transforms操作

transforms的操作可以通过torchvision.transforms.Compose整合在一起进行操作，具体包含的部分操作如下：

• ToTensor() - 把图片数据转换成张量并使其范围在[0,1]内。
• Normalization(mean,std) - 归一化。
• Resize(size) - 输入的PIL图像调整为指定的大小，参数可以为int或int元组。
• CenterCrop(size) - 将给定的PIL Image进行中心切割，得到指定大小的元组。

• RandomCrop(size,padding=0) - 随机中心点切割。

• RandomHorizontalFlip(size,interpolation=2) - 将给定的PIL Image随机切割，再进行Resize。

• RandomHorizontalFlip() - 随机水平翻转给定的PIL Image。
• RandomVerticalFlip() - 随机垂直翻转给定的PIL Image。
• ToPILImage() - 将Tensor或者numpy.ndarray转换为PIL Image。
• FiveCrop(size) - 将给定的PIL Image裁剪成4个角落区域和中心区域。
• Pad(padding,fill=0,padding_mode='constant') - 对PIL边缘进行填充。
• RandomAffline(degrees,translate=None,scale=None) - 保存中心不变的图片进行随机仿射变换。
• RandomApply(transforms,p=0.5) - 随机选取变换。

DataLoader

DataLoader

DataLoader是Pytorch中用来处理模型输入数据的一个工具类，组合了数据集(dataset)和采样器(sampler)，并在数据集上提供单线程或多线程的可迭代对象。DataLoader的部分概念如下所示：

• epoch - 所有训练样本输入到模型中称为一个epoch
• iteration - 一批样本输入到模型中，称为一个iteration
• batchsize - 批大小，决定一个epoch有多少个iteration，$\text{iteration}=\frac{\text{epoch}}{\text{batchsize}}$

DataLoader的参数如下：

• dataset (Dataset) – 决定从哪里读取数据集。

• batch_size (int, optional) – 每批训练的样本数(默认值为1)。

• shuffle (bool, optional) – 每一个epoch是否为乱序(默认为False)。

• sampler (Sampler or Iterable, optional) – sampler 是 PyTorch 中用于控制数据加载顺序的对象，它定义了在数据加载过程中如何对样本进行采样和排序的逻辑。因此选择sampler后shuffle参数不需要指定。常见的sampler的定义如下：

  • SequentialSampler：顺序采样器，按照数据集中样本的顺序逐个采样，即按照索引依次获取样本。适用于不需要对样本顺序进行改变的情况。
  • RandomSampler：随机采样器，随机地从数据集中采样样本，可以用于训练集的随机采样和验证集的无重复采样。
  • SubsetRandomSampler：子集随机采样器，从指定的样本子集中随机采样样本。适用于需要从数据集中选择特定样本子集进行训练的情况。
  • WeightedRandomSampler：加权随机采样器，根据每个样本的权重进行随机采样。适用于不平衡数据集（imbalanced dataset）中的样本采样，可以提高少数类样本的采样概率。
  • BatchSampler：批次采样器，将样本索引划分为多个批次，每个批次中的样本索引按照指定的规则进行采样。可以用来实现自定义的样本采样逻辑，如带有样本约束条件的采样。

• batch_sampler (Sampler or Iterable**, optional) – like sampler, but returns a batch of indices at a time. Mutually exclusive with batch_size, shuffle, sampler, and drop_last.

• num_workers (int, optional) – 是否采用多线程读取数据(默认为0)。num_workers 参数用于指定 DataLoader 中用于加载数据的子进程的数量。每个子进程都是一个独立的工作单元，负责从存储设备中读取数据、进行预处理并返回给主进程。增加 num_workers 的值可以提高数据加载的速度，特别是在数据加载和预处理过程比较耗时时，可以充分利用多核处理器的计算能力。

  需要注意的是，增加 num_workers 的值并不总是能够线性地提高数据加载的速度，因为子进程的数量过多也会导致进程间的通信和调度开销增加。在选择合适的 num_workers 值时，需要根据具体的硬件环境、数据集大小和数据加载的复杂度进行调优。

• collate_fn (Callable, optional) – 定义如何对每个样本的特征和标签进行处理，并将它们组合成一个批次（batch）的数据。

  collate_fn 函数会接收一个样本列表作为输入，并返回一个批次的数据作为输出。在 collate_fn 函数中，可以针对不同的数据类型（如图像、文本等）进行自定义的处理和转换操作，以适应模型的输入要求。

  通常，collate_fn 函数的输入是一个样本列表，每个样本是数据集中的一个元素。每个样本可以是一个元组或字典，其中包含了样本的特征和标签等信息。collate_fn 函数需要将样本列表中的特征和标签分别提取出来，并进行适当的处理和转换，最终返回一个包含批次数据的对象（如张量、列表等）。

• pin_memory (bool, optional) – If True, the data loader will copy Tensors into device/CUDA pinned memory before returning them. If your data elements are a custom type, or your collate_fn returns a batch that is a custom type, see the example below.

• drop_last (bool, optional) – 当样本数不能被batchsize整除时，如果为True，舍弃最后一批不完整的数据(默认为False)。

• timeout (numeric, optional) – if positive, the timeout value for collecting a batch from workers. Should always be non-negative. (default: 0)

• worker_init_fn (Callable, optional) – If not None, this will be called on each worker subprocess with the worker id (an int in [0, num_workers - 1]) as input, after seeding and before data loading. (default: None)

• generator (torch.Generator, optional) – If not None, this RNG will be used by RandomSampler to generate random indexes and multiprocessing to generate base_seed for workers. (default: None)

• prefetch_factor (int, optional, keyword-only arg) – Number of batches loaded in advance by each worker. 2 means there will be a total of 2 * num_workers batches prefetched across all workers. (default value depends on the set value for num_workers. If value of num_workers=0 default is None. Otherwise if value of num_workers>0 default is 2).

• persistent_workers (bool, optional) – If True, the data loader will not shutdown the worker processes after a dataset has been consumed once. This allows to maintain the workers Dataset instances alive. (default: False)

• pin_memory_device (str, optional) – the data loader will copy Tensors into device pinned memory before returning them if pin_memory is set to true.

DataLoader的使用

以数据集CIFAR10为例：

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

test_data = torchvision.datasets.CIFAR10("./CIFAR10",# 一般将数据集保存在同一工程文件下，使用相对路径读取
                                         train=False,# 选择测试集
                                         transform=torchvision.transforms.ToTensor())
test_loader = DataLoader(dataset=test_data, # 选择数据集
                         batch_size=4, # 设定批大小为4
                         shuffle=True, # 打乱数据集
                         num_workers=0, # 单进程读取数据
                         drop_last=False) # 保留最后一批数据

# 测试数据集中第一张图片及target
img, target = test_data[0]
print(img.shape)
print(target)
------------------------------
# 输出
torch.Size([3,32,32])	# 输出图片为3通道，大小为32*32
3					# 输出图片标签为3
------------------------------

# 在定义test_loader时，设置了batch_size=4，表示一次性从数据集中取出4个数据
for data in test_loader:
    imgs, targets = data
    print(imgs.shape)
    print(targets)
------------------------------
# 第一次循环输出
torch.Size([4,3,32,32])	# 4表示batch_size=4，后面三个参数表示输出图片为3通道，大小为32*32
tensor([0,4,3,8])		# 表示该批取出的图片的标签信息
------------------------------

模型搭建

nn.Module类中的常用函数

Conv2d

nn.Conv2d定义了一个卷积层，参数如下：

计算前后两个卷积层的kernel_size的公式：

$$\text{Output}=\frac{\text{Width}-\text{kernel\_size}+2*\text{Padding}}{\text{Stride}}+1$$

默认情况下，$\text{Padding}=0,\text{Stride=1}$，则有

$$\text{Output}=\text{Width}-\text{kernel\_size}+1$$

使用nn.Module类搭建模块与模型

在自定义网络时，需要继承nn.Module类，并重新实现构造__init__构造函数和forward这两个函数。其中forward函数是必须要重写的，它能实现各个层之间的连接关系。

一般的，在__init__中实现层的参数设定，在forward中实现层之间的连接关系。所有放在__init__里面的层都是这个模型的固有属性。

import torch

class MyNet(torch.nn.Module):
    def __init__(self):
        super(MyNet, self).__init__()  # 调用父类的构造函数
        self.conv1 = torch.nn.Conv2d(3, 32, 3, 1, 1)
        self.relu1=torch.nn.ReLU()
        self.max_pooling1=torch.nn.MaxPool2d(2,1)
 
        self.conv2 = torch.nn.Conv2d(3, 32, 3, 1, 1)
        self.relu2=torch.nn.ReLU()
        self.max_pooling2=torch.nn.MaxPool2d(2,1)
 
        self.dense1 = torch.nn.Linear(32 * 3 * 3, 128)
        self.dense2 = torch.nn.Linear(128, 10)
 
    def forward(self, x):
        x = self.conv1(x)
        x = self.relu1(x)
        x = self.max_pooling1(x)
        x = self.conv2(x)
        x = self.relu2(x)
        x = self.max_pooling2(x)
        x = self.dense1(x)
        x = self.dense2(x)
        return x
 
model = MyNet()

此外，还可以使用Sequential容器实现层之间的连接。

import torch

class MyNet(torch.nn.Module):
    def __init__(self):
        super(MyNet, self).__init__()  # 调用父类的构造函数
        self.conv1 = torch.nn.Conv2d(3, 32, 3, 1, 1)
        self.relu1=torch.nn.ReLU()
        self.max_pooling1=torch.nn.MaxPool2d(2,1)
 
        self.conv2 = torch.nn.Conv2d(3, 32, 3, 1, 1)
        self.relu2=torch.nn.ReLU()
        self.max_pooling2=torch.nn.MaxPool2d(2,1)
 
        self.dense1 = torch.nn.Linear(32 * 3 * 3, 128)
        self.dense2 = torch.nn.Linear(128, 10)
 		
        self.model = nn.Sequential(
        				nn.Conv2d(3, 32, 3, 1, 1),
            			nn.ReLU(),
            			nn.MaxPool2d(2,1),
            			nn.Conv2d(3, 32, 3, 1, 1),
            			nn.ReLU(),
            			nn.MaxPool2d(2,1),
            			nn.Linear(32 * 3 * 3, 128),
            			nn.Linear(128,10)
        			)
    def forward(self, x):
        return self.model(x)
 
model = MyNet()

模型训练

GPU训练，对模型、数据、损失函数使用CUDA方法

# 方式1，直接调用CUDA
model = Model()
model = model.cuda()

# 方式2，使用to方法选择CPU、CUDA进行训练
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
imgs, labels = data
imgs, labels = imgs.to(device), labels.to(device)

优化器

自定义层的实现

要实现一个自定义层，需要有以下步骤：

• 自定义一个类，该类继承nn.Module类，并且要实现基本函数：__init__构造函数和forward逻辑运算函数。
• 在__init__中实现层的参数定义
• 在forward中实现批数据的前向传播，只要在nn.Module的子类中定义了forward函数，backward函数会自动实现。但是如果自定义参数不可导，就需要手动实现backward函数。

自定义层实现这样一个功能：输入为两个$N$维向量$x_1$和$x_2$，参数为一个$N\times N$的矩阵$M$，输出为$\text{label}=\text{sigmoid}(x_1\times M\times x_2)$。代码如下：

import torch
import torch.nn as nn
import numpy as np
from torch.autograd import Variable
import math
from torch import optim
import torch.utils.data as Data
 
 
# 定义DisMult层
class DisMult(nn.Module):
	def __init__(self, emb_size):
 
		# nn.Module子类的函数必须在构造函数中执行父类的构造函数
		# 下式等价于nn.Module.__init__(self)
		super(DisMult, self).__init__()
		# 隐特征维度
		self.emb_size = emb_size
		# 关系特定的方阵
		# self.weights = nn.Parameter(torch.Tensor(emb_size, emb_size), requires_grad=requires_grad)
		self.weights = nn.Parameter(torch.Tensor(emb_size, emb_size))
		# 初始化参数
		self.reset_parameters()
 
	# 初始化参数
	def reset_parameters(self):
		stdv = 1. / math.sqrt(self.weights.size(0))
		self.weights.data.uniform_(-stdv, stdv)
 
	# 前向传播函数
	def forward(self, input1, input2):
		# 前向传播的逻辑
		result = torch.sum((input1 @ self.weights) * input2, dim=1)
 
		return torch.sigmoid(result)

backward的相关内容