Pytorch入门学习笔记（五）

最新推荐文章于 2024-09-12 08:54:42 发布
最新推荐文章于 2024-09-12 08:54:42 发布
阅读量568 收藏 1
点赞数 22
文章标签： pytorch 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tryflyhigh/article/details/138159427
版权

本文结合小土堆的教学视频PyTorch深度学习快速入门教程进行学习

一、完整的模型训练套路

具体代码实现如下

# model.py文件
import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential

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

    # 前向传播
    def forward(self,x):
        x = self.model(x)
        return x
    
if __name__ == '__main__':
    model = Model()
    input = torch.ones((64,3,32,32))
    output = model(input)
    print(output.shape)
# train.py文件
import torchvision
from torch.utils.data import DataLoader
from model import *     # model.py和train.py必须在同一个文件夹下
from torch.utils.tensorboard import SummaryWriter

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

# length长度
train_data_len = len(train_data)
test_data_len = len(test_data)
print("训练数据集的长度为：{}".format(train_data_len))  # 格式化字符串
print("测试数据集的长度为：{}".format(test_data_len))

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

# 创建网络模型
model = Model()

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

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

# 设置训练网络的一些参数
total_train_step = 0    # 记录训练的次数
total_test_step = 0     # 记录测试的次数
epoch = 10      # 训练的轮数

# 添加tensorboard
writer = SummaryWriter("logs")

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

    # 训练步骤开始
    model.train()   # 让网络进入训练状态
    for data in train_dataloader:
        imgs,targets = data
        outputs = model(imgs)
        loss = loss_fn(outputs,targets)  # 计算误差值

        # 优化器优化模型
        optimizer.zero_grad()   # 将参数梯度清0
        loss.backward()     # 反向传播
        optimizer.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_test_step)

    # 测试步骤开始
    model.eval()    # 让网络进入测试状态
    total_test_loss = 0
    total_accuracy = 0
    with torch.no_grad():   # 去除梯度，使模型不会对参数进行调优
        for data in test_dataloader:
            imgs,targets = data
            outputs = model(imgs)
            loss = loss_fn(outputs,targets)  # 计算误差值
            total_test_loss += loss
            accuracy = (outputs.argmax(1) == targets).sum()  # 计算预算正确的数量
            total_accuracy += accuracy
    # 展示效果
    print("整体测试集上的Loss:{}".format(total_test_loss))
    print("整体测试集上的正确率：{}".format(total_accuracy/test_data_len))
    writer.add_scalar("test_loss",loss.item(),total_test_step)
    writer.add_scalar("test_accuracy",total_accuracy/test_data_len,total_test_step)
    total_test_step += 1

    # 保存模型
    torch.save(model,"model_{}.pth".format(i+1))
    print("模型已保存")

writer.close()

程序运行结果显示如下

Files already downloaded and verified
Files already downloaded and verified
训练数据集的长度为：50000
测试数据集的长度为：10000
--------第1轮训练开始--------
训练次数:100, Loss:2.2883501052856445
训练次数:200, Loss:2.283978223800659
训练次数:300, Loss:2.276535749435425
训练次数:400, Loss:2.211817741394043
训练次数:500, Loss:2.121809482574463
训练次数:600, Loss:2.0784034729003906
训练次数:700, Loss:1.9761544466018677
整体测试集上的Loss:311.06243896484375
整体测试集上的正确率：0.288100004196167
模型已保存
--------第2轮训练开始--------
训练次数:800, Loss:1.878362774848938
训练次数:900, Loss:1.832785964012146
训练次数:1000, Loss:1.9041134119033813
训练次数:1100, Loss:1.9213755130767822
训练次数:1200, Loss:1.6937150955200195
训练次数:1300, Loss:1.6661460399627686
训练次数:1400, Loss:1.7335188388824463
训练次数:1500, Loss:1.7996962070465088
整体测试集上的Loss:285.850341796875
整体测试集上的正确率：0.3483000099658966
模型已保存
--------第3轮训练开始--------
训练次数:1600, Loss:1.7524412870407104
训练次数:1700, Loss:1.6654188632965088
训练次数:1800, Loss:1.9707260131835938
训练次数:1900, Loss:1.7274596691131592
训练次数:2000, Loss:1.9246697425842285
训练次数:2100, Loss:1.5304251909255981
训练次数:2200, Loss:1.4880874156951904
训练次数:2300, Loss:1.7865030765533447
整体测试集上的Loss:255.3195037841797
整体测试集上的正确率：0.4147000014781952
模型已保存
--------第4轮训练开始--------
训练次数:2400, Loss:1.732339859008789
训练次数:2500, Loss:1.3916590213775635
训练次数:2600, Loss:1.6185827255249023
训练次数:2700, Loss:1.6978445053100586
训练次数:2800, Loss:1.4863864183425903
训练次数:2900, Loss:1.6016960144042969
训练次数:3000, Loss:1.3664864301681519
训练次数:3100, Loss:1.5545544624328613
整体测试集上的Loss:244.28079223632812
整体测试集上的正确率：0.43779999017715454
模型已保存
--------第5轮训练开始--------
训练次数:3200, Loss:1.3771955966949463
训练次数:3300, Loss:1.4948328733444214
训练次数:3400, Loss:1.4798005819320679
训练次数:3500, Loss:1.563676357269287
训练次数:3600, Loss:1.5787324905395508
训练次数:3700, Loss:1.3048750162124634
训练次数:3800, Loss:1.267425298690796
训练次数:3900, Loss:1.4718506336212158
整体测试集上的Loss:242.99974060058594
整体测试集上的正确率：0.43939998745918274
模型已保存
--------第6轮训练开始--------
训练次数:4000, Loss:1.4343503713607788
训练次数:4100, Loss:1.4455058574676514
训练次数:4200, Loss:1.5285396575927734
训练次数:4300, Loss:1.2184882164001465
训练次数:4400, Loss:1.1589688062667847
训练次数:4500, Loss:1.326550006866455
训练次数:4600, Loss:1.3971928358078003
整体测试集上的Loss:238.05587768554688
整体测试集上的正确率：0.44999998807907104
模型已保存
--------第7轮训练开始--------
训练次数:4700, Loss:1.275310754776001
训练次数:4800, Loss:1.5368099212646484
训练次数:4900, Loss:1.370495319366455
训练次数:5000, Loss:1.370849609375
训练次数:5100, Loss:1.0084483623504639
训练次数:5200, Loss:1.3147143125534058
训练次数:5300, Loss:1.2318178415298462
训练次数:5400, Loss:1.43149733543396
整体测试集上的Loss:232.78636169433594
整体测试集上的正确率：0.4666999876499176
模型已保存
--------第8轮训练开始--------
训练次数:5500, Loss:1.240295648574829
训练次数:5600, Loss:1.2105470895767212
训练次数:5700, Loss:1.2011173963546753
训练次数:5800, Loss:1.2001447677612305
训练次数:5900, Loss:1.3301762342453003
训练次数:6000, Loss:1.5595725774765015
训练次数:6100, Loss:1.070670247077942
训练次数:6200, Loss:1.126779317855835
整体测试集上的Loss:224.64822387695312
整体测试集上的正确率：0.4875999987125397
模型已保存
--------第9轮训练开始--------
训练次数:6300, Loss:1.4885517358779907
训练次数:6400, Loss:1.0875073671340942
训练次数:6500, Loss:1.57513427734375
训练次数:6600, Loss:1.1213852167129517
训练次数:6700, Loss:1.0803751945495605
训练次数:6800, Loss:1.1594667434692383
训练次数:6900, Loss:1.0916932821273804
训练次数:7000, Loss:0.9281116724014282
整体测试集上的Loss:211.3177490234375
整体测试集上的正确率：0.5192999839782715
模型已保存
--------第10轮训练开始--------
训练次数:7100, Loss:1.2686500549316406
训练次数:7200, Loss:1.0005848407745361
训练次数:7300, Loss:1.1087175607681274
训练次数:7400, Loss:0.8756632804870605
训练次数:7500, Loss:1.2323938608169556
训练次数:7600, Loss:1.2329813241958618
训练次数:7700, Loss:0.849784255027771
训练次数:7800, Loss:1.2703667879104614
整体测试集上的Loss:200.145751953125
整体测试集上的正确率：0.5473999977111816
模型已保存

将程序运行后，在终端输入  tensorboard --logdir=logs --port=6007  ，结果显示如下，可见网络模型在测试集上的精确度逐步提升，损失函数值逐渐降低

二、利用GPU训练

方式1：.cuda()

具体代码实现如下

# train.py文件
import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

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

# length长度
train_data_len = len(train_data)
test_data_len = len(test_data)
print("训练数据集的长度为：{}".format(train_data_len))  # 格式化字符串
print("测试数据集的长度为：{}".format(test_data_len))

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

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

    # 前向传播
    def forward(self,x):
        x = self.model(x)
        return x
    
# 创建网络模型
model = Model()
if torch.cuda.is_available():
    model.cuda()    # 将网络模型转移到cuda


# 损失函数
loss_fn = nn.CrossEntropyLoss()
if torch.cuda.is_available():
    loss_fn.cuda()
# 优化器
# learning_rate = 0.01
learning_rate = 1e-2    # 1e-1 = 1×(10)^(-2) = 0.01
optimizer = torch.optim.SGD(model.parameters(),lr=learning_rate)

# 设置训练网络的一些参数
total_train_step = 0    # 记录训练的次数
total_test_step = 0     # 记录测试的次数
epoch = 10      # 训练的轮数

# 添加tensorboard
writer = SummaryWriter("logs")

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

    # 训练步骤开始
    model.train()   # 让网络进入训练状态
    for data in train_dataloader:
        imgs,targets = data
        if torch.cuda.is_available():
            imgs = imgs.cuda()
            targets = targets.cuda()
        outputs = model(imgs)
        loss = loss_fn(outputs,targets)  # 计算误差值

        # 优化器优化模型
        optimizer.zero_grad()   # 将参数梯度清0
        loss.backward()     # 反向传播
        optimizer.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_test_step)

    # 测试步骤开始
    model.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():
                imgs = imgs.cuda()
                targets = targets.cuda()
            outputs = model(imgs)
            loss = loss_fn(outputs,targets)  # 计算误差值
            total_test_loss += loss
            accuracy = (outputs.argmax(1) == targets).sum()  # 计算预算正确的数量
            total_accuracy += accuracy
    # 展示效果
    print("整体测试集上的Loss:{}".format(total_test_loss))
    print("整体测试集上的正确率：{}".format(total_accuracy/test_data_len))
    writer.add_scalar("test_loss",loss.item(),total_test_step)
    writer.add_scalar("test_accuracy",total_accuracy/test_data_len,total_test_step)
    total_test_step += 1

    # 保存模型
    torch.save(model,"model_{}.pth".format(i+1))
    print("模型已保存")

writer.close()

方式2：torch.device() & .to()（常用）

# train.py文件
import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

# 定义一个设备, 通过控制参数来控制程序在哪里运行
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

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

# length长度
train_data_len = len(train_data)
test_data_len = len(test_data)
print("训练数据集的长度为：{}".format(train_data_len))  # 格式化字符串
print("测试数据集的长度为：{}".format(test_data_len))

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

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

    # 前向传播
    def forward(self,x):
        x = self.model(x)
        return x
    
# 创建网络模型
model = Model()
model.to(device)    # 把网络转移到device设备上

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

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

# 设置训练网络的一些参数
total_train_step = 0    # 记录训练的次数
total_test_step = 0     # 记录测试的次数
epoch = 10      # 训练的轮数

# 添加tensorboard
writer = SummaryWriter("logs")

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

    # 训练步骤开始
    model.train()   # 让网络进入训练状态
    for data in train_dataloader:
        imgs,targets = data
        imgs = imgs.to(device)
        targets = targets.to(device)
        outputs = model(imgs)
        loss = loss_fn(outputs,targets)  # 计算误差值

        # 优化器优化模型
        optimizer.zero_grad()   # 将参数梯度清0
        loss.backward()     # 反向传播
        optimizer.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_test_step)

    # 测试步骤开始
    model.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 = model(imgs)
            loss = loss_fn(outputs,targets)  # 计算误差值
            total_test_loss += loss
            accuracy = (outputs.argmax(1) == targets).sum()  # 计算预算正确的数量
            total_accuracy += accuracy
    # 展示效果
    print("整体测试集上的Loss:{}".format(total_test_loss))
    print("整体测试集上的正确率：{}".format(total_accuracy/test_data_len))
    writer.add_scalar("test_loss",loss.item(),total_test_step)
    writer.add_scalar("test_accuracy",total_accuracy/test_data_len,total_test_step)
    total_test_step += 1

    # 保存模型
    torch.save(model,"model_{}.pth".format(i+1))
    print("模型已保存")

writer.close()

三、完整的模型验证套路

验证：把训练好的模型应用到实际环境中

具体代码实现如下

from PIL import Image
import torchvision
import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential

class Model(nn.Module):
    def __init__(self) -> None:
        super(Model,self).__init__()
        self.model = Sequential(
            Conv2d(3,32,5,1,2),
            MaxPool2d(2),
            Conv2d(32,32,5,1,2),
            MaxPool2d(2),
            Conv2d(32,64,5,1,2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024,64),
            Linear(64,10)
        )

    def forward(self,x):
        x = self.model(x)
        return x
    
image_path = "./image/dog.png"
image = Image.open(image_path)
print(image)
image = image.convert('RGB')    # 将图片转化为RGB三通道
transform = torchvision.transforms.Compose([torchvision.transforms.Resize([32,32]),
                                            torchvision.transforms.ToTensor()])
image = transform(image)
print(image.shape)

model = torch.load("model_1.pth")
print(model)
image = torch.reshape(image,(1,3,32,32))    # 添加batch_size
model.eval()
with torch.no_grad():
    output = model(image)
print(output)
print(output.argmax(1))

程序运行结果如下，输出索引是6，其对应的种类是frog而不是dog，说明采用第一次训练的模型准确率还有待提高

<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=1659x1073 at 0x1C8688E2610>
<PIL.Image.Image image mode=RGB size=1659x1073 at 0x1C8688A3040>
torch.Size([3, 32, 32])
Model(
  (model): Sequential(
    (0): Conv2d(3, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (2): Conv2d(32, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (4): Conv2d(32, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (6): Flatten(start_dim=1, end_dim=-1)
    (7): Linear(in_features=1024, out_features=64, bias=True)
    (8): Linear(in_features=64, out_features=10, bias=True)
  )
)
tensor([[-1.7079,  0.4696,  0.6549,  0.4952,  0.7226,  0.8485,  1.3298,  0.2228,
         -1.4841,  0.0125]])
tensor([6])
tryflyhigh
关注
Pytorch学习笔记（五）
kongshuchen的博客
05-16 1万+
（9）在Pytorch中使用LSTM 学习Pytorch的RNN使用时最好去官方文档看一下API是如何使用的：（http://pytorch.org/docs/nn.html#recurrent-layers）。一个需要注意的地方是在Pytorch中RNN的输入input的shape的三维分别是 (seq_len, batch, input_size)，隐藏层h_0的shape三维分别是 (n
Pytorch入门学习笔记
u012733099的博客
11-27 1069
定义两层卷积层 + 三层全连接层的神经网络： class Net(nn.Module): def __init__(self): # 定义神经网络结构 super(Net, self).__init__() # 第一层（卷积层） self.conv1 = nn.Conv2d(1,6,3) # 输入频道1，输出频道6，卷积大小3*3 ...
Pytorch深度学习入门（笔记）
Superstar23333的博客
03-18 667
这是方差（损失）这是平均损失（MSE）这个值越小，拟合性越好。
Pytorch入门学习笔记（二）
tryflyhigh的博客
04-21 1557
本文结合小土堆的教学视频进行学习。
【Pytorch入门】小土堆PyTorch入门教程完整学习笔记（详细笔记并附练习代码 ipynb文件）
几度热忱的博客
03-28 6461
【Pytorch入门】小土堆PyTorch入门教程完整学习笔记（详细笔记 文末附练习代码 ipynb文件）
Python-Pytorch入门学习笔记（小土堆视频）
02-20
Python pytorch学习笔记 ***from的是一个个的包（package)*** ***import 的是一个个的py文件(file.py)*** ***所使用的一般是文件中的类(.class)*** ***第一步实例化所使用的类,然后调用类中的方法（def)*** 包含...
Pytorch入门实战学习笔记
04-24
### PyTorch 入门实战学习笔记 #### 一、PyTorch简介 PyTorch 是一个基于 Torch 的机器学习库，它支持动态计算图，主要用于应用程序中的深度神经网络研究。PyTorch 提供了丰富的功能，如自动梯度计算、GPU 加速...
深度学习与PyTorch入门学习教程.txt打包整理.zip
03-05
这个"深度学习与PyTorch入门学习教程.txt打包整理.zip"文件可能包含一系列教程或笔记，涵盖了以上提到的各个知识点，帮助初学者逐步掌握深度学习和PyTorch的基础。通过阅读和实践其中的内容，你将能够系统地学习和...
Pytorch 入门学习笔记+深度学习代码示例
weixin_41823298的博客
09-21 2813
Pytorch 入门学习笔记1.0 Pytorch是什么2.0 Pytorch 的安装2.1 Pytorch 的安装方式2.2 Pytorch 的安装结果3.0 Pytorch 入门编程3.1 Pytorch 的安装结果3.2 Pytorch 的安装结果3.3 Pytorch 的安装结果4.0 Pytorch 示例Resnet神经网络训练代码 1.0 Pytorch是什么 Pytorch是一种基于Python的科学计算软件包，面向两组受众： 1.替代NumPy以使用GPU的功能 2.提供最大灵活性和速度的深
PyTorch深度学习快速入门教程【小土堆】 学习笔记
热门推荐
竦貊的博客
05-27 1万+
目录学习视频地址 —— B站1 pyTorch安装和配置已经测试，速度很慢，30kB/s已经测试，最有效的办法，速度最快,3MB/s2 python 编辑器的安装pyCharm 安装注意事项pyCharm 配置检测是否正常运行新环境中安装jupyterjupyter 使用指南3 为什么 返回 false4 pyhton 学习中的两个 法宝函数 学习视频地址 —— B站 PyTorch深度学习快速入门教程（绝对通俗易懂！）【小土堆】 1 pyTorch安装和配置 anaconda 安装路径：D:\anac
动手学深度学习（pytorch土堆）-02TensorBoard的使用
凯的博客
09-10 530
代码使用了将数据记录到 TensorBoard 以便可视化。具体来说，它将标量数据记录到目录logs中，使用的是类。"logs""y=x"iy = x然后在浏览器中访问来查看记录的标量数据。add_image。
Redis 入门 - 五大基础类型及其指令学习
IT规划师
09-11 771
学习Redis基础类型：字符串、集合、有序集合、列表、哈希，每种类型有各自的特点和常用指令。掌握这些基础是熟练使用Redis的关键。更多指令需自行尝试。
qmt量化交易策略小白学习笔记第61期【qmt编程之期权行情数据--get_market_data_ex函数】
fanglue3705的博客
09-09 720
获取期权行情数据 获取期权最新数据，首先需要进行数据订阅。完成合约订阅后，用get_market_data_ex函数即可提取相关信息。这个过程包含两大步骤： 第一，通过订阅操作确保能接收到你感兴趣的期权合约的更新； 第二，调用get_market_data_ex函数来实际获取并处理这些订阅到的数据,如果需要用到历史数据或过期合约数据，需要使用download_history_data进行下载。
计算几何学习
最新发布
网安小白
09-12 365
学习计算几何过程中对经典算法的记录
AdaBoost算法（AdbBoost Algorithm）—有监督学习方法、非概率模型、判别模型、非线性模型、非参数化模型、批量学习
nanxiaotao的博客
09-11 853
AdaBoost算法（AdbBoost Algorithm）—有监督学习方法、非概率模型、判别模型、非线性模型、非参数化模型、批量学习
【学习笔记】SSL证书之前向保密
Taki_UP的博客
09-10 703
本篇介绍了密码学中前向保密（Forward Secrecy）的相关内容
Android Fragment 学习备忘
sdaujz的博客
09-08 417
1.fragment的动态添加与管理：
IIC基本学习
????????????????????????????????????????????????
09-11 230
对IIC通信协议补充了基本的了解，在进行相关的工程实践后再进行补充。
学习threejs，创建立方体，并执行旋转动画
我哎GIS博客
09-09 681
本文基于threejs，实现立方体的创建，并加入立方体旋转动画。
"PyTorch入门实战学习笔记：小土堆教程全解析，附代码整合及学习视频链接
通过学习视频链接 https://www.bilibili.com/video/BV1hE411t7RN?spm_id_from=333.337.search-card.all.click ，作者整理出了一些PyTorch入门实战的学习内容，并附上了自己创建的MyData数据集。 在学习过程中，作者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值