pytorch学习【2】

已于 2024-10-02 20:33:55 修改
阅读量342 收藏 7
点赞数 6
分类专栏： 深度学习 文章标签： pytorch 学习 人工智能
于 2024-10-02 20:15:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52384627/article/details/142671159
版权

这里写目录标题


打开tensorboard 

tensorboard --logdir="D:\6.PyCharm\1项目代码\test\logs_池化层"

前置API：

# 1.root="./dataset"当前文件的相对位置 , 2.train=True是为训练集(不是测试集), 3.transform=将图片使用该方法转换, 4.download=True下载到root路径中
dataset = torchvision.datasets.CIFAR10(root='./dataset',train=False,transform=transform,download=True)  # 下载测试集

# 1.dataset=test_set:数据集, 2.batch_size=4:一次取四张图片, 3.shuffle=False（默认）:不打乱顺序, 4.num_workers=0:进程数, 5.drop_last=False(默认)：保留最后不能整除
dataloader = DataLoader(dataset=dataset, batch_size=64)

# 标签要不同、step要不同
writer.add_images("input", imgs, step)
writer.add_images("output", output, step)

1.卷积层：提取特征

卷积层API：

# 输入的通道数、输出的通道数、卷积核大小、步长（默认1）、填充（默认0）
self.conv1 = Conv2d(in_channels=3, out_channels=6, kernel_size=3, stride=1, padding=0)

# 输出通道数out_channels = 卷积核的个数
#
import torchvision
import torch
from torch.utils.data import DataLoader
from torch import nn
from torch.nn import Conv2d
from torch.utils.tensorboard import SummaryWriter
# torchvision->transforms->[Compose...]
# torchvision->datasets->CIFAR10
# torch.utils.data-> DataLoader
# torch.nn->Module
# torch.utils.tensorboard->SummaryWriter
'''
# 图像格式预处理
'''
transform = torchvision.transforms.Compose([
    torchvision.transforms.ToTensor()
])

'''
# 读入数据集
'''
# 1.root="./dataset"当前文件的相对位置 , 2.train=True是为训练集(不是测试集), 3.transform=将图片使用该方法转换, 4.download=True下载到root路径中
dataset = torchvision.datasets.CIFAR10(root='./dataset',train=False,transform=transform,download=True)  # 下载测试集

'''
# 小批量的数据读入
'''
# 1.dataset=test_set:数据集, 2.batch_size=4:一次取四张图片, 3.shuffle=False（默认）:不打乱顺序, 4.num_workers=0:进程数, 5.drop_last=False(默认)：保留最后不能整除
dataloader = DataLoader(dataset=dataset, batch_size=64)

'''
# 建立模型
'''
class MyModule(nn.Module):
    def __init__(self):
        super(MyModule, self).__init__()
        self.conv1 = Conv2d(in_channels=3, out_channels=6, kernel_size=3, stride=1, padding=0)

    def forward(self, x):
        x = self.conv1(x)
        return x

mymodule = MyModule()
# print(mymodule)

writer = SummaryWriter("./logs_卷积层")


# data是64张图片
step = 0
for data in dataloader:
    # imgs = 64张图片，targets =64张图片的正确标签
    imgs, targets = data
    output = mymodule(imgs)
    writer.add_images("input", imgs, step)
    # 图片展示需要三个通道
    output = torch.reshape(output, (-1, 3, 30, 30))
    writer.add_images("output", output, step)
    step = step + 1
    # print(imgs.shape)
    # print(output.shape)

writer.close()

2.池化层：减少特征

池化不需要reshape了，因为通道数没有改变（MaxPool2d没有参数涉及到通道数）

池化层API

# 1.kernel_size=3：池化核大小 2.ceil_mode=true:向上取整, 3.步长stride=kernel_size（默认）
self.maxpool1 = MaxPool2d(kernel_size=3, ceil_mode=True)

import torch
import torchvision.datasets
from torch import nn
from torch.nn import MaxPool2d
from torch.utils.data import DataLoader

# 图片预处理
from torch.utils.tensorboard import SummaryWriter

transform = torchvision.transforms.Compose([
    torchvision.transforms.ToTensor()
])
# 加载数据集
dataset = torchvision.datasets.CIFAR10("./dataset", train=False, transform=transform, download=True)
# 小批量读入
dataloader = DataLoader(dataset=dataset,batch_size=64)


class MyModule(nn.Module):
    def __init__(self):
        super(MyModule, self).__init__()
        # 1.kernel_size=3：池化核大小 2.ceil_mode=true:向上取整, 3.stride=kernel_size（默认）
        self.maxpool1 = MaxPool2d(kernel_size=3, ceil_mode=True)

    def forward(self, input):
        output = self.maxpool1(input)
        return output

mymodule = MyModule()

writer = SummaryWriter("./logs_池化层")
step = 0
for data in dataloader:
    imgs, targets = data
    output = mymodule(imgs)
    writer.add_images("input", imgs, step)
    writer.add_images("output", output, step)
    step = step + 1

writer.close()

在这里插入图片描述
在这里插入图片描述

3.非线性激活

3.1ReLU函数

ReLU函数API：

torch.nn.ReLU(inplace=False)

具体函数：ReLU(x) =max(0,x)
图像：
在这里插入图片描述

3.1.1处理tensor

import torch
from torch import nn
from torch.nn import ReLU
input = torch.tensor([[1, -0.5],
              [-1, 3]])

input = torch.reshape(input, (-1, 1, 2, 2))
class MyModule(nn.Module):
    def __init__(self):
        super(MyModule, self).__init__()
        self.relu1 = ReLU()

    def forward(self, input):
        output = self.relu1(input)
        return output

mymodule = MyModule()

output = mymodule(input)
print(output)

3.1.2处理图片

将图片过ReLU函数

import torch
import torchvision.datasets
from torch import nn
from torch.nn import ReLU,Sigmoid
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

transform = torchvision.transforms.Compose([
    torchvision.transforms.ToTensor()
])
dataset = torchvision.datasets.CIFAR10("./dataset", train=False, transform=transform, download=True)
dataloader = DataLoader(dataset=dataset, batch_size=64)

class MyModule(nn.Module):
    def __init__(self):
        super(MyModule, self).__init__()
        self.relu1 = ReLU()
        self.sigmoid1 = Sigmoid()

    def forward(self, input):
        output = self.relu1(input)
        return output

mymodule = MyModule()

writer = SummaryWriter("./logs_非线性激活ReLU")
step = 0
for data in dataloader:
    imgs, targets = data
    writer.add_images("input", imgs, step)
    output = mymodule(imgs)
    writer.add_images("output", output, step)
    step += 1

writer.close()

几乎没有差别
在这里插入图片描述

3.2Sigmoid函数

API

torch.nn.Sigmoid(*args, **kwargs)

在这里插入图片描述
在这里插入图片描述

3.2.1处理图片

import torch
import torchvision.datasets
from torch import nn
from torch.nn import ReLU,Sigmoid
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

transform = torchvision.transforms.Compose([
    torchvision.transforms.ToTensor()
])
dataset = torchvision.datasets.CIFAR10("./dataset", train=False, transform=transform, download=True)
dataloader = DataLoader(dataset=dataset, batch_size=64)

class MyModule(nn.Module):
    def __init__(self):
        super(MyModule, self).__init__()
        self.relu1 = ReLU()
        self.sigmoid1 = Sigmoid()

    def forward(self, input):
        output = self.sigmoid1(input)
        return output

mymodule = MyModule()

writer = SummaryWriter("./logs_非线性激活Sigmoid")
step = 0
for data in dataloader:
    imgs, targets = data
    writer.add_images("input", imgs, step)
    output = mymodule(imgs)
    writer.add_images("output", output, step)
    step += 1

writer.close()

在这里插入图片描述

4.线性层

API：

in_features （int） – 每个输入样本的大小
out_features （int） – 每个输出样本的大小
bias (bool) – 默认True
torch.nn.Linear(in_features, out_features, bias=True, device=None, dtype=None)

import torch
import torchvision
from torch import nn
from torch.utils.data import DataLoader
from torch.nn import Linear
dataset = torchvision.datasets.CIFAR10("./dataset", train=False, transform=torchvision.transforms.ToTensor(), download=True)
dataloader = DataLoader(dataset, batch_size=64)

class MyModule(nn.Module):
    def __init__(self):
        super(MyModule, self).__init__()
        self.linear1 = Linear(196608, 10)

    def forward(self, input):
        output = self.linear1(input)
        return output

mymodule = MyModule()

for data in dataloader:
    imgs, targets = data
    print(imgs.shape)
    # print(64*3*32*32)
    # input = torch.reshape(imgs, (1, 1, 1, -1))
    input = torch.flatten(imgs)
    print(input.shape)
    output = mymodule(input)
    print(output.shape)

在这里插入图片描述

5.小实战+Sequential使用

在这里插入图片描述
如果前后尺寸不变的话，那么padding=（f-1）/2，f是卷积核的尺寸，也就是5，所以padding=(5-1)/2=2

import torch
from torch import nn
from torch.nn import Conv2d,MaxPool2d,Flatten,Linear,Sequential
from torch.utils.tensorboard import SummaryWriter


class My(nn.Module):
    def __init__(self):
        super(My, self).__init__()
        # 繁琐版本
        '''
        # 公式推算出来的s and p （卷积核中心对准最边缘的那个==》5/2=2）
        self.conv1 = Conv2d(in_channels=3, out_channels=32, kernel_size=5, stride=1, padding=2)
        # 公式推算
        self.maxpool1 = MaxPool2d(kernel_size=2, stride=2, padding=0)
        # 公式推算
        self.conv2 = Conv2d(in_channels=32, out_channels=32, kernel_size=5, stride=1, padding=2)
        # 公式推算
        self.maxpool2 = MaxPool2d(kernel_size=2, stride=2, padding=0)
        self.conv3 = Conv2d(in_channels=32, out_channels=64, kernel_size=5, stride=1, padding=2)
        self.maxpool3 = MaxPool2d(kernel_size=2, stride=2, padding=0)
        self.flatten = Flatten()
        self.linear1 = Linear(1024, 64)
        self.linear2 = Linear(64, 10)
        '''
        # 简化版本
        self.model1 = Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

    def forward(self, x):
        # 繁琐版本
        '''
        x = self.conv1(x)
        x = self.maxpool1(x)
        x = self.conv2(x)
        x = self.maxpool2(x)
        x = self.conv3(x)
        x = self.maxpool3(x)
        x = self.flatten(x)
        x = self.linear1(x)
        x = self.linear2(x)
        '''
        # 简化版本
        x = self.model1(x)
        return x
my = My()
print(my)
# 模型是否错误、验证
input = torch.ones((64, 3, 32, 32))
output = my(input)
print(output.shape)

writer = SummaryWriter("./logs_Sequential")
writer.add_graph(my, input)
writer.close()

在这里插入图片描述
在这里插入图片描述

6.损失函数

6.1L1Loss

在这里插入图片描述

6.2MSELoss

在这里插入图片描述

6.3CrossEntropyLoss

在这里插入图片描述

egg:
在这里插入图片描述

import torch
from torch.nn import L1Loss, MSELoss, CrossEntropyLoss
inputs = torch.tensor([1, 2, 3], dtype=torch.float32)
targets = torch.tensor([1, 2, 5], dtype=torch.float32)
inputs = torch.reshape(inputs, (1, 1, 1, 3))
targets = torch.reshape(targets, (1, 1, 1, 3))

# egg:L1Loss(reduction='sum') 下边三个损失函数都可以使用
# reduction='sum':差值的绝对值相加
# reduction='mean'(默认):差值的绝对值相加的平均值
loss = L1Loss()
loss_mse = MSELoss()

ans1 = loss(inputs, targets)
ans2 = loss_mse(inputs, targets)

print(ans1)
print(ans2)


# 预测概率
x = torch.tensor([0.1, 0.2, 0.3])
# 真实值
y = torch.tensor([1])
# 必须有3=》分类的类数
x = torch.reshape(x, (1, 3))
loss_cross = CrossEntropyLoss()
ans3 = loss_cross(x, y)
print(ans3)

7.反向传播

就一句话：loss.backward()

import torch
import torchvision.datasets
from torch import nn
from torch.nn import Conv2d,MaxPool2d,Flatten,Linear,Sequential,CrossEntropyLoss
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10("./dataset", train=False, transform=torchvision.transforms.ToTensor(), download=True)
dataloader = DataLoader(dataset=dataset, batch_size=64)


class My(nn.Module):
    def __init__(self):
        super(My, self).__init__()
        # 简化版本
        self.model1 = Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

    def forward(self, x):
        # 简化版本
        x = self.model1(x)
        return x


my = My()
# 参数：一张图片的[各个分类的概率、真实分类]
# 比如三分类，参数就是，预测概率[0.1，0.2，0.3] 真实分类[1]
loss_cross = CrossEntropyLoss()
for data in dataloader:
    imgs, targets = data
    outputs = my(imgs)
    # print(outputs)  # 一张图片预测的分类的概率[10个概率值]
    # print(targets)  # 真实分类

    loss = loss_cross(outputs, targets)
    # 损失函数的反向传播
    loss.backward()
    print("每bacth图片上的损失值：", loss)

8.优化器

引入
optim = torch.optim.SGD(my.parameters(), lr=0.01)

三步：1.清零 2.反向传播 3.调优
loss = loss_cross(outputs, targets)
optim.zero_grad()  #参数置0
loss.backward()  #方向传播、求梯度
optim.step()  #参数调优

import torch
import torchvision.datasets
from torch import nn
from torch.nn import Conv2d,MaxPool2d,Flatten,Linear,Sequential,CrossEntropyLoss
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10("./dataset", train=False, transform=torchvision.transforms.ToTensor(), download=True)
dataloader = DataLoader(dataset=dataset, batch_size=64)


class My(nn.Module):
    def __init__(self):
        super(My, self).__init__()
        # 简化版本
        self.model1 = Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

    def forward(self, x):
        # 简化版本
        x = self.model1(x)
        return x


my = My()
loss_cross = CrossEntropyLoss()
optim = torch.optim.SGD(my.parameters(), lr=0.01)
for k in range(20):
    sum_loss = 0
    for data in dataloader:
        imgs, targets = data
        outputs = my(imgs)
        loss = loss_cross(outputs, targets)
        optim.zero_grad()  #参数置0
        loss.backward()  #方向传播、求梯度
        optim.step()  #参数调优
        sum_loss += loss
    print("每一轮的损失值：", sum_loss)

9.加载现有模型、并且修改

import os
import torchvision
from torchvision import models
from torchvision.models import vgg16
from torch import nn

# 修改下载路径
os.environ['TORCH_HOME']='D:\\6.PyCharm\\1项目代码\\test\models'
# 不自带参数
vgg16_false = vgg16(weights=None)
# 自带参数
vgg16_true = vgg16(weights=models.VGG16_Weights.DEFAULT)

print(vgg16_true)
# print(vgg16_false)

vgg16_true.add_module('add_linear1', nn.Linear(1000, 10))
print(vgg16_true)

vgg16_true.classifier.add_module('add_linear2', nn.Linear(1000, 10))
print(vgg16_true)

vgg16_true.classifier[6] = nn.Linear(4096, 10)
print(vgg16_true)

添加

vgg16_true.add_module('add_linear', nn.Linear(1000, 10))

在这里插入图片描述

vgg16_true.classifier.add_module('add_linear', nn.Linear(1000, 10))

在这里插入图片描述
修改

vgg16_true.classifier[6] = nn.Linear(4096, 10)

原来：
在这里插入图片描述
修改后：
在这里插入图片描述

10.网络模型的保存和读入

10.1网上加载的模型

获取模型：

os.environ['TORCH_HOME']='D:\\6.PyCharm\\1项目代码\\study_pytorch\models'
vgg16 = torchvision.models.vgg16(weights=torchvision.models.VGG16_Weights.DEFAULT)

保存模型：

# 保存模型法1：保存参数，保存结构
torch.save(vgg16, "./vgg16_1.pth")

# 保存模型法2：保存参数，不保存结构
torch.save(vgg16.state_dict(), "./vgg16_2.pth")

加载模型：

# 加载法1：
# weights_only不知道社么意思
load_model1 = torch.load('./vgg16_1.pth', weights_only=False)
print(load_model1)

在这里插入图片描述

# 加载法2：
# 1.输出是参数字典
load_model2 = torch.load('./vgg16_2.pth', weights_only=False)
print(load_model2)
# 2.输出的结构
vgg16 = torchvision.models.vgg16(weights=torchvision.models.VGG16_Weights.DEFAULT)  # 获取模型
vgg16.load_state_dict(torch.load('./vgg16_2.pth', weights_only=False))  # 加载参数->放入模型
print(vgg16)

在这里插入图片描述
在这里插入图片描述

10.2加载自定义模型

保存模型：
文件1.py：

# 保存模型法1：自定义模型
class MyModule(nn.Module):
    def __init__(self):
        super(MyModule, self).__init__()
        self.conv1 = Conv2d(in_channels=3, out_channels=6, kernel_size=3, stride=1, padding=0)

    def forward(self, x):
        x = self.conv1(x)
        return x

mymodule = MyModule()
torch.save(mymodule, "./mymodule.pth")

文件2.py：

# 加载法1：自定义模型
mymodule = torch.load('./mymodule.pth', weights_only=False)
print(mymodule)

以上代码回会出错。
解决办法：
1.加入class MyModule(nn.Module):XXXX自己模型的代码。

# 保存模型法1：自定义模型
class MyModule(nn.Module):
    def __init__(self):
        super(MyModule, self).__init__()
        self.conv1 = Conv2d(in_channels=3, out_channels=6, kernel_size=3, stride=1, padding=0)

    def forward(self, x):
        x = self.conv1(x)
        return x
# 加载法1：自定义模型
mymodule = torch.load('./mymodule.pth', weights_only=False)
print(mymodule)

2.from model import *直接导入，注意model是.py模型文件

阿斯卡码
关注
专栏目录
PyTorch深度学习实战（2）——PyTorch基础
盼小辉丶的博客
06-04 4万+
PyTorch 是广泛应用于机器学习领域中的强大开源框架，因其易用性和高效性备受青睐。在本节中，将介绍使用 PyTorch 构建神经网络的基础知识。首先了解 PyTorch 的核心数据类型——张量对象。然后，我们将深入研究用于张量对象的各种操作。PyTorch 提供了许多帮助构建神经网络的高级方法及组件，并提供了利用 GPU 更快地训练神经网络的张量对象。
PyTorch深度学习实战（3）——使用PyTorch构建神经网络
盼小辉丶的博客
06-13 6万+
PyTorch 是一个用于构建深度神经网络的库，具有灵活性和可扩展性，可以轻松自定义模型。在本节中，我们将使用 PyTorch 库构建神经网络，利用张量对象操作和梯度值计算更新网络权重，并利用 Sequential 类简化网络构建过程，最后还介绍了如何使用 save、load 方法保存和加载模型，以节省模型训练时间。
PyTorch 深度学习入门
努力是为了站在万人之中，成为别人的光
06-14 2万+
深度学习是机器学习的一个分支，其中编写了模仿人脑功能的算法。深度学习中最常用的库是 Tensorflow 和 PyTorch。由于有各种可用的深度学习框架，人们可能想知道何时使用 PyTorch。以下是人们可能更喜欢将 Pytorch 用于特定任务的原因。Pytorch 是一个开源深度学习框架，带有 Python 和 C++ 接口。Pytorch 位于 torch 模块中。在 PyTorch 中，必须处理的数据以张量的形式输入。如果您的系统中安装了 Anaconda Python.........
PyTorch深度学习与计算机视觉实践
weixin_43178406的博客
07-30 5万+
本文主要介绍了PyTorch深度学习与计算机视觉实践，希望能对同学们有所帮助。 文章目录 1. 前言 2. 书籍推荐 2.1 内容简介 2.2 本书作者 2.3 本书目录 3. 购买链接
Pytorch学习
骊山道童的博客
03-05 2108
Pytorch学习 1.1 Pytorch简介： Pytorch是一个优秀的开源机器学习和深度学习算法框架，pytorch官方网址: https://pytorch.org/. 除此之外的开源框架还有TensorFlow、MXNet、CNTK、Keras等。Pytorch语法简洁、优美。个人感觉比起TensorFlow更容易上手。PyTorch 的奥秘，重点在于‘’张量‘’ 1.2 Pytorch的环境安装 1.3 Pytorch资料 pytorch中文文档 ： https://pytorch-cn.re
pytorch与深度学习
数字人生
04-17 1817
PyTorch是一个由Facebook AI Research Team开发的开源深度学习库，它提供了一个灵活的环境和丰富的API，用于快速且方便地构建、训练和部署深度学习模型。综上所述，PyTorch 凭借其灵活的动态图机制、强大的张量运算与自动求导、丰富的深度学习模块以及活跃的社区支持，已成为深度学习研究与应用开发的首选工具之一。2. 优秀的社区和生态系统：有着活跃的社区和广泛的支持，PyTorch提供了大量的预训练模型和工具，这些模型和工具涵盖了图像识别、自然语言处理等多个领域。
Pytorch最全安装教程（一步到位）
热门推荐
weixin_44904136的博客
03-05 31万+
概述 PyTorch是一个开源的Python机器学习库，其前身是著名的机器学习库Torch。它是美国Facebook公司使用python语言开发的一个深度学习的框架，2017年1月，Facebook人工智能研究院（FAIR）在GitHub上开源了PyTorch。它的前身是2002年诞生于纽约大学 的Torch。 特点： 1）简洁： PyTorch的设计追求最少的封装，尽量避免重复造轮子。 简洁的设计带来的另外一个好处就是代码易于理解。PyTorch的源码只有TensorFlow的十分之一左右，更少的抽
pytorch深度学习实战
shuaiqidexiaojiejie的博客
06-24 3285
爱因斯坦求和是一种对求和公式简洁高效的记法，其原则是当变量下标重复出现时，即可省略繁琐的求和符号。比如求和公式： 其中变量 a 与变量 b 的下标是相同的（即重复出现），则可将其记为： einsum方法正是利用了爱因斯坦求和简介高效的表示方法，从而可以驾驭任何复杂的矩阵计算操作。基本的框架如下： 上述操作表示矩阵A与矩阵B的点积。输入的参数分为两部分，前面表示计算操作的字符串，后面是以逗号隔开的操作对象（数量需与前面对应）。其中在计算操作表示中，"->“左边是以逗号隔开的下标索引，重复出现的索引即是需要
PyTorch详细教程
IT菜鸟
02-13 1万+
为了加速计算，一些框架会使用对神经网络“先编译，后执行”的静态图来描述网络。静态图的缺点是难以描述控制流（比如 if-else 分支语句和 for 循环语句），直接对其引入控制语句会导致产生不同的计算图。比如循环执行 n 次 a=a+b，对于不同的 n，会生成不同的计算图。
PyTorch深度学习实战
码龙社的博客
02-22 1232
pytorch深度学习实战
pytorch学习课件
09-12
PyTorch学习课件 PyTorch是当前深度学习领域中最流行的开源机器学习库之一，本资源旨在为读者提供PyTorch的学习课件，涵盖深度学习的基本原理、PyTorch的开发环境、深度学习的基础网络、PyTorch框架等知识点。 ...
PyTorch深度学习实践_pytorch_深度学习_
10-01
pytorch深度学习实践，深度学习实践入门，内附pdf，代码。
jupyter使用pytorch
pattyi的博客
09-27 570
以下所有命令都在Anaconda Prompt中操作。我的环境名称是。
【PyTorch】环境配置
Glass_Gun的博客
09-27 732
2017年1月，FAIR（Facebook AI Research）发布了PyTorch。PyTorch是在Torch基础上用python语言重新打造的一款。Torch是采用Lua语言作为接口的机器学习框架，但因为Lua语言较为小众，导致Torch知名度不高。
Pytorch基本知识
最新发布
西木风落
10-01 755
事实上，绝大多数操作并不修改tensor的实际数据(即存储区的内容)，而是修改tensor的头信息，这样操作既节约内存，处理速度也更快，例如使用索引截取部分tensor后新tensor的内存指向不会发生变化，只会改变对应的地址偏移量，而使用。值得注意的是，model.state_dict()所存储的模型参数tensor的require_grad都是False，而model.named_parameters()模型参数中的require_grad属性都是True。)的一部分，从而可以进行参数优化。
使用PyTorch实现自然语言处理：从基础到实践
windowshht的博客
10-01 202
本文详细介绍了如何使用PyTorch实现一个简单的自然语言处理任务——文本分类。从数据准备、模型构建到训练与评估，提供了完整的代码示例。希望通过本文，读者能够掌握使用PyTorch进行自然语言处理的基本方法，并能够在实际项目中应用。自然语言处理是一个复杂且多变的领域，随着数据量和模型复杂度的增加，不断优化和改进模型是必不可少的。希望大家在实践中不断探索，提升自然语言处理模型的性能和应用效果。希望这篇博文对你有所帮助！如果有任何问题或需要进一步的解释，请随时告诉我。
pytorch之梯度累加
2303_77275067的博客
10-01 794
可以理解为一个多变量函数的变化率，它告诉我们在某一点上，函数的输出如何随输入的变化而变化。更直观地说，梯度指示了最优化方向。
深度学习之开发环境(CUDA、Conda、Pytorch)准备（4）
Aimmon
09-26 1037
CUDA（Compute Unified Device Architecture）是由NVIDIA公司推出的一种并行计算平台和编程模型，它使得开发者能够利用NVIDIA GPU的强大并行计算能力来加速计算密集型任务。CUDA 不仅是一种编程语言，更是一个完整的开发平台，包括了硬件、软件、驱动程序、库和工具等。Anaconda 是一个开源的 Python 和 R 语言的分发版本，主要用于数据科学、机器学习和大数据分析。
pytorch千问模型源码分析
LIjin_1006的博客
09-28 872
self.num_key_value_groups = self.num_heads // self.num_key_value_heads # 比例。# (b,h,q_len,dk)-->(b,h,q_len,h,dk),之后.contiguous()转为内存连续存储。# (b,q_len,q_h,dk)-->(b,q_h,q_len,dk),transpose:换轴(转置)# 用于生成旋转位置嵌入。# 键/值序列长度：kv_seq_len 是键和值向量的长度，这是因为键和值向量代表的是相同的序列。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阿斯卡码

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值