【python第三方库】tqdm——超详细解读

目录

什么是tqdm？

介绍

安装

使用方法

1.传入可迭代对象

使用trange

2.为进度条设置描述

3.tqdm的write方法

4.在深度学习中如何使用

下载训练集数据集

创建数据DataLoader

创建神经网络模型

模型训练和测试

训练深度学习模型

输出结果

---

什么是tqdm？

介绍

tqdm是一个快速、可扩展的Python进度条，可以在Python长循环中添加一个进度提示信息，用户只需要封装任意的迭代器tqdm(iterator)。它可以帮助我们监测程序运行的进度，估计运行的时长，甚至可以协助debug。对于在长时间运行的任务中显示进度很有用，因为它可以让用户知道任务正在进行。

安装

pip install tqdm

使用方法

1.传入可迭代对象

import time
from tqdm import *

for i in tqdm(range(1000)):
	time.sleep(0.01)    #进度条每0.01s前进一次，总时间为1000*0.01=10s

运行结果：

使用trange

trange(i)是 tqdm(range(i))的简单写法

import time
from tqdm import trange

for i in trange(1000):
	time.sleep(0.01)

运行结果：

2.为进度条设置描述

在for循环外部初始化tqdm，可以打印其他信息

import time
from tqdm import tqdm

pbar = tqdm(["a","b","c","d"])

for char in pbar:
    pbar.set_description("Processing %s" % char) # 设置描述
    time.sleep(1)  # 每个任务分配1s
    
# 结果如下
  0%|          | 0/4 [00:00<?, ?it/s]

Processing a:   0%|          | 0/4 [00:00<?, ?it/s]

Processing a:  25%|██▌       | 1/4 [00:01<00:03,  1.01s/it]

Processing b:  25%|██▌       | 1/4 [00:01<00:03,  1.01s/it]

Processing b:  50%|█████     | 2/4 [00:02<00:02,  1.01s/it]

Processing c:  50%|█████     | 2/4 [00:02<00:02,  1.01s/it]

Processing c:  75%|███████▌  | 3/4 [00:03<00:01,  1.01s/it]

Processing d:  75%|███████▌  | 3/4 [00:03<00:01,  1.01s/it]

Processing d: 100%|██████████| 4/4 [00:04<00:00,  1.01s/it]

3.tqdm的write方法

bar = trange(10)
for i in bar:
    time.sleep(0.1)
    if not (i % 3):
        tqdm.write("Done task %i" % i)
# 结果如下

Done task 0
0%|                                                                                           | 0/10 [00:10<?, ?it/s]
  0%|                                                                                           | 0/10 [00:00<?, ?it/s]
 10%|████████▎                                                                          | 1/10 [00:00<00:01,  8.77it/s]
 20%|████████████████▌                                                                  | 2/10 [00:00<00:00,  9.22it/s]
                                                                                                                       
                                                                                                                       

Done task 3


  0%|                                                                                           | 0/10 [00:10<?, ?it/s]
 30%|████████████████████████▉                                                          | 3/10 [00:00<00:01,  6.91it/s]
 40%|█████████████████████████████████▏                                                 | 4/10 [00:00<00:00,  9.17it/s]
 50%|█████████████████████████████████████████▌                                         | 5/10 [00:00<00:00,  9.28it/s]
                                                                                                                       
                                                                                                                       

Done task 6


  0%|                                                                                           | 0/10 [00:10<?, ?it/s]
 60%|█████████████████████████████████████████████████▊                                 | 6/10 [00:00<00:00,  7.97it/s]
 70%|██████████████████████████████████████████████████████████                         | 7/10 [00:00<00:00,  9.25it/s]
 80%|██████████████████████████████████████████████████████████████████▍                | 8/10 [00:00<00:00,  9.31it/s]
                                                                                                                       
                                                                                                                       

Done task 9


  0%|                                                                                           | 0/10 [00:11<?, ?it/s]
 90%|██████████████████████████████████████████████████████████████████████████▋        | 9/10 [00:01<00:00,  8.37it/s]
100%|██████████████████████████████████████████████████████████████████████████████████| 10/10 [00:01<00:00,  9.28it/s]

4.在深度学习中如何使用

下面是一段手写数字识别代码

下载训练集数据集

import torch.cuda
from torch import nn    #导入神经网络模块
from torch.utils.data import DataLoader  #数据包管理工具
from torchvision import datasets    #数据处理工具，专门用于图像处理的包
from torchvision.transforms import ToTensor  #数据转换，张量

'''下载训练集数据集(包含训练图片和标签)'''
#datasets.MNIST来加载MNIST数据集作为训练数据集。
#root='data'：指定数据集存储的根目录，可以根据需要进行更改。
#train=True：表示加载训练数据集
#download=True：如果数据集在指定路径中不存在，将自动从官方源下载并保存。
#transform=ToTensor()：指定数据转换操作，将图像数据转换为PyTorch中的Tensor张量格式。
training_data = datasets.MNIST(
    root='data',
    train=True,
    download=True,
    transform=ToTensor(),  #张量
)     #对于pythorch库能够识别的数据一般是tensor张量

test_data = datasets.MNIST(
    root='data',
    train=False,
    download=True,
    transform=ToTensor()
)

创建数据DataLoader

train_dataloader = DataLoader(training_data,batch_size=64)  #64张图片为一个包
test_dataloader = DataLoader(test_data,batch_size=64)
for X,Y in train_dataloader:  #X表示打包好的每一个数据包
    print(f'Shape of X[N,C,H,W]:{X.shape}')
    print(f'Shape of Y:{Y.shape}{Y.dtype}')
    break

'''判断当前设备是否支持GPU,其中mps是苹果m系列芯片的GPU'''
device = 'cuda' if torch.cuda.is_available() else 'mps' if torch.backends.mps.is_available() else 'cpu'
print(f'Using  {device}  device')

补充：

bath_size:将数据集分成多份，每一份为bath_size个数据
优点：可以减少内存的使用，提高训练的速度
64: 表示批次大小（batch size），即该张量包含了64个样本。
1: 表示通道数（channel），在这里是灰度图像，所以通道数为1。
28: 表示图像的高度（height），即每个图像有28个像素点的高度。
28: 表示图像的宽度（width），即每个图像有28个像素点的宽度。

创建神经网络模型

class NeuralNetwork(nn.Module):   #定义了一个名为 NeuralNetwork 的类，继承自 nn.Module 类，这是 PyTorch 中用于构建神经网络的基类。
    def __init__(self):
        super().__init__()      #调用父类（nn.Module）的构造函数，确保初始化神经网络的基类。
        self.flatten = nn.Flatten()     #创建一个展开对象 flatten，用于将输入的图像数据展平成一维向量
        self.hidden1 = nn.Linear(28*28,128)   #创建了第一个全连接层，输入大小为 28*28（即图像展开后的长度），输出大小为 128。
        self.hidden2 = nn.Linear(128,64)  #创建了第二个全连接层，输入大小为 128，输出大小为 64。
        self.hidden3 = nn.Linear(64,256)   # 创建了第三个全连接层，输入大小为 64，输出大小为 64。
        self.out = nn.Linear(256,10)       #创建了输出层，输入大小为 64，输出大小为 10，用于分类任务。
    def forward(self,x):     # 定义了模型的前向传播过程，指定了数据在网络中流动的路径和操作。
        x = self.flatten(x)   #将输入的图像数据 x 进行展平操作。
        x = self.hidden1(x)   #将展平后的数据 x 传入第一个全连接层 hidden1 进行线性变换和激活函数操作。
        x = torch.relu(x)   # 使用 ReLU (Rectified Linear Unit) 激活函数对 hidden1 层的输出进行非线性化
        x = self.hidden2(x)   # 将 hidden1 层的输出 x 传入第二个全连接层 hidden2 进行线性变换和激活函数操作。
        x = torch.sigmoid(x)
        x = self.hidden3(x)
        x = torch.relu(x)
        x = self.out(x)
        return x
model = NeuralNetwork().to(device)   # 创建一个神经网络模型的实例，将其移动到指定的设备上，

模型训练和测试

# 定义训练函数，输入参数包括数据加载器，模型，损失函数和优化器  
def train(dataloader,model,loss_fn,optimizer):  
    model.train()  # 设定模型为训练模式  
  
    batch_size_num = 1  # 初始化批次编号为1  
    for x,y in dataloader:  # 遍历数据加载器，每次提供一批数据  
        x,y = x.to(device),y.to(device)  # 将数据移到指定设备，例如GPU  
        pred = model.forward(x)  # 通过模型计算预测结果  
        loss = loss_fn(pred,y)  # 计算预测结果与实际结果的损失值  
        optimizer.zero_grad()  # 清空优化器的梯度缓存  
        loss.backward()  # 反向传播，计算梯度  
        optimizer.step()  # 使用优化器更新模型参数  
  
        loss_value = loss.item()  # 获取损失值的item，以便后续操作  
        # 打印损失值和批次编号  
        # print(f'loss:{loss_value:>7f}[num:{batch_size_num}]')  
        batch_size_num += 1  # 批次编号加1，以便在每个批次后更新批次编号。  
  
# 定义损失函数，这里使用交叉熵损失函数  
loss_fn = nn.CrossEntropyLoss()  
# 定义优化器，这里使用Adam优化器，学习率为0.0015  
optimizer = torch.optim.Adam(model.parameters(),lr=0.0015)  #可以用Adam 最好的模型  
# 调用训练函数进行模型训练  
train(train_dataloader,model,loss_fn,optimizer)

# 定义测试函数，输入参数包括数据加载器，模型和损失函数  
def test(dataloader,model,loss_fn):  
    size = len(dataloader.dataset)  # 获取测试集的数量  
    num_batches = len(dataloader)  # 获取数据加载器的批次数量  
    model.eval()  # 设定模型为评估模式，关闭dropout等影响结果的因素  
    test_loss,correct = 0,0  # 初始化测试损失和正确率  
    with torch.no_grad():  # 关闭梯度计算，节省内存，因为这里不需要反向传播计算梯度  
        for x,y in dataloader:  # 遍历数据加载器，每次提供一批数据用于测试  
            x,y = x.to(device),y.to(device)  # 将数据移到指定设备，例如GPU  
            pred = model.forward(x)  # 通过模型计算预测结果  
            test_loss += loss_fn(pred,y).item()  # 计算预测结果与实际结果的损失值并累加到总损失中  
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()  # 计算预测正确的数量并累加到总数中  
    test_loss /= num_batches  # 平均损失值，得到最终的测试损失  
    correct /= size  # 平均正确率，得到最终的测试正确率  
    return test_loss, correct  # 返回测试损失和正确率作为测试结果

训练深度学习模型

# 定义训练的轮数，即迭代次数  
epochs = 5  
  
# 导入进度条模块，tqdm可以让我们在训练过程中看到每个epoch的进度  
from tqdm import tqdm  
  
# 循环进行指定轮数的训练  
for epoch in range(epochs):    
    # for data,targets in tqdm(train_loadr,leave=False) # 进度显示在一行  
    for data,targets in tqdm(train_dataloader):  
        # 将数据移动到指定设备，如果可能的话。例如，如果你使用GPU进行计算，这将会把数据移到GPU上。    
        data = data.to(device=device)  
        targets = targets.to(device=device)  
  
        # 正向传播，模型对输入的数据进行计算，得到预测的结果  
        scores = model(data)  
  
        # 计算损失，这个损失是模型预测的结果与实际目标之间的差距  
        loss = loss_fn(scores,targets)  
  
        # 反向传播，根据损失计算出梯度，这个过程是在每个训练步骤中计算损失对模型参数的梯度  
        optimizer.zero_grad()  # 清空之前的梯度缓存  
        loss.backward()  # 计算梯度  
  
        # 使用优化器更新模型参数，这个过程是根据前面计算的梯度来更新模型参数，实现下降学习。  
        optimizer.step()  # 使用优化器更新模型参数

输出结果