基础-深度学习pytorch

最新推荐文章于 2024-11-17 12:01:11 发布
最新推荐文章于 2024-11-17 12:01:11 发布
阅读量163 收藏
点赞数
分类专栏： 自学笔记 文章标签： 深度学习 pytorch 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61793088/article/details/131819077
版权
本笔记详细介绍了PyTorch中的张量操作，包括创建、数值计算、类型转换、拼接、索引、形状操作以及自动微分模块。通过这些基础知识，可以搭建和理解简单的神经网络模型，并进行图像和自然语言处理任务的初步探索。
摘要由CSDN通过智能技术生成

🤗写在前面

本笔记是Onekey在学习传智教育黑马程序员课程中的本人的笔记记录，供本人复习使用，感谢黑马程序员的教学课程，如有不便分享可联系删除，感谢你们的教学视频！👍👍👍

深度学习框架pytorch的使用

神经网络的重要概念

神经网络应用于图像

神经网络应用于自然语言处理任务

第一章 PyTorch使用

0 介绍

  1. PyTorch 创建张量

  2. PyTorch 张量的数值计算

  3. PyTorch 张量类型转换

  4. PyTorch 张量的拼接操作

  5. PyTorch 索引操作

  6. PyTorch 张量形状的操作

  7. PyTorch 张量的运算函数

  8. PyTorch 自动微分模块

  9. 案例 手动构建线性回归

  10. PyTorch 构架构建线性回归

  11. 模型的保存和加载

1 张量的创建

💯 小结

  1. 创建张量的方式

    torch.tensor 根据指定数据创建张量

    torch.Tensor 根据形状创建张量，其也可用来创建指定数据的张量

    torch.lntTensor、torch.FloatTensor、torch.DoubleTensor 创建指定类型的张量

  2. 创建线性和随机张量

    torch.arange 和 torch.linspace 创建线性张量

    torch.random.init_seed和 torch.random.manual_seed 随机种子设置

    torch.randn 创建随机张量

  3. 创建01张量

    torch.ones 和 torch.ones_like 创建全1张量

    torch.zeros 和torch.zeros_like 创建全0张量

    torch.full 和 torch.full_like 创建全为指定值张量

  4. 张量元素类型转换

    tensor.type(torch.DoubleTensor)

    torch.double()

(1) 基本创建方式

  • PyTorch 是一个Python 深度学习框架，它将数据封装成张量 (Tensor) 来进行运算

  • PyTorch 中的张量就是元素为同一种数据类型的多维矩阵

  • PyTorch 中，张量以“类”的形式封装起来，对张量的一些运算、处理的方法被封装在类中。

  1. torch.tensor 根据指定数据创建张量
  2. torch.Tensor 根据形状创建张量，其也可以用来根据指定数据创建张量
  3. torch.IntTensor、torch.FloatTensor、torch.DoubleTensor创建指定类型张量
import torch
import numpy as np
import random

# 1. 根据已有的数据创造张量
def test01():
    
	# 1.1 创建标量
    data = torch.tensor(10)
    print(data)
    
    # 1.2 使用numpy数组来创建
    data = np.random.randn(2,3)
    data = torch.tensor(data)
    print(data)#pytorch默认float32
    
    # 1.3 使用list列表来创建
	data = [[10.,20.,30.],[40.,50.,60.]]
    data = torch.tensor(data)
    print(data)
    
# 2. 创建指定形状的张量
def test02():
    
    # 2.1 创建2行3列的张量
    data = torch.Tensor(2,3)
    print(data)
    
    # 2.2 创建指定值的张量
    # 注意：传递列表
    data = torch.Tensor([2,3])
    print(data)
    
    data = torch.Tensor([10])
    print(data)
    
# 3. 创建指定类型的张量
def test03():
    
    # 前面创建的张量都是使用默认类型或者元素类型
    # 创建一个int类型的张量
	data = torch.IntTensor(2,3)
    print(data)
    
    # data = torch.ShortTensor(2,3) 表示创建的是int16张量
    # data = torch.LongTensor(2,3) 表示创建的是int32张量    
    # data = torch.FloatTensor(2,3) 表示创建的是float32张量

    
	# 注意：如果创建指定类型的张量，但是传递的数据不匹配，会发生类型装换
    data = torch.IntTensor([2.5,3.5])
    print(data)

    
if __name__ == '__main__':
	test01()
    test02()
    test03()

输出

tensor([[ 0.4466, -0.2139, -0.2531],
        [-1.0478,  1.2809, -0.7754]], dtype=torch.float64)
tensor([[10., 20., 30.],
        [40., 50., 60.]])
tensor([[-2.3635e+38,  9.3186e-43,  0.0000e+00],
        [ 0.0000e+00,  0.0000e+00,  0.0000e+00]])
tensor([2., 3.])
tensor([10.])
tensor([[6357102, 7274595, 6553710],
        [3342433, 7077980, 6422633]], dtype=torch.int32)
tensor([2, 3], dtype=torch.int32)
(2) 创建线性和随机张量
  1. torch.arange和 torch.linspace 创建线性张量
  2. torch.random.init_seed 和torch.random.manual_seed 随机种子设置
  3. torch.randn 创建随机张量
import torch

# 1. 创建线性张量
def test01():
    # 1.1 创建指定步长的张量
    # 第一参数：开始值
    # 第二参数：结束值
    # 第三参数：步长
    data = torch.arange(0, 10, 2)
    print(data)

    # 1.2 在指定区间指定元素个数
    # 第一参数：开始值
    # 第二参数：结束值
    # 第三参数：创建元素的个数
    data = torch.linspace(0, 11, 10)
    print(data)

# 2. 创建随机张量
def test02():
    # 固定随机数种子
    torch.random.manual_seed(0)  # 手动设置随机数种子

    # 2.1 创建随机张量
    data = torch.randn(2, 3)
    print(data)

    # 2.2 希望能够固定随机数
    print('随机数种子：',torch.random.initial_seed())

if __name__ == '__main__':
    test01()
    test02()

输出

tensor([0, 2, 4, 6, 8])
tensor([ 0.0000,  1.2222,  2.4444,  3.6667,  4.8889,  6.1111,  7.3333,  8.5556,
         9.7778, 11.0000])
tensor([[ 1.5410, -0.2934, -2.1788],
        [ 0.5684, -1.0845, -1.3986]])
随机数种子： 0
(3) 创建01张量

  1. torch.ones 和 torch.ones_like 创建全1张量

  2. torch.zeros 和 torch.zeros_like 创建全0张量

  3. torch.full 和 torch.full_like 创建全为指定值张量

import torch

# 1. 创建全为0的张量
def test01():

    # 1.1 创建制定形状全为0的张量
    data = torch.zeros(2,3)
    print(data)

    # 1.2 根据其他张量的形状去创建全0张量
    data = torch.zeros_like(data)
    print(data)

# 2. 创建全为1的张量
def test02():

    # 1.1 创建制定形状全为1的张量
    data = torch.ones(2, 3)
    print(data)

    # 1.2 根据其他张量的形状去创建全01量
    data = torch.ones_like(data)
    print(data)

# 3. 创建全为0的张量
def test03():

    # 3.1 创建形状为2行3列，值全部为100的张量
    data = torch.full([2,3],100)
    print(data)

    # 3.2 创建一个形状和data一样，但是值全部是200的张量
    data = torch.full_like(data,200)
    print(data)

if __name__ == '__main__':
    test01()
    test02()
    test03()

输出

tensor([[0., 0., 0.],
        [0., 0., 0.]])
tensor([[0., 0., 0.],
        [0., 0., 0.]])
tensor([[1., 1., 1.],
        [1., 1., 1.]])
tensor([[1., 1., 1.],
        [1., 1., 1.]])
tensor([[100, 100, 100],
        [100, 100, 100]])
tensor([[200, 200, 200],
        [200, 200, 200]])
(4) 张量元素类型转换
  1. tensor.type(torch.DoubleTensor)
  2. torch.double()
import torch

# 1. 使用type函数进行转换
def test01():

    data = torch.full([2,3],10)
    print(data.dtype)

    # 注意：返回一个新的类型装换过的张量
    data = data.type(torch.DoubleTensor)
    print(data.dtype)
# 2. 使用具体类型函数进行转换
def test02():

    data = torch.full([2,3],10)
    print(data.dtype)

    # 转换成float64类型
    data = data.double()
    print(data.dtype)

    data.short() # 将张量元素装换为int16类型
    data.int() # 将张量元素装换为int32类型
    data.long() # 将张量元素装换为int64类型
    data.float() # 将张量元素装换为float32类型
    data.double() # 将张量元素装换为float64类型

if __name__ == '__main__':
    test01()
    test02()

输出

torch.int64
torch.float64
torch.int64
torch.float64

2 张量数值计算

💯 小结
  1. 张量基本运算

​ 加法add add_

​ 减法sub sub_

​ 乘法mul mul_

​ 除法div div_

​ 取反neg neg_

  1. 张量阿达玛积

​ *或者mul，矩阵对应位置的元素相乘

  1. 张量点积运算

​ 运算符 @ 用于进行两个矩阵的点乘运算

​ torch.mm 用于进行两个矩阵点乘运算要求输入的张量为2维

​ torch.bmm 用于批量进行矩阵点乘运算要求输入的张量为3维

​ torch.matmul 对进行点乘运算的两张量形状没有限定

  1. 制定运算设备

​ 使用 cuda 方法

​ 直接在 GPU上创建张量device="cuda:0"

​ 使用to指定设备

(1) 张量基本计算

  1. 加法add add_

  2. 减法sub sub_

  3. 乘法mul mul_

  4. 除法div div_

  5. 取反neg neg_

其中待下划线的版本为修改原数据

import torch

# 1. 不修改原数据的计算
def test01():

    # 第一个参数：开始值
    # 第二个参数：结束值
    # 第三个参数：形状
    data = torch.randint(0,10,[2,3])
    print(data)

    # 计算完成之后，会返回一个新的张量
    data = data.add(10)
    print(data)

    # data.sub() # 减法
    # data.mul() # 乘法
    # data.div() # 除法
    # data.neg() # 取相反数

# 2. 修改原数据的计算（inplace方式的计算）
def test02():

    data = torch.randint(0,10,[2,3])
    print(data)

    # 待下划线的版本的函数直接修改原数据，不需要用新的变量保存
    data.add_(10)
    print(data)

    # data.sub_() # 减法
    # data.mul_() # 乘法
    # data.div_() # 除法
    # data.neg_() # 取相反数

if __name__ == '__main__':
    test01()
    test02()

输出

tensor([[0, 5, 5],
        [9, 6, 8]])
tensor([[10, 15, 15],
        [19, 16, 18]])
tensor([[5, 9, 7],
        [6, 9, 7]])
tensor([[15, 19, 17],
        [16, 19, 17]])
(2) 阿达玛积

阿达玛积指的是矩阵对应位置的元素相乘，*或者mul

import torch

# 1. 使用mul函数
def test01():

    data1 = torch.tensor([[1,2],[3,4]])
    data2 = torch.tensor([[5,6],[7,8]])

    data = data1.mul(data2)
    print(data)

# 2. 使用*号运算符
def test02():

    data1 = torch.tensor([[1,2],[3,4]])
    data2 = torch.tensor([[5,6],[7,8]])

    data = data1 * data2
    print(data)

if __name__ == '__main__':
    test01()
    test02()

输出

tensor([[ 5, 12],
        [21, 32]])
tensor([[ 5, 12],
        [21, 32]])
(3) 点积运算

点积运算要求第一个矩阵 shape: (n,m)，第二个矩阵 shape: (m, p) 两个阵点积运算 shape 为:(n,p)。

  1. 运算符 @ 用于进行两个矩阵的点乘运算

  2. torch.mm 用于进行两个矩阵点乘运算要求输入的张量为2维

  3. torch.bmm 用于批量进行矩阵点乘运算要求输入的张量为3维

  4. torch.matmul 对进行点乘运算的两张量形状没有限定

    1. 对于输入都是二维的张量相当于 torch.mm 运算
    2. 对于输入都是三维的张量相当于 torch.bmm 运算
    3. 对数输入的 shape 不同的张量对应的最后几个维度须符合矩阵运算规则
    import torch

# 1. 使用@运算符
def test01():

    # 形状为：3行2列
    data1 = torch.tensor([[1,2],
                   [3,4],
                   [5,6]])
    # 形状为：3行2列
    data2 = torch.tensor([[5,6],
                   [7,8]])
    data = data1 @ data2
    print(data)

# 2. 使用mm函数
def test02():

    # 要求输入的张量形状都是二维
    # 形状为：3行2列
    data1 = torch.tensor([[1, 2],
                          [3, 4],
                          [5, 6]])
    # 形状为：3行2列
    data2 = torch.tensor([[5, 6],
                          [7, 8]])
    data = torch.mm(data1,data2)
    print(data)

# 3. 使用bmm函数
def test03():

    # 第一个维度：表示批次
    # 第二个维度：多少行
    # 第三个维度：多少列
    data1 = torch.randn(3,4,5)
    data2 = torch.randn(3,5,8)

    data = torch.bmm(data1,data2)
    print(data.shape)

# 4. 使用matmul函数
def test04():

    # 对二维进行计算
    data1 = torch.randn(4,5)
    data2 = torch.randn(5,8)
    print(torch.matmul(data1,data2).shape)

    # 对三维进行计算
    # 对二维进行计算
    data1 = torch.randn(3,4,5)
    data2 = torch.randn(3,5,8)
    print(torch.matmul(data1,data2).shape)

    data1 = torch.randn(3,4,5)
    data2 = torch.randn(5,8)
    print(torch.matmul(data1,data2).shape)

if __name__ == '__main__':
    test01()
    test02()
    test03()
    test04()

输出

tensor([[19, 22],
        [43, 50],
        [67, 78]])
tensor([[19, 22],
        [43, 50],
        [67, 78]])
torch.Size([3, 4, 8])
torch.Size([4, 8])
torch.Size([3, 4, 8])
torch.Size([3, 4, 8])
(4) 指定运算设备

PyTorch 默认会将张量创建在 CPU 控制的内存中,默认的运算设备为 CPU。

我们也可以将张量创建在GPU 上能够利用对于矩阵计算的优势加快模型训练。

将张量移动到 GPU 上有方法:

  1. 使用 cuda 方法
  2. 直接在 GPU上创建张量
  3. 使用to 法指定设备

查看torch版本和cuda是否可用：

import torch
print(torch.__version__)
print(torch.cuda.is_available())

输出

2.0.1+cu117
True

import torch

# 1. 使用cuda方法
def test01():

   data = torch.tensor([10,20,30])
   print("存储设备:",data.device)

   # 将张量移动到GPU设备上
   data = data.cuda()
   print("存储设备:",data.device)

   # 将张量从GPU再移动到CPU
   data = data.cpu()
   print("存储设备:",data.device)

# 2. 直接讲张量创建在GPU上
def test02():

   data = torch.tensor([10,20,30],device="cuda:0")
   print("存储设备：",data.device)

   # 将张量从GPU再移动到CPU
   data = data.cpu()
   print("存储设备:",data.device)

# 3. 使用to方法
def test03():

   data = torch.tensor([10,20,30])
   print("存储设备:",data.device)

   # 使用to方法移动张量到指定设备
   data = data.to("cuda:0")
   print("存储设备:",data.device)

# 4. 注意：存储在不同设备上的张量不能直接进行运算
def test04():

   data1 = torch.tensor([10,20,30])
   data2 = torch.tensor([10,20,30],device="cuda:0")

   # RuntimeError: Expected all tensors to be on the same device, but found at least two devices, cuda:0 and cpu!
   # 以下代码会报错

   # 如果你的电脑上安装pytorch不是gpu版本的，或者电脑本身没有gpu（nvidia）设备环境
   # 否则下面的调用cuda函数的代码会报错
   data1 = data1.cuda()

   data = data1 + data2
   print(data)

if __name__ == '__main__':
   test01()
   test02()
   test03()
   test04()

输出

存储设备: cpu
存储设备: cuda:0
存储设备: cpu
存储设备： cuda:0
存储设备: cpu
存储设备: cpu
存储设备: cuda:0
tensor([20, 40, 60], device='cuda:0')

3 张量类型转换

💯 小结
  1. tensor.numpy函数可以将张量转换为ndarry数组，共享内存，使用copy函数避免共享
  2. torch.from_numpy（浅拷贝）可以将ndarry数组转换为tensor，共享内存，使用copy函数避免共享
  3. torch.tensor（深拷贝）可以将ndarry数组转换为tensor，不共享内存
  4. item方法将该值从张量中提取出来(只有一个元素的张量)
(1) 张量转换为numpy数组

使用tensor.numpy函数可以将张量转换为ndarry数组

但是共享内存，可以使用copy函数避免共享

import torch

# 1. 张量转换为numpy数组
def test01():
     data_tensor = torch.tensor([2,3,4])
     # 将张量转换为numpy数组
     data_numpy = data_tensor.numpy()
     print(type(data_tensor))
     print(type(data_numpy))

     print(data_tensor)
     print(data_numpy)

# 2. 张量和numpy数组共享内存
def test02():

    data_tensor = torch.tensor([2,3,4])
    data_numpy = data_tensor.numpy()

    # 修改张量元素的值，看看numpy数组是否会发生变化？
    # data_tensor[0] = 100
    # print(data_tensor)
    # print(data_numpy)

    # 修改numpy数组元素的值，看看张量是否会发生变化？
    data_numpy[0] = 100
    print(data_tensor)
    print(data_numpy)

# 3. 使用copy函数使用不共享内存
def test03():

    data_tensor = torch.tensor([2,3,4])
    # 此处，发生了类型转换，可以使用拷贝函数产生新的数据，避免共享内存
    data_numpy = data_tensor.numpy().copy()

    # 修改张量元素的值，看看numpy数组是否会发生变化？
    data_tensor[0] = 100
    print(data_tensor)
    print(data_numpy)

if __name__ == '__main__':
    test01()
    test02()
    test03()

输出

<class 'torch.Tensor'>
<class 'numpy.ndarray'>
tensor([2, 3, 4])
[2 3 4]
tensor([100,   3,   4])
[100   3   4]
tensor([100,   3,   4])
[2 3 4]
(2) numpy转换为张量
  1. torch.from_numpy（浅拷贝）可以将ndarry数组转换为tensor，默认共享内存，使用copy函数避免共享。
  2. torch.tensor（深拷贝）可以将ndarry数组转换为tensor，默认不共享内存
import torch
import numpy as np

# 1. from_numpy函数的用法
def test01():

    data_numpy = np.array([2,3,4])
    data_tensor = torch.from_numpy(data_numpy.copy())

    print(type(data_numpy))
    print(type(data_tensor))

    # 默认共享内存
    # data_numpy[0] = 100
    data_tensor[0] = 100
    print(data_numpy)
    print(data_tensor)

# 2. torch.tensor函数的用法
def test02():

    data_numpy = np.array([2, 3, 4])
    data_tensor = torch.tensor(data_numpy)

    # 默认不！共！享！内存
    # data_numpy[0] = 100
    data_tensor[0] = 100
    print(data_numpy)
    print(data_tensor)

if __name__ == '__main__':
    test01()
    test02()

输出

<class 'numpy.ndarray'>
<class 'torch.Tensor'>
[2 3 4]
tensor([100,   3,   4], dtype=torch.int32)
[2 3 4]
tensor([100,   3,   4], dtype=torch.int32)
(3) 标量张量和数字的转换

item方法将该值从张量中提取出来(只有一个元素的张量)

import torch

def test():

    t1 = torch.tensor(30)
    t2 = torch.tensor([30])
    t3 = torch.tensor([[30]])

    print(t1.shape)
    print(t2.shape)
    print(t3.shape)

    print(t1.item())
    print(t2.item())
    print(t3.item())

    # 注意：张量中只有一个元素，如果有多个元素的话，使用item函数可能就会报错
    # RuntimeError: a Tensor with 2 elements cannot be converted to Scalar
    # t4 = torch.tensor([30,40])
    # print(t4.item())

if __name__ == '__main__':
    test()

输出

torch.Size([])
torch.Size([1])
torch.Size([1, 1])
30
30
30

4 张量拼接操作

💯 小结
  1. torch.cat函数可以将两个张量根据指定的维度拼接起来
  2. torch.stack函数可以将两个张量根据指定的维度叠加起来
(1) torch.cat函数的使用

torch.cat函数可以将两个张量根据指定的维度拼接起来，是频繁使用的函数

import torch

def test():

    # 固定随机数种子
    torch.manual_seed(0)

    data1 = torch.randint(0, 10, [3, 4, 5])
    data2 = torch.randint(0, 10, [3, 4, 5])

    print(data1.shape)
    print(data2.shape)

    # 1. 按照0维度进行拼接
    new_data = torch.cat([data1, data2], dim=0)
    print(new_data.shape)

    # 2. 按照1维度进行拼接
    new_data = torch.cat([data1, data2], dim=1)
    print(new_data.shape)

    # 3. 按照2维度进行拼接
    new_data = torch.cat([data1, data2], dim=2)
    print(new_data.shape)

    # 注意： dim必须保证是有效

if __name__ == '__main__':
    test()

输出

torch.Size([3, 4, 5])
torch.Size([3, 4, 5])
torch.Size([6, 4, 5])
torch.Size([3, 8, 5])
torch.Size([3, 4, 10])
(2) torch.stack函数的使用

torch.stack函数可以将两个张量根据指定的维度叠加起来

import torch

def test():

    torch.manual_seed(0)
    data1 = torch.randint(0, 10, [2, 3])
    data2 = torch.randint(0, 10, [2, 3])

    print(data1)
    print(data2)
    print('-'*30)

    # 将两个张量stack起来，想cat一样指定维度
    # 1. 按照0维度进行叠加
    new_data = torch.stack([data1,data2],dim=0)
    print(new_data.shape)
    print(new_data)
    print('-' * 30)


    # 2. 按照1维度进行叠加
    new_data = torch.stack([data1,data2],dim=1)
    print(new_data.shape)
    print(new_data)
    print('-' * 30)

    # 2. 按照2维度进行叠加
    new_data = torch.stack([data1, data2], dim=2)
    print(new_data.shape)
    print(new_data)
    print('-' * 30)

if __name__ == '__main__':
    test()

输出

tensor([[4, 9, 3],
        [0, 3, 9]])
tensor([[7, 3, 7],
        [3, 1, 6]])
------------------------------
torch.Size([2, 2, 3])
tensor([[[4, 9, 3],
         [0, 3, 9]],

        [[7, 3, 7],
         [3, 1, 6]]])
------------------------------
torch.Size([2, 2, 3])
tensor([[[4, 9, 3],
         [7, 3, 7]],

        [[0, 3, 9],
         [3, 1, 6]]])
------------------------------
torch.Size([2, 3, 2])
tensor([[[4, 7],
         [9, 3],
         [3, 7]],

        [[0, 3],
         [3, 1],
         [9, 6]]])
------------------------------

5 张量索引操作

💯 小结
  1. 简单行、列索引

data[1,2], data[1][2]获得指定位置的某个元素

data[:, 0]获得第1列的元素

  1. 列表索引

data[[0, 2, 3], [0, 1, 2]]获得(0, 0)、(2, 1)、(3, 2)三个位置的元素

data[[[0], [2], [3]], [0, 1, 2]]获得0、2、3行的0、1、2列

  1. 范围索引

data[:3, 2]获得的前3行，再获得第2列的数据

  1. 布尔索引

data[data[:, 1] > 6返回第2列元素大于6的行

  1. 多维索引

data[0, :, :]按照第0个维度选择第0元素，4行5列元素

(1) 简单行、列索引
(2) 列表索引
(3) 范围索引
import torch

# 1. 简单行列索引
def test01():

    data = torch.randint(0, 10, [4, 5])
    print(data)
    print('-' * 30)

    # 1.1 获得指定的某行元素
    print(data[0])

    # 1.2 获得指定的某列元素
    # 逗号前面表示行，逗号后面表示列
    # 冒号表示所有行或者所有列

    # 表示获得第1列的元素
    print(data[:, 0])

    # 获得指定位置的某个元素
    print(data[1,2], data[1][2])
    
# 3. 范围索引 

    # 表示先获得的前3行，再获得第2列的数据
    print(data[:3, 2])

    # 表示获得前3行的前2列
    print(data[:3, :2])

# 2. 列表索引
def test02():

    # 固定随机数种子
    torch.manual_seed(0)

    data = torch.randint(0, 10, [4, 5])
    print(data)
    print('-' * 30)

    # 如果索引的行列都是一个1维的列表，那么两个列表的长度必须相等
    # 表示获得(0, 0)、(2, 1)、(3, 2)三个位置的元素
    print(data[[0, 2, 3], [0, 1, 2]])

    # 表示获得0、2、3行的0、1、2列
    print(data[[[0], [2], [3]], [0, 1, 2]])

if __name__ == '__main__':
    test01()
    test02()

输出

tensor([[1, 0, 1, 6, 3],
        [2, 9, 7, 5, 4],
        [1, 0, 9, 9, 8],
        [2, 1, 5, 7, 7]])
------------------------------
tensor([1, 0, 1, 6, 3])
tensor([1, 2, 1, 2])
tensor(7) tensor(7)
tensor([1, 7, 9])
tensor([[1, 0],
        [2, 9],
        [1, 0]])
tensor([[4, 9, 3, 0, 3],
        [9, 7, 3, 7, 3],
        [1, 6, 6, 9, 8],
        [6, 6, 8, 4, 3]])
------------------------------
tensor([4, 6, 8])
tensor([[4, 9, 3],
        [1, 6, 6],
        [6, 6, 8]])
(4) 布尔索引
(5) 多维索引
import torch

# 1. 布尔索引
def test01():

    torch.manual_seed(0)
    data = torch.randint(0, 10, [4, 5])
    print(data)

    # 希望能够获得该张量中所有大于3的元素
    print(data[data > 3])

    # 希望返回第2列元素大于6的行
    print(data[data[:, 1] > 6])

    # 希望返回第2行元素大于3的所有列
    print(data[:, data[1] > 3])

# 2. 多维索引
def test02():

    torch.manual_seed(0)
    data = torch.randint(0, 10, [3, 4, 5])
    print(data)
    print('-' * 30)

    # 按照第0个维度选择第0元素，4行5列元素
    print(data[0, :, :])
    print('-' * 30)

    # 按照第1个维度选择第0元素
    print(data[:, 0, :])
    print('-' * 30)

    # 按照第2个维度选择第0元素
    print(data[:, :, 0])
    print('-' * 30)

if __name__ == '__main__':
    test01()
    test02()

输出

tensor([[4, 9, 3, 0, 3],
        [9, 7, 3, 7, 3],
        [1, 6, 6, 9, 8],
        [6, 6, 8, 4, 3]])
tensor([4, 9, 9, 7, 7, 6, 6, 9, 8, 6, 6, 8, 4])
tensor([[4, 9, 3, 0, 3],
        [9, 7, 3, 7, 3]])
tensor([[4, 9, 0],
        [9, 7, 7],
        [1, 6, 9],
        [6, 6, 4]])
tensor([[[4, 9, 3, 0, 3],
         [9, 7, 3, 7, 3],
         [1, 6, 6, 9, 8],
         [6, 6, 8, 4, 3]],

        [[6, 9, 1, 4, 4],
         [1, 9, 9, 9, 0],
         [1, 2, 3, 0, 5],
         [5, 2, 9, 1, 8]],

        [[8, 3, 6, 9, 1],
         [7, 3, 5, 2, 1],
         [0, 9, 3, 1, 1],
         [0, 3, 6, 6, 7]]])
------------------------------
tensor([[4, 9, 3, 0, 3],
        [9, 7, 3, 7, 3],
        [1, 6, 6, 9, 8],
        [6, 6, 8, 4, 3]])
------------------------------
tensor([[4, 9, 3, 0, 3],
        [6, 9, 1, 4, 4],
        [8, 3, 6, 9, 1]])
------------------------------
tensor([[4, 9, 1, 6],
        [6, 1, 1, 5],
        [8, 7, 0, 0]])
------------------------------

6 张量形状操作

💯 小结
  1. reshape函数可以在保证张量数据不变的前提下改变数据的维度
  2. torch.transpose可以一次性交换2个维度
  3. torch.permute可以一次性交换多个维度
  4. view函数也可用于修改张量的形状，但是用法比较局限，只能用于存储在整块内存中的张量
  5. squeeze函数用删除shape为1的维度
  6. unsqueeze函数在每个维度添加1，以增加数据的形状
(1) reshape函数的用法

  1. shape size()可以查看张量的形状

  2. reshape函数可以在保证张量数据不变的前提下改变数据的维度，将其转换成指定的形状

import torch

def test():

    torch.manual_seed(0)
    data = torch.randint(0, 10, [4, 5])

    # 查看张量的形状
    print(data.shape, data.shape[0], data.shape[1])
    print(data.size(), data.size(0), data.size(1))

    # 修改张量的形状
    new_data = data.reshape(2, 10)
    print(new_data)

    # 注意：转换之后的形状元素个数得等于原来张量的元素个数
    # new_data = data.reshape(1, 10)
    # print(new_data)

    # 使用-1代替省略的形状
    new_data = data.reshape(5, -1)
    print(new_data)

if __name__ == '__main__':
    test()

输出

torch.Size([4, 5]) 4 5
torch.Size([4, 5]) 4 5
tensor([[4, 9, 3, 0, 3, 9, 7, 3, 7, 3],
        [1, 6, 6, 9, 8, 6, 6, 8, 4, 3]])
tensor([[4, 9, 3, 0],
        [3, 9, 7, 3],
        [7, 3, 1, 6],
        [6, 9, 8, 6],
        [6, 8, 4, 3]])
(2) torch.transpose和torch.permute函数的使用
  1. torch.transpose可以一次性交换2个维度
  2. torch.permute可以一次性交换多个维度
  3. 本质上都是在修改数据的维度
import torch

# 1. transpose函数
def test01():

    torch.manual_seed(0)
    data = torch.randint(0, 10, [3, 4, 5])

    new_data = data.reshape(4, 3, 5)
    print(new_data.shape)

    # 直接交换两个维度的值
    new_data = torch.transpose(data, 1, 2)
    print(new_data.shape)

    # 缺点： 一次只能交换两个维度
    # 把数据的形状变成(4, 5, 3)
    # 进行第一次交换：(4, 3, 5)
    # 进行第二次交换：(4, 5, 3)
    new_data = torch.transpose(data, 0, 1)
    new_data = torch.transpose(new_data, 1, 2)
    print(new_data.shape)

# 2. permute函数
def test02():

    torch.manual_seed(0)
    data = torch.randint(0, 10, [3, 4, 5])

    # permute可以一次性交换多个维度
    new_data = torch.permute(data, [1, 2, 0])
    print(new_data.shape)

if __name__ == '__main__':
    test01()
    test02()

输出

torch.Size([4, 3, 5])
torch.Size([3, 5, 4])
torch.Size([4, 5, 3])
torch.Size([4, 5, 3])
(3) view和contigous函数的用法
  1. view函数也可用于修改张量的形状，但是用法比较局限，只能用于存储在整块内存中的张量。例：经过torch.transpose或torch.permute函数处理之后的张量，无法使用view函数进行形状操作
  2. is_contiguous判断是否连续
  3. contiguous将张量连续化
import torch

# 1. view函数的使用
def test01():

    data = torch.tensor([[10, 20, 30], [40, 50, 60]])
    data = data.view(3, 2)
    print(data.shape)

    # is_contiguous函数来判断张量是否是连续内存空间（整块的内存）
    print(data.is_contiguous())

# 2. view函数使用注意
def test02():

    # 当张量经过transpose或者pre，ute函数之后，内存空间基本不连续
    # 此时，必须先把空间连续，才能够使用view函数进行张量形状操作

    data = torch.tensor([[10, 20, 30], [40, 50, 60]])
    print('是否连续：', data.is_contiguous())
    data = torch.transpose(data, 0, 1)
    print('是否连续：', data.is_contiguous())

    # 此时，在不连续内存的情况下使用view会怎么样呢？
    data = data.contiguous().view(2, 3)
    print(data)

if __name__ == '__main__':
    test01()
    test02()

输出

torch.Size([3, 2])
True
是否连续： True
是否连续： False
tensor([[10, 40, 20],
        [50, 30, 60]])
(4) squeeze和unsqueeze函数的用法
  1. squeeze函数用删除shape为1的维度
  2. unsqueeze函数在每个维度添加1，以增加数据的形状
import torch

# 1. squeeze函数使用
def test01():

    data = torch.randint(0, 10, [1, 3, 1, 5])
    print(data.shape)

    # 维度压缩，默认去掉所有1的维度
    new_data = data.squeeze()
    print(new_data.shape)

    # 指定去掉某个1的维度
    new_data = data.squeeze(2)
    print(new_data.shape)

# 2. unsqueeze函数使用
def test02():

    data = torch.randint(0, 10, [3, 5])
    print(data.shape)

    # 可以在指定位置增加维度
    # -1 代表最后一个维度
    new_data = data.unsqueeze(-1)
    print(new_data.shape)

if __name__ == '__main__':
    test01()
    test02()

输出

torch.Size([1, 3, 1, 5])
torch.Size([3, 5])
torch.Size([1, 3, 5])
torch.Size([3, 5])
torch.Size([3, 5, 1])

7 张量运算函数

💯 小结
  1. mean均值
  2. sum求和
  3. pow次方
  4. sqrt平方根
  5. expe多少次方
  6. log对数
import torch

# 1. 均值
def test01():

    torch.manual_seed(0)
    # data = torch.randint(0, 10, [2, 3], dtype=torch.float64)
    data = torch.randint(0, 10, [2, 3]).double()
    # print(data.dtype)

    print(data)
    # 默认对所有的数据计算均值
    print(data.mean())
    # 按指定的维度计算均值
    print(data.mean(dim=0))
    print(data.mean(dim=1))

# 2. 求和
def test02():

    torch.manual_seed(0)
    data = torch.randint(0, 10, [2, 3]).double()

    print(data.sum())
    print(data.sum(dim=0))
    print(data.sum(dim=1))

# 3. 平方
def test03():

    torch.manual_seed(0)
    data = torch.randint(0, 10, [2, 3]).double()

    print(data)
    print(data.pow(2))

# 4. 平方根
def test04():

    torch.manual_seed(0)
    data = torch.randint(0, 10, [2, 3]).double()

    print(data)
    print(data.sqrt())

# 5. e多少次方
def test05():

    torch.manual_seed(0)
    data = torch.randint(0, 10, [2, 3]).double()

    print(data)
    print(data.exp())

# 6. 对数
def test06():

    torch.manual_seed(0)
    data = torch.randint(0, 10, [2, 3]).double()

    print(data)
    print(data.log()) # 以e为底
    print(data.log2())  # 以2为底
    print(data.log10())  # 以10为底

if __name__ == '__main__':
    test01()
    print('-' * 30)
    test02()
    print('-' * 30)
    test03()
    print('-' * 30)
    test04()
    print('-' * 30)
    test05()
    print('-' * 30)
    test06()

输出

tensor([[4., 9., 3.],
        [0., 3., 9.]], dtype=torch.float64)
tensor(4.6667, dtype=torch.float64)
tensor([2., 6., 6.], dtype=torch.float64)
tensor([5.3333, 4.0000], dtype=torch.float64)
------------------------------
tensor(28., dtype=torch.float64)
tensor([ 4., 12., 12.], dtype=torch.float64)
tensor([16., 12.], dtype=torch.float64)
------------------------------
tensor([[4., 9., 3.],
        [0., 3., 9.]], dtype=torch.float64)
tensor([[16., 81.,  9.],
        [ 0.,  9., 81.]], dtype=torch.float64)
------------------------------
tensor([[4., 9., 3.],
        [0., 3., 9.]], dtype=torch.float64)
tensor([[2.0000, 3.0000, 1.7321],
        [0.0000, 1.7321, 3.0000]], dtype=torch.float64)
------------------------------
tensor([[4., 9., 3.],
        [0., 3., 9.]], dtype=torch.float64)
tensor([[5.4598e+01, 8.1031e+03, 2.0086e+01],
        [1.0000e+00, 2.0086e+01, 8.1031e+03]], dtype=torch.float64)
------------------------------
tensor([[4., 9., 3.],
        [0., 3., 9.]], dtype=torch.float64)
tensor([[1.3863, 2.1972, 1.0986],
        [  -inf, 1.0986, 2.1972]], dtype=torch.float64)
tensor([[2.0000, 3.1699, 1.5850],
        [  -inf, 1.5850, 3.1699]], dtype=torch.float64)
tensor([[0.6021, 0.9542, 0.4771],
        [  -inf, 0.4771, 0.9542]], dtype=torch.float64)

8 自动微分模块

💯 小结

  1. 首先要设置属性requires_grad=True，计算梯度的张量

  2. backward自动微分，必须是一个标量

  3. grad访问梯度值

  4. 控制梯度

    1. with torch.no_grad():第一种方法：不参与梯度计算

    2. # 第二种方法：装饰器
@torch.no_grad()
    def my_func(x):
        return x**2

    3. torch.set_grad_enabled(False)第三种方法：全局的方式（会影响其他代码）

  5. 累计梯度和梯度清零

if x.grad is not None:
    x.grad.data.zero_()
  1. 梯度下降法 w = w − α ∗ ∇ f w=w-\alpha*\nabla f w=w−α∗∇f
  2. 要先使用detach函数进行分离，再使用numpy函数
(1) 梯度基本计算

  1. 要计算梯度的张量，首先要设置属性requires_grad=True

  2. backward自动微分，必须是一个标量，一般使用mean 或sum把向量值变成一个标量，然后再进行backward反向传播（反向梯度求导）

  3. grad访问梯度值

import torch

# 1. 标量的梯度计算
# y = x ** 2 + 20
def test01():

    # 对于需要求导的张量需要设置requires_grad=True
    x = torch.tensor(10, requires_grad=True, dtype=torch.float64)

    # 对x的中间计算
    f = x ** 2 + 20    # 2x

    # 自动微分
    f.backward()

    # 访问梯度
    print(x.grad)

# 2. 向量的梯度计算
def test02():

    x = torch.tensor([10, 20, 30, 40], requires_grad=True, dtype=torch.float64)
    # 定义变量的计算过程
    y1 = x ** 2 + 20

    # 注意：自动微分的时候，必须是一个标量
    y2 = y1.mean()    # 1/4 * y1 ==> 1/4 * 2x

    # 自动微分
    y2.backward()

    # 打印梯度值
    print(x.grad)

# 3. 多标量的梯度计算
# y = x1**2 + x2**2 + x1*x2
def test03():

    x1 = torch.tensor(10, requires_grad=True, dtype=torch.float64)
    x2 = torch.tensor(20, requires_grad=True, dtype=torch.float64)

    # 中间计算过程
    y = x1**2 + x2**2 + x1*x2

    # 自动微分
    y.backward()

    # 打印梯度值
    print(x1.grad)
    print(x2.grad)

# 4. 多向量的梯度计算
def test04():

    x1 = torch.tensor([10, 20], requires_grad=True, dtype=torch.float64)
    x2 = torch.tensor([30, 40], requires_grad=True, dtype=torch.float64)

    # 定义中间计算过程
    y = x1**2 + x2**2 + x1*x2

    # 将输出结果变为标量
    y = y.sum()

    # 自动微分
    y.backward()

    # 打印梯度值
    print(x1.grad)
    print(x2.grad)

if __name__ == '__main__':
    test01()
    print('-' * 30)
    test02()
    print('-' * 30)
    test03()
    print('-' * 30)
    test04()

输出

tensor(20., dtype=torch.float64)
------------------------------
tensor([ 5., 10., 15., 20.], dtype=torch.float64)
------------------------------
tensor(40., dtype=torch.float64)
tensor(50., dtype=torch.float64)
------------------------------
tensor([50., 80.], dtype=torch.float64)
tensor([ 70., 100.], dtype=torch.float64)
(2) 控制梯度计算

  1. 控制梯度计算三种方式

    1. with torch.no_grad():第一种方法：不参与梯度计算

    2. @torch.no_grad()
    def my_func(x):
        return x**2

      第二种方法：装饰器

    3. torch.set_grad_enabled(False)第三种方法：全局的方式（会影响其他代码）

  2. 累计梯度和梯度清零

    if x.grad is not None:
    x.grad.data.zero_()

  3. 梯度下降法 w = w − α ∗ ∇ f w=w-\alpha*\nabla f w=w−α∗∇f

import torch

# 1. 控制梯度计算
def test01():

    x = torch.tensor(10, requires_grad=True, dtype=torch.float64)
    print(x.requires_grad)

    # 1. 第一种方法：不参与梯度计算
    with torch.no_grad():
        y = x**2
    print(y.requires_grad)

    # 2. 第二种方法：装饰器
    @torch.no_grad()
    def my_func(x):
        return x**2

    y = my_func(x)
    print(y.requires_grad)

    # 3.第三种方法：全局的方式（会影响其他代码）
    torch.set_grad_enabled(False)
    y = x**2
    print(y.requires_grad)
    
if __name__ == '__main__':
    test01()

输出

True
False
False
False

import torch

# 2. 累计梯度和梯度清零
def test02():

    x = torch.tensor([10, 20, 30, 40], requires_grad=True, dtype=torch.float64)

    # 当我们重复对x进行梯度计算的时候，是会将历史的梯度值累加到x.grad属性中
    # 希望不要去累加历史梯度
    for _ in range(3):

        # 对输入x的计算过程
        f1 = x**2 + 20
        # 将向量转换成标量
        f2 = f1.mean()

        # 梯度清零
        if x.grad is not None:
            x.grad.data.zero_()

        # 自动微分
        f2.backward()
        print(x.grad)

# 3. 案例-梯度下降优化函数
def test03():

    # y = x**2
    # 当x为什么值的情况下，y最小

    # 初始化
    x = torch.tensor(10, requires_grad=True, dtype=torch.float64)

    for _ in range(1000):

        # 正向计算
        y = x**2

        # 梯度清零
        if x.grad is not None:
            x.grad.data.zero_()

        # 反向传播（自动微分）
        y.backward()

        # 更新参数
        x.data = x.data - 0.01 * x.grad

        # 打印x的值
        print('%.10f' % x.data)

if __name__ == '__main__':
    test02()
    print('-' * 30)
    test03()

输出

tensor([ 5., 10., 15., 20.], dtype=torch.float64)
tensor([ 5., 10., 15., 20.], dtype=torch.float64)
tensor([ 5., 10., 15., 20.], dtype=torch.float64)
------------------------------
9.8000000000
9.6040000000
......
0.0000000175
0.0000000172
0.0000000168
(3) 梯度计算注意

当设置requires_grad=True的张量使用numpy函数进行转换时，会出现以下报错：

RuntimeError: Can't call numpy() on Tensor that requires grad. Use tensor.detach().numpy() instead.

此时，需要先使用detach函数进行分离，再使用numpy函数

注意：detach之后又会产生一个新的张量，新的张量作为叶子结点，并且该张量和原来张量共享数据，但是分离之后的张量不需要计算梯度。

import torch

# 1. 演示下错误
def test01():

    x = torch.tensor([10, 20], requires_grad=True, dtype=torch.float64)

    # RuntimeError: Can't call numpy() on Tensor that requires grad. Use tensor.detach().numpy() instead.
    # print(x.numpy())
    # 下面是正确的操作
    print(x.detach().numpy())

# 2. 共享数据
def test02():

    # x是叶子节点
    x1 = torch.tensor([10, 20], requires_grad=True, dtype=torch.float64)
    # 使用detach函数分离出一个新的张量
    x2 = x1.detach()

    print(id(x1.data), id(x2.data))

    # 修改分离后产生的新的张量
    x2[0] = 100

    print(x1)
    print(x2)

    # 通过结果我们发现，x2张量不存在requires_grad=True
    # 表示：对x1的任何计算都会影响到对x1的梯度计算
    # 但是，对x2的任何计算不会影响到对x1的梯度计算

    print(x1.requires_grad)
    print(x2.requires_grad)

if __name__ == '__main__':
    test01()
    test02()

输出

[10. 20.]
2429421557136 2429421557136
tensor([100.,  20.], dtype=torch.float64, requires_grad=True)
tensor([100.,  20.], dtype=torch.float64)
True
False

9 案例-构建线性回归

On3K3y
关注
专栏目录
【黑马程序员自然语言处理实战课程】学习笔记---pytorch基础知识和autograd
weixin_43444329的博客
12-07 5132
1.1什么是pytorch pytorch是一个基于Numpy的科学计算包，向他的使用者提供两大功能 作为numpy的替代者，向用户提供GPU强大功能的能力； 作为一款深度学习的平台，向用户提供最大的灵活性和速度 pytorch基本元素操作： tensor张量：类似于numpy中的ndarray数据结构，最大区别在于tensor可以利用GPU的加速功能。 需要先将torch引用进来 from __future__ import print_function import torch 1..
Deep-Learning-with-PyTorch.rar
07-12
《PyTorch深度学习实践详解》 PyTorch是一款由Facebook研发的开源机器学习库，以其易用性、灵活性和高效性...通过本教程，你将能够熟练运用PyTorch进行各种深度学习任务，从基础模型到复杂的网络结构，都能游刃有余。
深度学习笔记其一：基础知识和PYTORCH
泠山的博客
08-14 826
为了能够完成各种数据操作，我们需要某种方法来存储和操作数据。 通常，我们需要做两件重要的事：首先，我们介绍 nnn 维数组，也称为。 使用过 Python 中 NumPy 计算包的读者会对本部分很熟悉。 无论使用哪个深度学习框架，它的张量类(在 MXNet 中为 ndarray， 在 PyTorch 和 TensorFlow 中为 Tensor）都与 Numpy 的 ndarray 类似。但深度学习框架又比 Numpy 的 ndarray 多一些重要功能：首先，GPU 很好地支持加速计算，而 NumPy 仅
深度学习基础教程
悠眠小虫的博客
01-10 1841
本文适用于神经网络前期的学习，了解PyTorch的基本使用方法及实现简单模型的建立。
PyTorch入门——（黑马程序员视频学习笔记）
zhang_ysx的博客
03-12 590
对比有无初始化的矩阵：当声明一个未初始化的矩阵时，它本身不包含任何确切的值。当创建一个未初始化的矩阵时，分配给内存中有什么数值就赋值给了这个矩阵，本质上是毫无意义的数据.
深度学习框架pytorch_PyTorch：深度学习框架的黑马（第1部分）
weixin_26737625的博客
08-25 1167
深度学习框架pytorchRecently the CES 2020 concluded in Vegas and for those who aren’t aware, CES is the annual trade show for consumer electronics around the world. As such, it an excellent indicator of the ...
Dive-into-DL-PyTorch-master (2).zip
03-05
《动手学深度学习PyTorch版》是一本深入浅出的深度学习教程，它结合了理论与实践，旨在帮助读者掌握PyTorch这一强大的深度学习框架。PyTorch以其灵活性和易用性受到广大研究者和开发者的青睐，是进行深度学习研究和...
Dive-into-DL-PyTorch.rar
06-10
《深入学习PyTorch》是针对深度学习框架PyTorch的一本详细教程，旨在帮助读者掌握PyTorch的核心概念和实际应用。PyTorch是由Facebook的AI研究团队开发的一个开源库，它为机器学习和神经网络提供了一个强大的平台，...
Dive-into-DL-Pytorch_深度学习_
09-30
深度学习是现代人工智能领域的重要分支，它通过模拟人脑神经网络的工作原理，处理复杂的数据问题。...通过深入阅读这本书，你可以掌握深度学习的基本概念和PyTorch的实战技巧，为你的AI项目打下坚实基础。
ComputerVision-with-PyTorch-Learning-Program:由TinkerHub Foundation使用PyTorch学习程序进行计算机视觉
03-09
是一个由创建的开源深度学习框架。 该学习计划将涵盖以下内容， 计算机视觉。 Pytorch框架。 Torchvision库。 图像分类和目标检测。 转移学习。 我们将广泛使用PyTorch文档进行此程序。 参加者标准 应该知道...
黑马程序员Python学习笔记，代码使用Pycharm编写。
IN year
09-14 3763
黑马程序员Python学习笔记，全阶段学习，新手、基础、进阶。代码使用pycharm编写。 很详细！！
使用pytorch构建图片分类器
IT之一小佬的博客
12-09 3635
分类器任务和数据介绍 构造一个将不同图像进行分类的神经网络分类器, 对输入的图片进行判别并完成分类. 本案例采用CIFAR10数据集作为原始图片数据. CIFAR10数据集介绍: 数据集中每张图片的尺寸是3 * 32 * 32, 代表彩色3通道 CIFAR10数据集总共有10种不同的分类, 分别是"airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck". CIF
黑马程序员人工智能NLP基础教程1——pytorch
qq_42832272的博客
04-06 982
pytorch构建分类器 import numpy as np import matplotlib.pyplot as plt import torch #构建展示图像的函数 def imshow(img): img = img/2+0.5 #固定格式 npimg = img.numpy() #将图像tensor类型转换为numpy类型才能显示 plt.imshow(np.transpose(npimg,(1,2,0))) plt.show() #从数据地带其中读取一
面向程序员的深度学习实战课程(2019)(PyTorch/fastai)
追随梦想，实现梦想
10-19 296
面向程序员的深度学习实战课程(2019)(PyTorch/fastai) https://www.bilibili.com/video/av41718196
python pytorch教程_基于PyTorch的深度学习入门教程
weixin_31919471的博客
01-13 528
本文是关于Part1的内容。Part1：PyTorch简单知识PyTorch是一个基于Python的科学计算框架，用于进行深度学习相关研究。对于Python语言的入门，可以参考之前的两篇介绍Python&Numpy的博客。分别是Python& Numpy 教程(上) 和Python & Numpy 教程(下)。这里我们就直接介绍PyTorch中的基本操作。1 Tensors...
基于OpenFOAM和深度学习驱动的流体力学计算与应用
2301_80236428的博客
11-14 731
从物理模型融合到复杂流动模拟，从数据驱动研究到流场智能分析，深度学习正以前所未有的力量重塑流体力学领域。伴随深度学习在流体力学研究中应用的普及，相关的开源软件和工具为科研人员提供了便捷的平台，简化了深度学习模型的实现与应用过程，加速了研究成果的转化。深度学习架构能够有效从流体数据中抽取关键特征，应用于流场预测、流动优化、流场可视化等多个领域，极大地提升了流体问题的分析效率和精度。构建物理增强的深度学习模型，将流体力学的控制方程、边界条件等物理规则内嵌于模型中，以提高模型的准确性和物理一致性。
深度学习：利用随机数据更快地测试一个新的模型在自己数据格式很复杂的时候
weixin_44162814的博客
11-14 330
比如下面一个，我自己的数据很复杂，这里在代码最后用，两分钟就完成了代码的测试成功。
基于YOLOv8深度学习的智慧农业野生蓝莓成熟度小目标检测系统研究与实现(PyQt5界面+数据集+训练代码)
ZSW1218的博客
11-17 521
随着智慧农业技术的不断进步，传统农业逐渐向自动化、智能化转型，特别是在果实成熟度检测领域，精确、及时的检测手段已成为提升农业生产效率和优化资源配置的重要工具。
2024 - 超火的多模态深度学习公共数据纯生信5+思路分享
最新发布
itwangyang520的博客
11-17 340
研究通过决策曲线（DCA）分析也观察到所有队列中，与基于病理的生存模型、基因特征和单独的病理特征相比，DeepClinMed-PGM模型性能始终更优越（图2G-I），这一结果强调了DeepClinMed-PGM模型在早期DFS预测中的重要临床价值。**首先为了评估临床特征对乳腺癌患者DFS的预测作用，研究在训练和试验队列进行了单因素回归分析，结果发现年龄、分期、T分期和N分期等临床特征不能独立预测乳腺癌患者的DFS，而多模态风险评分在训练和试验队列中都是更有效的预测因子（图5A-B ）。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值