PyTorch学习笔记——PyTorch模块和基础实战

文章目录

  • 前言
  • 一、pytorch基础知识
    • 2.1、张量
    • 代码演示
    • 2.2自动求导
      • PyTorch实现模拟训练
      • Tensor数据结构是实现自动求导的基础
      • 自动求导——数学基础
    • 代码展示
    • 2.3并行计算
      • 怎么并行?——CUDA
      • 并行计算的方法
    • 2.3并行计算——扩展
  • 二、Pytorch模块和基础实践
    • 2.1神经网络学习机制
    • 2.2深度学习在实现上的特殊性
    • 2.3PyTorch深度学习模块
      • 2.3.1 基本配置
      • 2.3.2 数据读入
      • 2.3.3 模型构建
      • 2.3.4 损失函数
      • 2.3.5 优化器
      • 2.3.6 训练与评估
  • 三、总结


前言

提示:pytorch学习记录:

例如:随着人工智能的不断发展,机器学习这门技术也越来越重要,很多人都开启了学习机器学习,本文就介绍了机器学习的基础内容。


提示:以下是本篇文章正文内容,下面案例可供参考

一、pytorch基础知识

2.1、张量

Scalar
Vector
Matrix
Tensor
张量Tensor可以是高维的,pytorch运算的基本单元,基础数据定义和运算,在pytorch中支持GPU运算,自动求导等操作。

代码演示

import torch
# tensor(data, *, dtype=None, device=None, requires_grad=False, pin_mimory=False)
?torch.tesnor

# 创建tensor,用dtype指定类型,注意类型要匹配
a = torch.tensor(1.0, dtype=torch.float)
b = torch.tensor(1, dtype=torch.long)
c = torch.tensor(1.0, dtype=torch.int8)

# 使用指定类型函数随机初始化指定大小的tensor
d = torch.FloatTensor(2, 3)
e = torch.IntTensor(2) # 默认是int32
f = torch.IntTensor([1, 2, 3, 4])  # 对于python已经定义号的数据结构可以直接转换

# tensor和numpy array 之间的相互转换

g = np.array([[1, 2, 3], [4, 5, 6]])
h = torch.tensor(g)
i = h.numpy()

# 常见的构造Tensor的函数

k = torch.rand(1, 2)  # 随机
l = torch.ones(2, 3)
m = torch.zeros(2, 3)
n = torch.arrange(0, 10, 2)  # [0, 10)

# 查看tensor的维度信息
k.shape
k.size()

# tensor的运算

o = torch.add(k, l)

# tensor的索引方式
o[:, 1]
o[0, :]

# 改变tensor形状的神器:view

o.view(3, 2)
o.view(-1, 2)  # -1自动推导出大小

# tensor的广播机制(使用时需要注意这个特性)
p = torch.arange(1, 3).view(1, 2)
q = torch.arange(1, 4).view(3, 1)
p + q   # 如果未对齐,将自动对齐
# 1 x 2
# 3 x 1
# 3 x 2

# 扩展&压缩tensor的维度: squeeze unsqueeze
o  # 2 x 3
r = o.unsqueeze(1)  # 在第二个维度扩展
r  # 2 x 1 x 3
# 只有维度等于1才能压缩

2.2自动求导

PyTorch实现模拟训练

  • 输入数据,正向传播
  • 同时创建计算图
  • 计算损失函数
  • 损失函数反向传播
  • 更新模型参数

Tensor数据结构是实现自动求导的基础

自动求导——数学基础

  • 多元函数求导的雅可比矩阵
  • 复合函数求导的链式法则
    若h(x) = f(g(x)),则d(h)/dx = d(f(x))/d(g(x)) * d(g(x))/dx

代码展示

### 第二部分:自动求导示例
这里将通过一个简单的函数y = x1 + 2 * x2

import torch

x1 = torch.tensor(1.0, requires_grad=True)
x2 = torch.tensor(2.0, requires_grad=True)
y = x1 + 2 * x2

y

# 首先查看每个变量是否需要求导
print(x1.requires_grad)
print(x2.requires_grad)
print(y.requires_grad)

# 查看每个变量导数大小,此时因为还没有反向传播,因此导数不存在
print(x1.grad.data)
print(x2.grad.data)
print(y.grad.data)

x1

## 反向传播后看导数的大小
y = x1 + 2 * x2
y.backward()
print(x1.grad.data)
print(x2.grad.data)

# 导数是会累积的,重复运行相同命令,grad会增加
y = x1 + 2 * x2
y.backward()
print(x1.grad.data)
print(x2.grad.data)

# 所以每次计算前需要清除当前导数值避免累积,这一功能可以通过pytorch的optimizer实现,后续会将

# 尝试,如果不允许求导,会出现什么情况?
x1 = torch.tensor(1.0, requires_grad=False)
x2 = torch.tensor(2.0, requires_grad=False)
y = x1 + 2 * x2
y.backward()

2.3并行计算

  • 能计算——显存占用
  • 算得快——计算速度
  • 效果好——大batch提升训练效果

怎么并行?——CUDA

  • 在Pytorch中,CUDA更多的指用GPU进行计算(而不是CPU)

并行计算的方法

  • 网络结构分布到不同的设备中
  • 同一层任务分布到不同数据中
  • 不同数据分布到不同的设备中

2.3并行计算——扩展

  • cuDNN与CUDA
    • cuDNN是用于深度神经网络的加速库
    • cuDNN基于CUDA完成深度学习的加速

二、Pytorch模块和基础实践

2.1神经网络学习机制

  • 数据预处理
  • 模型设计
  • 损失函数和优化方案设计
  • 前向传播
  • 反向传播
  • 更新参数

2.2深度学习在实现上的特殊性

  • 样本量大,通常需要分批加载
  • 逐层、模块化搭建网络(卷积层、全连接层、lstm等
  • 多样化的损失函数和优化器设计*
  • GPU的使用
  • 以上各个模块之间的配合

2.3PyTorch深度学习模块

  • 将PyTorch完成深度学习的步骤拆解为几个主要模块
  • 实际使用根据自身需求修改对应模块即可
  • 深度学习 ——>搭积木

2.3.1 基本配置

  • 导入必要的packages
    • os, numpy, pandas, torch, torch.nn, torch.optim, torch.utils.data
  • 配置训练过程的超参数
    • batch size, learning rate, max_epochs, num_workers
  • 配置训练用的硬件设备
    • CPU or GPU, which GPU(s)
  • 代码演示

2.3.2 数据读入

  • 如何读取格式不定的本地数据:Dataset
    • init, getitem, len
  • 如何将数据加载以供模型输入:DataLoader
    • batch_size, num_workers, shuffle, drop_last, pin_memory
  • 代码演示
## 读取方式二:使用csv格式的数据,自行构建Dataset类
class FMDataset(Dataset):
    def __init__(self, df, transform=None):
        self.df = df
        self.transform = transform
        self.images = df.iloc[:, 1:].values.astype(np.uint8)
        self.labels = df.iloc[:, 0].values
    
    def __len__(self):
        return len(self.images)
    
    def __getitem__(self, idx):
        image = self.images[idx].reshape(28, 28, 1)
        label = int(self.labels[idx])
        if self.transform is not None:
            image = self.transform(image)
        else:
            image = torch.tensor(image/255, dtype=torch.float)
        label = torch.tensor(label, dtype=torch.long)
        return image, label

train_df = pd.read_csv("D:/人工智能/pytorch/数据集/fashion-mnist_train.csv")
test_df = pd.read_csv("D:/人工智能/pytorch/数据集/fashion-mnist_test.csv")
train_data = FMDataset(train_df, data_transform)
test_data = FMDataset(test_df, data_transform)  
train_loader = DataLoader(train_data, batch_size=batch_size, shuffle=True, num_workers=num_workers, drop_last=True)  # batch_size每一批读入数据,shuffle打乱数据,num_workers读的时候用多少线程读,drop_last是否丢弃最后不满一个batch的数据, pin_memory锁用内存,运行更快,占用内存
test_loader = DataLoader(test_data, batch_size=batch_size, shuffle=False, num_workers=num_workers)

2.3.3 模型构建

  • 神经网络的构造:基于nn.Module

    • init, forward
  • 神经网络是通过“层定义 + 层顺序”的方式构建起来的

  • 神经网络常见层

    • nn.Conv2d, nn.MaxPool2d, nn.Linear,nn.ReLU,…
  • 代码演示

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(1, 32, 5),
            nn.ReLU(),
            nn.MaxPool2d(2, stride=2),
            nn.Dropout(0.3),
            nn.Conv2d(32, 64, 5),
            nn.ReLU(),
            nn.MaxPool2d(2, stride=2),
            nn.Dropout(0.3)
        )
        self.fc = nn.Sequential(
        nn.Linear(64*4*4, 512),
        nn.ReLU(),
        nn.Linear(512, 10))
        
    def forward(self, x):
        x = self.conv(x)
        x = x.view(-1, 64*4*4)
        x = self.fc(x)
        # x = nn.functional.normalize(x)
        return x
    
    
model = Net()
model = model.cuda()

2.3.4 损失函数

  • torch.nn提供了多种预定义的损失函数
  • 可以自己定义损失函数
  • 根据实际需求选用对应的损失函数
  • 损失函数常用操作
    • backward()
  • 代码演示
criterion = nn.CrossEntropyLoss()
# criterion = nn.CrossEntropyLoss(weight=[1, 1, 1, 1, 1, 1, 1, 1, 1, 1])

2.3.5 优化器

  • torch.optim提供了多种预定义的优化器
  • 可以自己定义优化器
  • 根据实际需求选用对应的优化器
  • 优化器常用操作:
    • step(), zero_grad(), load_state_dict(),…
  • 代码演示

2.3.6 训练与评估

  • 模型状态设置

    • model.train(), model.eval()
  • 训练流程:读取、转换、梯度清零、输入、计算损失、反向传播、参数更新

  • 验证流程:读取、转换、输入、计算损失、计算指标

  • 代码演示

def train(epoch):
    model.train()
    train_loss = 0
    for data, label in train_loader:
        data, label = data.cuda(), label.cuda()
        optimizer.zero_grad()  # 梯度清零
        output = model(data)
        loss = criterion(output, label)
        loss.backward()
        optimizer.step()
        train_loss += loss.item()*data.size(0)
    train_loss = train_loss/len(train_loader.dataset)
    print("Epoch:{} \tTraining Loss:{:.6f}".format(epoch, train_loss))

def val(epoch):
    model.eval()
    val_loss = 0
    gt_labels = []
    pred_labels = []
    with torch.no_grad():
        for data, label in test_loader:
            data, label = data.cuda(), label.cuda()
            output = model(data)
            preds = torch.argmax(output, 1)
            gt_labels.append(label.cpu().data.numpy())
            pred_labels.append(preds.cpu().data.numpy())
            loss = criterion(output, label)
            val_loss += loss.item()*data.size(0)
    val_loss = val_loss/len(test_loader.dataset)
    gt_labels, pred_labels = np.concatenate(gt_labels), np.concatenate(pred_labels)
    acc = np.sum(gt_labels==pred_labels)/len(pred_labels)
    print('Epoch:{} \tValidation Loss:{:.6f}, Accuracy:{:.6f}'.format(epoch, val_loss, acc))

三、总结

提示:这里对文章进行总结:
例如:以上就是今天要讲的内容,本文仅仅简单介绍了pytorch的使用,而pytorch提供了能使我们快速便捷地训练模型和优化模型的函数和方法。

你可能感兴趣的:(笔记,人工智能,pytorch,学习,深度学习)