深度学习基础--11个专题带你入门Pytorch上

于 2024-08-27 19:21:02 发布
阅读量670 收藏 4
点赞数 20
分类专栏： 深度学习/神经网络基础讲解 文章标签： 深度学习 pytorch 人工智能 机器学习 python 算法 数据挖掘
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74085818/article/details/141609995
版权

目的

  • 本专栏更新深度学习基础，包括pytorch、tensorflow的使用以及CNN、RNN、yolo、GAN、LSTM、Transformer等神经网络的理论基础

前言

  • Pytorch是最常用的深度学习框架，里面包含了大量关于构建神经网络及其运算的API
  • Pytorch基础入门分为上下两篇文章，此为上
  • 注意：Pytorch的学习在学完基础后，对Pytorch有一定了解后，一定要结合实践进行学习，光学一堆API函数没有任何意义
  • 欢迎点赞 + 收藏 + 关注

Pytroch入门11的专题思维导图如下
在这里插入图片描述

文章目录

1、张量的创建

学习目标

  • 掌握张量的创建
  • 张量的简介
    在Pytorch中，数据都是封装成张量进行运算的，张量是同一种元素类型的多维矩阵

1、基本创建方法

  • torch.tensor 根据数据创建张量
  • torch.Tensor 根据形状创建张量，也可以创建指定数据的张量
  • torch.IntTensor、torch.FloatTensor、torch.DoubleTensor等 创建指定类型的张量
import torch
import numpy as np
import random

# 1. 根据数据创建张量
def test01():
    # 创建标量张量
    data = torch.tensor(10) 
    print(data)  # 输出 tensor(10)
    
    # 其他数据转 tensor
    data = np.random.randn(2, 3)  # 生成(2,3)矩阵(0~1)
    data = torch.tensor(data)  
    print(data)    #数据类型 torch.float64
    
    # 列表
    data = [[10, 20, 30], [40, 50, 60]]
    data = torch.tensor(data)
    print(data)  
    
# 2. 指定形状创建张量
def test02():
    # (2,3)的张量，**默认类型为float**
    data = torch.Tensor(2,3)
    print(data)
    
    # 传递列表，则就只创建传递列表的张量
    data = torch.Tensor([10])
    print(data) # print: tensor([10.])
    
    data = torch.Tensor([10, 20])
    print(data)

# 3. 创建指定类型的张量
def test03():
    # int
    data = torch.IntTensor(2,3)
    print(data)
    
    # 注意：如果传递元素类型不一致，会强制转换
    data = torch.IntTensor([2.0, 3.5, 4.8])
    print(data)  # pytorch，如何创建指定类型的张量
    
    # 其他类型
    data = torch.FloatTensor()      # float32
    data = torch.DoubleTensor()     # double64
    data = torch.ShortTensor()      # int16
    data = torch.LongTensor()       # int32  
    # 注意：没有orch.LongLongTensor()类型
    
    

if __name__ == "__main__":
    test03()

tensor([[-549255968,        516,          0],
        [         0,          0,          0]], dtype=torch.int32)
tensor([2, 3, 4], dtype=torch.int32)

2、创建线性张量

  • torch.arange和torch.linspace创建线性张量
  • torch.random.init_seed和torch.random.manual_seed随机种子设置
  • torch.randn 创建随机张量
import torch

# 1、创建线性空间的张量
def test01():
    # 1. 在指定的区间按照步长生成元素 [step, end, step)
    data = torch.arange(0, 10, 2)
    print(data)
    
    # 2. 在指定区间按照元素个数生成
    data =  torch.linspace(0, 11, 10)
    print(data)
    
# 2、创建随机张量
def test02():
    # 1. 创建随机张量
    data = torch.randn(2, 3)  # 创建2行3列的张量
    print(data)
    
    # 2. 随机数种子的设置
    print('随机数种子： ', torch.random.initial_seed())
    torch.random.manual_seed(100)
    print('随机数种子：', torch.random.initial_seed())
    
    
if __name__ == '__main__':
    test02()

tensor([[0.2001, 0.6427, 1.1013],
        [0.3320, 0.2964, 0.6062]])
随机数种子：  46007482472300
随机数种子： 100

3、创建01张量

  • torch.ones和torch.ones_like创建全1张量
  • torch.zeros和torch.zeros_like创建全0张量
  • torch.full和torch.full_like创建全指定值的张量
import torch

# 1、创建全0张量
def test01():
    # 1. 创建指定形状的全0张量
    data = torch.zeros(2,3)
    print(data)
    
    # 2. 根据**张量形状**创建全0张量
    data = torch.zeros_like(data)
    print(data)
    
# 2、创建全1张量
def test02():
    # 1、创建指定形状全1张量
    data = torch.ones(2,3)
    print(data)
    
    # 根据**张量形状**创建全1张量
    data = torch.ones_like(data)
    print(data)
    
# 3、创建全是指定数的张量
def test03():
    
    # 1. 创建指定形状和值的张量
    data = torch.full([2, 3], 8)
    print(data)
    
    # 2. 更具张量形状创建指定值的张量
    data = torch.full_like(data, 20)
    print(data)
    
if __name__ == '__main__':
    test03()

tensor([[8, 8, 8],
        [8, 8, 8]])
tensor([[20, 20, 20],
        [20, 20, 20]])

4、张量元素类型转换

import torch

def test():
    data = torch.full([2,3], 8)
    print(data.dtype)
    
    # 转化为 float类型
    # 1、第一种方法
    data = data.type(torch.DoubleTensor)
    print(data.dtype)
    
    # 2、第二种方法
    data = data.double()
    print(data.dtype)
    
if __name__ == '__main__':
    test()

torch.int64
torch.float64
torch.float64

2、张量的数值计算

1、张量基本运算

基本运算常用api：

  • add、sub、mul、div、neg
  • add_、sub_、mul_、neg_ 这些版本为修改原数据
import numpy as np
import torch

def test():
    
    data = torch.randint(0, 10, [2, 3])
    print(data)
    print('-' * 50)
    
    # 1、不修改原数据
    new_data = data.add(50)
    print(new_data)
    print('-' * 50)
    
    # 2、修改原数据
    data.add_(50)
    print(data)
    
    print(data.neg())  # 取反
    
if __name__ == '__main__':
    test()

tensor([[6, 1, 7],
        [8, 2, 0]])
--------------------------------------------------
tensor([[56, 51, 57],
        [58, 52, 50]])
--------------------------------------------------
tensor([[56, 51, 57],
        [58, 52, 50]])
tensor([[-56, -51, -57],
        [-58, -52, -50]])

2、阿达玛积

指矩阵对应元素相乘

import torch

def test():
    
    data1 = torch.tensor([[1, 2], [3, 4]])
    data2 = torch.tensor([[5, 6], [7, 8]])    
    
    #1、第一种方法，注意：需要遵循矩阵运算规则
    new_data = torch.mul(data1, data2)
    print(new_data)
    
    #2、第二种方法
    new_data = data1 * data2
    print(new_data)
    
if __name__ == '__main__':
    test()
    

tensor([[ 5, 12],
        [21, 32]])
tensor([[ 5, 12],
        [21, 32]])

3、矩阵相乘(点积运算)

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

  • 运算符 @
  • torch.mm 用于两维矩阵
  • torch.bmm 用于三维矩阵
  • torch.matmul 用于多维
import numpy as np
import torch

#1 点积运算
def test01():
    data1 = torch.tensor([[1, 2], [3, 4], [5, 6]])
    data2 = torch.tensor([[5, 6], [7, 8]])
    
    #1 第一种
    data = data1 @ data2
    print(data)
    
    # 2 第二种
    data = torch.mm(data1, data2)
    print(data)
    
    # 第三种
    data = torch.matmul(data1, data2)
    print(data)
    
#2、torch.mm 和 torch.matmul区别
def test02():
    # torch.matmul维度可以不同
    print(torch.matmul(torch.randn(2, 4, 5), torch.randn(5, 4)).shape)   # 三维 * 两维
    
#3、torch.bmm 使用
def test03():
    # .bmm 批量矩阵相乘
    # 第一个参数为批量次数，必须一致
    data1 = torch.randn(2, 4, 5)   # 相当于第一个 [4, 5] * [5, 8], 第二个[4, 5] * [5, 8] 相当于分开乘
    data2 = torch.randn(2, 5, 8)
    
    print(torch.bmm(data1, data2))
    
if __name__ == "__main__":
    test03()

tensor([[[-1.5538,  1.2162,  1.5792, -2.3072, -3.2645, -0.3950,  1.0962,
           2.7147],
         [ 1.6430,  1.5596, -1.4857, -1.0365, -0.7418,  0.2916, -0.8140,
           0.3571],
         [ 1.4194,  2.2233, -1.6982,  1.8784,  2.2567,  1.5027, -1.8993,
          -7.0435],
         [ 1.0284, -1.7581, -4.5965, -3.3414, -2.5268,  1.3937, -4.9438,
          -1.8333]],

        [[-1.3526, -1.6785, -0.0365, -0.0763, -1.1699, -0.8849, -1.3254,
          -0.9677],
         [-1.0104, -0.2635, -0.5428, -0.6463,  0.4798, -0.2916, -0.2097,
           0.1552],
         [ 0.6113,  2.0732, -1.1052, -2.5615,  4.2304, -0.8377,  0.4031,
           1.2656],
         [ 1.0027,  1.0019,  0.5648, -0.9055,  1.8673, -0.6666, -0.0486,
           1.0447]]])

4、指定运算设备

PyTorch 默认会将张量创建在 CPU 控制的内存中, 即: 默认的运算设备为 CPU。我们也可以将张量创建在 GPU 上, 能够利用对于矩阵计算的优势加快模型训练。将张量移动到 GPU 上有三种方法:

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


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

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

    # 注意要下载cuda
    data = data.cuda()
    print('存储设备:', data.device)

    # 使用 cpu 函数将张量移动到 cpu 上
    data = data.cpu()
    print('存储设备:', data.device)


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

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

    # 使用 cpu 函数将张量移动到 cpu 上
    data = data.cpu()
    print('存储设备:', data.device)



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

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

    data = data.to('cuda:0')
    print('存储设备:', data.device)


# 4. 存储在不同设备的张量不能运算
def test04():

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

    data = data1 + data2
    print(data)

    # 这样会报错

if __name__ == '__main__':
    test03()


存储设备: cpu
存储设备: cuda:0

3、张量类型转换

1、张量转换为numpy数组

使用Tensor.numpy函数可以将张量转换为ndarray数组，但是共享内存，可以使用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))
    
    # 注意：： data_tensor 和 data_tensor 共享内存
    data_numpy[0] = 100
    
    print(data_numpy)
    print(data_tensor)
    
#2 对象拷贝避免共享内存
def test02():
    
    data_tensor = torch.tensor([2, 3, 4])
    data_numpy = data_tensor.numpy().copy()  # 拷贝
    
    print(type(data_tensor))
    print(type(data_numpy))
    
    # 修改
    data_numpy[0] = 100
    
    print(data_numpy)
    print(data_tensor)

if __name__ == '__main__':
    test02()

<class 'torch.Tensor'>
<class 'numpy.ndarray'>
[100   3   4]
tensor([2, 3, 4])

2、numpy转张量

  • 使用from_numpy可以将ndarray数组转换为Tensor，默认共享内存，使用copy函数避免共享
  • 使用torch.tensor可以将ndarry数组转换为Tensor，默认不共享内存
import numpy as np
import torch

# 1、使用 from_numpy 函数
def test01():
    
    data_numpy = np.array([2, 3, 4])
    
    # 浅拷贝
    data_tensor = torch.from_numpy(data_numpy)
    
    # 修改
    data_numpy[0] = 100
    
    print(data_numpy)
    print(data_tensor)
    
# 2、使用 tensor.tensor 函数
def test02():
    data_numpy = np.array([2, 3, 4])
    
    data_tensor = torch.tensor(data_numpy)
    
    data_numpy[0] = 100
    
    print(data_numpy)
    print(data_tensor)
    
if __name__ == '__main__':
    test02()

[100   3   4]
tensor([2, 3, 4], dtype=torch.int32)

3、标量张量和数字的转换

对于只有一个元素的张量，使用item方法将该值从张量中提取出来

# 3 标量张量和数字转换
def test03():
    # 当张量只包含一个元素时，可以通过 item 函数提取出该值
    data = torch.tensor([30,])
    print(data.item())
    print(type(data))
    
    data = torch.tensor(30)
    print(data.item())
    print(type(data))
    
if __name__ == '__main__':
    test03()
    

30
<class 'torch.Tensor'>
30
<class 'torch.Tensor'>

4、张量的拼接

1、torch.cat函数的使用

torch.cat函数可以按照指定的维度拼接起来

import torch

def test():
    # 随机初始化数据
    data1 = torch.randint(0, 10, [2, 3, 2])
    data2 = torch.randint(0, 10, [2, 3, 2])
    
    print(data1)
    print(data2)
    print('*' * 50)
    
    # 1、按照0维度进行拼接
    new_data = torch.cat([data1, data2], dim=0)
    print(new_data.shape)
    print('*' * 50)
    
    # 2、按照1维进行拼接
    new_data = torch.cat([data1, data2], dim=1)
    print(new_data.shape)
    print('*' * 50)
    
    # 3、按照2维进行拼接
    new_data = torch.cat([data1, data2], dim=2)
    print(new_data.shape)
    print(new_data)
    
    
if __name__ == '__main__':
    test()

tensor([[[7, 7],
         [4, 4],
         [7, 0]],

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

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

        [[8, 7, 0, 8],
         [8, 7, 3, 7],
         [1, 3, 4, 2]]])

2、torch.stack函数的使用

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

import torch

def test():
    
    data1 = torch.randint(0, 10, [2, 3])
    data2 = torch.randint(0, 10, [2, 3])
    print(data1)
    print(data2)
    
    new_data = torch.stack([data1, data2], dim=0)
    print(new_data)
    print('*' * 50)
    
    new_data = torch.stack([data1, data2], dim=1)
    print(new_data)
    print('*' * 50)
    
    new_data = torch.stack([data1, data2], dim=2)
    print(new_data)
    
    
if __name__ == '__main__':
    test()

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

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

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

        [[4, 6],
         [4, 5],
         [9, 1]]])

5、张量索引操作

准备数据

import torch

# 准备数据
data = torch.randint(0, 10, [4, 5])
print(data)
print('*' * 50)

tensor([[9, 7, 4, 0, 8],
        [8, 1, 9, 9, 0],
        [7, 9, 7, 0, 8],
        [9, 4, 5, 4, 1]])
**************************************************

1、简单行、列索引

print(data[0])  # 第零行
print(data[:, 0])  # 第零列
print('*' * 50)

tensor([9, 7, 4, 0, 8])
tensor([9, 8, 7, 9])
**************************************************

2、列表索引

# 输出 (0, 1) 、(1, 2) 两个位置的元素
print(data[[0, 1], [1, 2]])
print(data[0, 1], data[1, 2])

# 输出 0、1 行的 1、 2列的四个元素
print(data[[[0], [1]], [1, 2]])  # 注意括号位置

tensor([7, 9])
tensor(7) tensor(9)
tensor([[7, 4],
        [1, 9]])

3、范围索引

# 输出前三行前两列的数据
print(data[:3, :2])  # 行为先

# 输出第二行到z前两列的数据
print(data[2, :2])

tensor([[9, 7],
        [8, 1],
        [7, 9]])
tensor([7, 9])

4、布尔索引

# 输出第三列大于5的行数据
print(data[data[:, 2] > 5])  # data[:, 2] > 5 创建了一个布尔数组(也称为掩码)
# 输出第二行大于5的列数据
#print(data[data[1, :] > 5])  # 注意：这样写违反了 行为先 的规则
print(data[1, data[1] > 5])

tensor([[8, 1, 9, 9, 0],
        [7, 9, 7, 0, 8]])
tensor([8, 9, 9])

5、多维数组索引

# 一层一层解析
import torch

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

print(data[0, :, :])
print(data[:, 0, :])
print(data[:, :, 0])

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

        [[5, 3, 8, 4, 8],
         [0, 7, 7, 8, 2],
         [7, 0, 0, 8, 0],
         [7, 5, 7, 7, 3]],

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

6、张量形状操作

1、reshape函数的用法

reshape函数可以保证张量数据不变的情况下提前改变数据的维度，将其转换成指定的形状，在后面的神经网络学习中，会经常使用该函数来调整数据的形状，用来适配不同网络层之间的数据传递。

import torch 
import numpy as np 

def test():
    
    data = torch.tensor([[10, 20, 30], [40, 50, 60]])
    
    # 1、获取张量的形状
    print(data.shape, data.shape[0], data.shape[1])
    print(data.size(), data.size(0), data.size(1))
    print('*' * 50)
    
    # 2、使用 reshape 函数修改张量的形状
    new_data = data.reshape(1, 6)
    print(new_data)
    
if __name__ == '__main__':
    test()

torch.Size([2, 3]) 2 3
torch.Size([2, 3]) 2 3
**************************************************
tensor([[10, 20, 30, 40, 50, 60]])

2、transpose和permute函数的使用

transpose函数可以实现交换张量形状的指定维度，例如：一个张量的形状为(2, 3, 4) 通过transpose可以将 3 和 4 进行交换，将张量的形状变为 (2, 4, 3)

而permute函数可以一次交换多维数据

在pytorch中创建张量，是存储在整块内存中的，而使用transpose 和 permute 函数后，返回的张量是由不同的数据块组成了(可以由is_contiguous判断是否由一整内存快组成)

import torch 
import numpy as np 

def test():
    
    data = torch.tensor(np.random.randint(0, 10, [3, 4, 5]))
    print(data.size())
    
    # 交换 1 和 2 的维度
    new_data = torch.transpose(data, 1, 2)
    print(new_data.shape)
    print('*' * 50)
    
    # 将data数据修改为 (4, 5, 3) 维度
    new_data = torch.transpose(data, 0, 1)
    new_data = torch.transpose(new_data, 1, 2)
    print(new_data.shape)
    print('*' * 50)
    
    # 使用 permute 直接修改成 (4, 5, 3)  |pəˈmjuːt|
    new_data = torch.permute(data, [1, 2, 0])
    print(new_data.shape)
    
if __name__ == '__main__':
    test()
    

torch.Size([3, 4, 5])
torch.Size([3, 5, 4])
**************************************************
torch.Size([4, 5, 3])
**************************************************
torch.Size([4, 5, 3])

3、view和contiguous函数的用法

view函数可以用于修改张量的形状，但是用法比较局限，只能用于存储在整块内存中的张量。在Pytorch中，有一些张量是由不同的数据块组成的，并没有存储在整块的内存中，view函数无法对这样的张量进行变形处理，例如：一个张量经过了 transpose 或者 permute 函数处理后就无法通过view函数进行形状操作。

contiguous可以将非整块内存变成整块内存

import torch 
import numpy as np 

def test():
    
    data = torch.tensor([[10, 20, 30], [40, 50, 60]])
    print(data.size())
    print(data.is_contiguous())  # 判断是否用整块内存
    print('*' * 50)
    
    # 1、使用 view 函数进行形状修改
    new_data = data.view(3, 2)
    print(new_data.size())
    print(new_data.is_contiguous())  # 判断是否用整块内存
    print('*' * 50)
    
    # 2、先使用transpose后用view回报错
    new_data = torch.transpose(data, 1, 0)
    print(new_data.size())
    print(new_data.is_contiguous())  # 判断是否用整块内存
    # 报错: 
    # new_data =  new_data.view(2, 3)
    print('*' * 50)
    
    # 解决方法：contiguous
    new_data = new_data.contiguous().view(2, 3)
    print(new_data.size())
    print('*' * 50)
    
if __name__ == '__main__':
    test()

torch.Size([2, 3])
True
**************************************************
torch.Size([3, 2])
True
**************************************************
torch.Size([3, 2])
False
**************************************************
torch.Size([2, 3])
**************************************************

4、squeeze和unsqueeze函数用法

squeeze函数用删除shape为1的维度，unsqueeze在每个维度添加1，用来增加数据的形状。

import torch 
import numpy as np 

def test():
    
    data = torch.tensor(np.random.randint(0, 10, [1, 3, 1, 5]))
    print(data.size())
    print('*' * 50)
    
    # 1、去掉值为 1 的维度
    new_data = data.squeeze()
    print(new_data.size())
    print('*' * 50)
    
    # 2、去掉指定维度为 1 的维度
    new_data = data.squeeze(2)
    print(new_data.size())
    print('*' * 50)
    
    # 3、在2维度的位置添加一个维度
    new_data = data.unsqueeze(-1)
    print(new_data.size())
    
if __name__ == '__main__':
    test()

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

7、张量运算函数

pytorch里面封装了很多计算函数，常用的有：

  • 计算均值
  • 计算综合
  • 计算平方
  • 计算平方根
  • 指数运算
  • 对数运算
  • 其他的先用现查
import torch 

def test():
    # 准备数据
    data = torch.randint(0, 10, [2, 3], dtype=torch.float64)
    print(data)

    
    # 1、计算均值
    print(data.mean())
    print(data.mean(dim=0))     # 按照维度计算
    print(data.mean(dim=1))
    print('-' * 50)
    
    # 2、计算总和
    print(data.sum())
    print(data.sum(dim=0))
    print(data.sum(dim=1))
    print('-' * 50)
    
    # 3、计算平方
    print(data.pow(2))

    # 4、计算平方根
    print(data.sqrt())
    print('-' * 50)
    
    # 5. 指数计算, e^n 次方
    print(data.exp())
    print('-' * 50)

    # 6. 对数计算
    print(data.log())  # 以 e 为底
    print(data.log2())
    print(data.log10())
    
if __name__ == '__main__':
    test()  
    

tensor([[0., 5., 2.],
        [4., 3., 7.]], dtype=torch.float64)
tensor(3.5000, dtype=torch.float64)
tensor([2.0000, 4.0000, 4.5000], dtype=torch.float64)
tensor([2.3333, 4.6667], dtype=torch.float64)
--------------------------------------------------
tensor(21., dtype=torch.float64)
tensor([4., 8., 9.], dtype=torch.float64)
tensor([ 7., 14.], dtype=torch.float64)
--------------------------------------------------
tensor([[ 0., 25.,  4.],
        [16.,  9., 49.]], dtype=torch.float64)
tensor([[0.0000, 2.2361, 1.4142],
        [2.0000, 1.7321, 2.6458]], dtype=torch.float64)
--------------------------------------------------
tensor([[1.0000e+00, 1.4841e+02, 7.3891e+00],
        [5.4598e+01, 2.0086e+01, 1.0966e+03]], dtype=torch.float64)
--------------------------------------------------
tensor([[  -inf, 1.6094, 0.6931],
        [1.3863, 1.0986, 1.9459]], dtype=torch.float64)
tensor([[  -inf, 2.3219, 1.0000],
        [2.0000, 1.5850, 2.8074]], dtype=torch.float64)
tensor([[  -inf, 0.6990, 0.3010],
        [0.6021, 0.4771, 0.8451]], dtype=torch.float64)
羊小猪~~
关注
  • 20
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Pytorch和深度学习】栏目导读
gongdiwudu的专栏
11-13 4020
本栏目《pytorch实践》是为初学者入门深度学习准备的。本文是该栏目的导读部分，因为计划本栏目在明年完成，因此，导读部分，即本文也在持续更新中。
深度学习理论与实战（基于PyTorch实现）-廖星宇-专题视频课程
qq_23368835的博客
07-17 2397
本课程对人工智能的核心—“深度学习”的知识和技能脉络进行了精细的梳理，设计出内容架构、学习路径和具体内容，期望达到“从零开始，循序渐进，高效”，层层递进的练习实践将不断让学员获得惊喜和信心。本课程的理论知识、项目案例及项目实践覆盖到了计算机视觉、自然语言处理、数据分析等当前就业热门领域...
torch学习 -- pytorch问题大全
Limonor的博客
08-31 459
pytorch问题大全 PyTorch 的设计遵循tensor→variable(autograd)→nn.Module 三个由低到高的抽象层次，分别代表高维数组（张量）、自动求导（变量）和神经网络（层/模块），而且这三个抽象之间联系紧密，可以同时进行修改和操作 PyTorch的源码只有TensorFlow的十分之一左右，更少的抽象、更直观的设计使得PyTorch的源码更易于阅读 pytorch resnet专题 resnet18 数字代表的是网络的深度，这里的18指定的是带有权重的18层，包括卷积层和全连
Pytorch入门——手把手带你配置云服务器环境
TechFlow的博客
06-25 1511
本文始发于个人公众号：TechFlow，原创不易，求个关注 今天这篇是Pytorch专题第一篇文章。 大家好，由于我最近自己在学习Pytorch框架的运用，并且也是为了响应许多读者的需求，推出了这个Pytorch专题。由于这个专题是周末加更的，所以不能保证更新进度，我尽量和其他专题一样，每周一更。 Pytorch简介 Pytorch底层是Torch框架，Torch框架是一个科学计算框架，拥有一个与Numpy类似的张量操作库。非常灵活，但是它的语言是Lua，比较小众，因此没有广泛流行。 后来开发团队在T
视频教程-深度学习-Pytorch项目实战－垃圾分类-深度学习
weixin_33893455的博客
05-28 2008
深度学习-Pytorch项目实战－垃圾分类 JAVA企业级应用讲师、大数据实...
深度学习实战_五天入门深度学习，这里有一份PyTorch实战课程
weixin_39645041的博客
12-09 177
这是一门五天入门深度学习的实战课程。想入门深度学习的小伙伴有福了！dataflowr 最近推出了一门五天初步掌握深度学习的实战教程（实战使用 PyTorch 框架），有知识点有实例有代码，值得一看。该课程的创建和维护者是法国国立计算机及自动化研究院（INRIA）的研究员 Marc Lelarge。课程地址：https://mlelarge.github.io/dataflowr-web/cea_e...
深度学习理论与实战（基于TensorFlow）实现-专题视频课程
qq_23368835的博客
07-23 1150
深度学习理论与实战（基于TensorFlow）实现—187人已学习 课程介绍         这门课程，重在教会你如何用，在你熟练应用的基础上，再去探究算法机理。基于这样的考量，我们设计了视频、图文、代码练习和项目实战这四种主要的教学方式。视频课程，老师会讲解理论知识、算法、重要的概念、关键性的代码。图文教程是视频教程的补充，主要是一些拓展知识，和一些不是重要，但是对理解知识又不可或缺的内容，供大...
基于深度学习的人脸性别识别系统（含UI界面，Python代码）
热门推荐
思绪无限的博客
03-03 3万+
摘要：人脸性别识别是人脸识别领域的一个热门方向，本文详细介绍基于深度学习的人脸性别识别系统，在介绍算法原理的同时，给出Python的实现代码以及PyQt的UI界面。在界面中可以选择人脸图片、视频进行检测识别，也可通过电脑连接的摄像头设备进行实时识别人脸性别；可对图像中存在的多张人脸进行性别识别，可选择任意一张人脸框选显示结果，检测速度快、识别精度高。博文提供了完整的Python代码和使用教程，适合新入门的朋友参考，完整代码资源文件请转至文末的下载链接。
PaddlePaddle深度学习7日入门-CV疫情特辑
weixin_46730871的博客
04-11 219
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Ma...
《自然语言处理实战入门》 ---- 【Generative AI重制版】总目录
shiter编写程序的艺术
12-03 5060
随着人工智能的快速发展，自然语言处理和机器学习技术的应用愈加广泛。为使大家对该领域整体概况有一个系统、明晰的认识，同时入门一些工程实践，也借CSDN为NLP的学习，开发者们搭建一个交流的平台。我希望能够通过这个专栏《自然语言处理实战入门》和广大NLP爱好者一起学习自然语言处理技术，分享学习资料，打破NLP 技术 的实战应用壁垒。................................................
深度学习学习经验——全连接神经网络（FCNN）
Linductor的博客
08-22 857
全连接神经网络（FCNN）是最基础的神经网络结构，它由多个神经元组成，这些神经元按照层级顺序连接在一起。每一层的每个神经元都与前一层的每个神经元连接。接待区交流区和结果区。
基于深度学习的单目标跟踪系统
2301_78240361的博客
08-26 555
基于深度学习的单目标跟踪，效果吊打传统算法，3060显卡上达到实时，代码python和c++都有
深度学习学习经验——长短期记忆网络（LSTM）
Linductor的博客
08-23 1138
长短期记忆网络（LSTM，Long Short-Term Memory）是一种特殊的循环神经网络（RNN），专为解决 RNN 中长期依赖问题而设计。
深度学习--Transformer和BERT区别详解
最新发布
GDHBFTGGG的博客
08-26 597
Transformer和BERT区别详解
李沐--动手学深度学习GoogLeNet
深度学习 初学者
08-21 201
【代码】李沐--动手学深度学习GoogLeNet。
回归预测|基于Transformer-LSTM组合模型的数据回归预测Matlab程序 多特征输入单输出
2401_86241083的博客
08-22 995
Transformer-LSTM回归预测模型是结合了Transformer和LSTM两种不同类型的神经网络模型的优势，以实现时间序列或序列数据的预测任务。包括但不限于。
【视频讲解】主成分分析原理与水果成熟数据实例：Python中PCA-LDA 与卷积神经网络CNN...
拓端研究室TRL
08-22 792
全文链接：https://tecdat.cn/?p=37450分析师：Shixian Ding主成分分析（PCA）作为数据科学中用于可视化和降维的重要工具，在处理具有大量特征的数据集时非常有用。就像我们难以找到时间阅读一本 1000 页的书，而更倾向于 2 到 3 页的总结以抓住整体概貌一样，当数据集中特征过多时，PCA 可以帮助我们减少维度，提高模型训练效率，同时尽可能保留更多信息（点击文末“...
循环神经网络RNN时间序列预测与MLP比较
溯源的专栏
08-23 753
batch_first 为 True时output的tensor为（batch_size,seq_len,hidden_size）,否则为（seq_len,batch_size,hidden_size）# 初始化隐藏状态和细胞状态# 计算输出和最终隐藏状态通过模型定义可以看出以下几点：（1）RNN不需要定义序列长度：RNN用于处理序列数据，但是在模型定义中并没有定义序列长度是多少。这一点和MLP不需要定义batch size是一样的，batch size和序列长度。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值