深度学习-张量相关

开出南方的花2024-11-10 23:14

一. 张量的创建

张量简介

张量是pytorch的基本数据结构

张量 ，英文为Tensor，是机器学习的基本构建模块，是以数字方式表示数据的形式。

例如，图像可以表示为形状为 [3, 224, 224] 的张量，这意味着 [colour_channels, height, width] ，因为图像具有 3 颜色通道（红色、绿色、蓝色），高度为 224 像素，宽度为 224 像素。

在张量语言（用于描述张量的语言）中，张量将具有三个维度，一个维度表示 colour_channels 、 height 和 width 。

张量的基本创建

根据数据创建tensor

默认64

复制代码 
# 1. 使用torch.tensor根据数据创建张量
# 1.1. 创建标量
data = torch.tensor(10)
print(data)
​
# 1.2. 创建numpy数组
data = np.random.randn(3, 4)
data = torch.tensor(data)
print(data)
​
# 1.3. 创建张量
data = torch.tensor([[1, 2], [3, 4]])
print(data)

根据形状/数据创建Tensor

默认32

复制代码 
# 2.使用torch.Tensor根据形状/数据创建张量
# 2.1. 创建两行三列张量, 默认dtype为float32
data = torch.Tensor(2, 3)
print(data)
​
# 2.2. 如果传递列表, 则创建包含指定元素的张量
data = torch.Tensor([10])
print(data)
​
data = torch.Tensor([1, 4])
print(data)

指定类型张量

复制代码 
# 3. torch.IntTensor(), torch.FloatTensor(), torch.DoubleTensor()创建指定类型的张量
# 3.1. 创建2行3列, dtype 为 int32 的张量
data = torch.IntTensor(2, 3)
print(data)
​
# 3.2. 注意: 如果传递的元素类型不正确, 则会进行类型转换
data = torch.IntTensor([2.5, 3.3])
print(data)
​
# 3.3. 其他的类型
data = torch.ShortTensor()      # int16
print(data)
data = torch.LongTensor()       # int64
print(data)
data = torch.FloatTensor()      # float32
print(data)
data = torch.DoubleTensor()     # float64
print(data)

线性张量与随机张量

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

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

  3. torch.randn 创建随机张量

线性张量

torch.arange()
复制代码 
# 1.1 arange() 左闭右开
data = torch.arange(0, 11, 2)
print(data)
torch.linspace()
复制代码 
# 1.2 linspace() 左闭右闭
data = torch.linspace(0, 10, 5)
print(data)
区别

arange(start, end, step): 起始, 截至, 步长(每步走多少, 左闭右开)

linspace(start, end, steps): 起始, 截止, 步数(走几步, 左闭右闭)

随机张量

  1. torch.random.initial_seed()查看随机种子

  2. torch.random.manual_seed() 设置随机数种子

  3. torch.randn() 创建随机张量

创建随机张量

复制代码 
# 2.1 创建随机张量
data = torch.randn(2, 3)  # 2行3列
print(data)
​
# 2.2 查看随机种子
print(torch.random.initial_seed())      # 查看默认种子, 机器码
​
# 2.3 创建随机种子
torch.random.manual_seed(1)    # 设置随机种子
data = torch.randn(2, 3)    # 随机张量
print(data)
print(torch.random.initial_seed())

创建指定值张量

  1. torch.ones 和 torch.ones_like(像什么形状) 创建全1张量

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

  3. torch.full([行数, 列数], 指定值) 和 torch.full_like 创建指定值张量

创建全0张量

创建结果为浮点型, zeros_like(data) => 创建形状和data一样的张量

复制代码 
# 3.1 创建全0张量
data_zeros = torch.zeros(2, 3)
print('0张量', data_zeros)
​
data_zeros = torch.zeros_like(data_zeros)
print('0张量', data_zeros)

创建全1张量

复制代码 
# 3.2 创建全1张量
data_ons = torch.ones(2, 3)
print('1张量', data_ons)
​
data_ons = torch.tensor(data_ons)
print('1张量', data_ons)

创建全指定值张量

复制代码 
# 3.3 创建指定值张量
data_full = torch.full((2, 3), 5)
print('指定值张量', data_full)
​
data_full = torch.full_like(data_full, 10)
print('指定值张量', data_full)

张量元素类型转换

  1. data.type(torch.DoubleTensor)

  2. data.double(), data.float()......小写

  3. data.dtype: 查看数据类型

间接转换

复制代码 
data = torch.full([2, 3], 10)
print(data.dtype)
>>> torch.int64
​
# 将 data 元素类型转换为 float64 类型
data = data.type(torch.DoubleTensor)
print(data.dtype)
>>> torch.float64
​
# 转换为其他类型
# data = data.type(torch.ShortTensor)   # int16
# data = data.type(torch.IntTensor)    # int32
# data = data.type(torch.LongTensor)   # int64
# data = data.type(torch.FloatTensor)  # float32

直接转换

复制代码 
data = torch.full([2, 3], 10)
print(data.dtype)
>>> torch.int64
​
# 将 data 元素类型转换为 float64 类型
data = data.double()
print(data.dtype)
>>> torch.float64
​
# 转换为其他类型
# data = data.short()
# data = data.int()
# data = data.long()
# data = data.float()
​

张量创建总结

创建张量的方式

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

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

  • torch.IntTensor()、torch.FloatTensor()、torch.DoubleTensor() 创建指定类型的张量

创建线性和随机张量

  • torch.arrange() 和 torch.linspace() 创建线性张量

  • torch.random.initial_seed() 和 torch.random.manual_seed() 随机种子设置

  • torch.randn() 创建随机张量

创建01张量

  • torch.ones() 和 torch.ones_like() 创建全1张量

  • torch.zeros() 和 torch.zeros_like() 创建全0张量

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

张量元素类型转换

  • data.type(torch.DoubleTensor)

  • data.double()

二. 张量相关操作

张量的类型转换

张量转Numpy数组

使用 Tensor.numpy 函数可以将张量转换为 ndarray 数组，但是共享内存，可以使用 copy 函数避免共享。

复制代码 
import torch
​
torch.manual_seed(21)
​
data = torch.randn(2, 3)
print(type(data))
​
data_numpy = data.numpy().copy()    # 设置不共享内存
print(type(data_numpy))
​
data[0][0] = 100
print(data)
print(data_numpy)

Numpy数组转张量

  1. from_numpy(data_numpy):默认共享内存, 可以使用data_numpy.copy()复制一份, 避免内存共享

  2. torch.tensor()/torch.Tensor ()此方法不共享内存

复制代码 
# numpy转张量
import numpy as np
​
data_numpy = np.random.randn(2, 3)
print(type(data_numpy))
print(data_numpy)
​
# data_tensor = torch.from_numpy(data_numpy)  # 此方法共享内存
# data_tensor = torch.from_numpy(data_numpy.copy())  # 此方法不共享内存
# data_tensor = torch.tensor(data_numpy)  # 此方法不共享内存
data_tensor = torch.Tensor(data_numpy)  # 此方法不共享内存
print(type(data_tensor))
print(data_tensor)
​
data_tensor[0][0] = 100
print(data_numpy)
print(data_tensor)
标量张量和数字转换

当只有一个元素的张量时, 可以使用data.item()函数将该值从张量中取出

复制代码 
# 标量张量和数字转换
​
data = torch.tensor(1)
print(data.item())
​
data = torch.tensor([1, 2])
print(data.item())      # 报错！

张量类型转换总结

张量转换为 numpy 数组

  • data_tensor.numpy()

  • data_tensor.numpy().copy()

numpy 转换为张量

  • torch.from_numpy(data_numpy)

  • torch.tensor(data_numpy)

标量张量和数字转换
  • data.item()

张量的数值计算

基本运算

复制代码 
1. 加减乘除取负号：
2. add+、sub-、mul*、div/、neg负号     不修改原数据
3. add_、sub_、mul_、div_、neg_        修改原数据
复制代码 
import torch
torch.manual_seed(21)
data1 = torch.randint(0, 10, [2, 3])
torch.manual_seed(22)
data2 = torch.randint(10, 20, [3, 4])
torch.manual_seed(23)
data3 = torch.randint(10, 20, [2, 3])
print(data1)
print(data2)
print(data3)
​
# 不修改原数据
print(data1.add(2))
print(data1.sub(2))
print(data1.mul(2))
print(data1.div(2))
print(data1.neg())
print(data1)
​
# # 修改原数据
print(data1.add_(2))
print(data1.sub_(2))
print(data1.mul_(2))
​
print(data1.neg_())
print(data1)

点乘运算

对应位置元素相乘

mul或者*

复制代码 
# 点乘
print(data1.mul(data3))
print(data1 * data3)

矩阵运算

点积

(n, m) * (m, p) = (n, p)

matmul或者@

复制代码 
# 点积
print(data1.matmul(data2))
print(data1 @ data2)

张量运算总结

张量基本运算函数

  • add、sub、mul、div、neg等函数

  • add*、sub* 、mul*、div*、neg_等函数

张量的点乘运算
  • mul 和运算符 *
点积运算

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

  • torch.matmul 对进行点乘运算的两矩阵形状没有限定，对数输入的 shape 不同的张量, 对应的最后几个维度必须符合矩阵运算规则

张量函数运算

PyTorch 为每个张量封装很多实用的计算函数：

复制代码 
import torch
​
torch.manual_seed(21)
data = torch.randint(1, 10, (2, 3), dtype=torch.float64)
print(data)
​
# 均值
print(data.mean())
print(data.mean(dim=0))     # 按列求和
print(data.mean(dim=1))     # 按行求和
​
# 平方
print(torch.pow(data, 2))
​
# 平方根
print(data.sqrt())
​
# 求和
print(data.sum())
print(data.sum(dim=0))
print(data.sum(dim=1))
​
# 指数计算(以e为底的指数)
print(data.exp())
​
# 对数计算
print(data.log())   # 以e为底
print(data.log2())
print(data.log10())

张量索引操作

复制代码 
import torch
# 随机生成数据
data = torch.randint(0, 10, [4, 5])
print(data)
>>> tensor([[0, 7, 6, 5, 9],
            [6, 8, 3, 1, 0],
            [6, 3, 8, 7, 3],
            [4, 9, 5, 3, 1]])
​

简单行列索引

复制代码 
print(data[0])      # 第0行数据
>>> tensor([0, 7, 6, 5, 9])
​
print(data[:, 0])   # 所有行第0列数据
>>> tensor([0, 6, 6, 4])
​

列表索引

复制代码 
# 返回 (0, 2)、(1, 3) 两个位置的元素
print(data[[0, 1], [2, 3]])     # 第0行第2列和第1行第3列
>>> tensor([7, 3])
​
# 返回 0、1 行的 1、2 列共4个元素
print(data[[[0], [1]], [1, 2]])
>>> tensor([[7, 6],
            [8, 3]])
​

范围索引

复制代码 
# 前3行的前2列数据
print(data[:3, :2])
>>> tensor([[0, 7],
            [6, 8],
            [6, 3]])
​
# 第2行到最后的前2列数据
print(data[2:, :2])
>>> tensor([[6, 3],
            [4, 9]])
​
# 第0行、第2行的第0、1两列数据
print(data[0:3:2, :2])# data[行(start, end, step), 列(start, end, step)]
>>>tensor([[0, 7],
            [6, 3]])
​

布尔索引

复制代码 
# 第三列大于5的行数据
print(data[data[:, 2] > 5])
>>> tensor([[0, 7, 6, 5, 9],
            [6, 3, 8, 7, 3]])
​
# 第二行大于5的列数据
# 所有数据第1列数据大于5的所有行数据
print(data[:, data[1] > 5])     # data[行, 列] => 第2行大于5的列
>>> tensor([[0, 7],
            [6, 8],
            [6, 3],
            [4, 9]])
​
# 所有行中第4列小于10的行数据
print(data[data[:, 3] < 10])

多维索引

复制代码 
# 范围索引
torch.random.manual_seed(21)
data = torch.randint(0, 10, [3, 4, 5])  # 三通道、四行、五列
print(data)
>>>tensor([[[3, 3, 6, 8, 6],
         [4, 0, 9, 8, 8],
         [3, 7, 2, 2, 6],
         [7, 8, 5, 9, 9]],
​
        [[9, 4, 4, 4, 2],
         [2, 0, 8, 1, 2],
         [9, 8, 8, 3, 1],
         [4, 1, 6, 8, 8]],
​
        [[4, 8, 2, 6, 3],
         [5, 8, 2, 9, 4],
         [6, 9, 5, 8, 6],
         [8, 5, 2, 0, 8]]])
​
print(data[:, 1:3, 2])      # 所有通道的第1行和第2行，第2列的数据
>>>tensor([[0, 8],
        [4, 0],
        [0, 7]])
​
print(data[1, :, :])    # 第二通道的所有行，所有列的数据
>>>tensor([[9, 4, 4, 4, 2],
        [2, 0, 8, 1, 2],
        [9, 8, 8, 3, 1],
        [4, 1, 6, 8, 8]])

张量形状操作

有重塑、堆叠、挤压和解压：

方法 单行描述
torch.reshape(input, shape) 重塑 input 到 shape （如果兼容），也可以使用 torch.Tensor.reshape()。
tensor.view(shape) 返回不同 shape 中的原始张量视图，但与原始张量共享相同的数据。
tensor.contiguous() 将张量转换到整块内存上
torch.stack(tensors, dim=0) 堆叠:沿着新的维度（dim）连接 tensors 的序列，所有 tensors 必须具有相同的大小。
torch.squeeze(input) 降维:挤压 input 以移除值为 1 的所有尺寸。
torch.unsqueeze(input, dim) 升维:返回在 dim 处添加了维度值 1 的 input。
torch.transpose(input,dim1,dim2) 维度交换:实现交换张量形状的指定维度
torch.permute(input, dims) 返回原始 input 的视图，其尺寸被置换（重新排列）为 dims。

深度学习模型（神经网络）都是以某种方式操纵张量。由于矩阵乘法的规则，如果形状不匹配，就会遇到错误。这些方法可帮助您确保张量的正确元素与其他张量的正确元素混合。

重塑维度形状

reshape

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

使用 torch.reshape() 增加一个维度。

复制代码 
import torch
torch.random.manual_seed(21)
data = torch.randint(0, 10, [4, 5, 6])
print(data)
print(data.shape)
print(data.size())
​
# 1. reshape
# 1.1 降维
data1 = torch.reshape(data, [2, -1])    # -1表示自动计算  
​
print(data1.shape)  # torch.Size([2, 60])
​
# 1.2 改变形状
data2 = torch.reshape(data, [2, 5, -1])
print(data2.shape)  # torch.Size([2, 5, 12])
view/contiguous

  1. view 函数也可以用于修改张量的形状，只能用于存储在整块内存中的张量。

  2. 在 PyTorch 中，有些张量是由不同的数据块组成的，它们并没有存储在整块的内存中，view 函数无法对这样的张量进行变形处理。例如: 一个张量经过了 transpose 或者 permute 函数的处理之后，就无法使用 view 函数进行形状操作。

  3. 此时需要先使用 contiguous 函数转换为整块内存的张量，再使用 view 函数。

复制代码 
# 2. view(): 存储在一块内存上才可以操作
# 查看data是否在一块内存上
print(data.is_contiguous())     # True
​
# 2.1 在一块内存上, 改变形状
data3 = data.view(3, 8, -1)
print(data3.shape)      # torch.Size([3, 8, 5])
​
# 2.2 不在一块内存上, 改变形状
# 2.2.1 交换数据维度, 使数据在不同的内存上
# data4 = data.permute(2, 0, 1)   # 一次交换多个维度
data4 = torch.transpose(data, 1, 2)  # 交换两个维度
print(data4.is_contiguous())    # False
​
# 2.2.2 转换为同一内存
print(data4.contiguous().is_contiguous())   # True
# 改变形状
data5 = data4.contiguous().view(3, 8, -1)
print(data5.shape)      # torch.Size([3, 8, 5])

stack

将新张量堆叠五次，使用 torch.stack() 来实现。

复制代码 
x = torch.arange(1, 9)
x_stack = torch.stack([x, x, x, x], dim=0)  # 按0维堆叠
print(x_stack)

升维降维

squeeze 函数删除形状为 1 的维度（降维），unsqueeze 函数添加形状为1的维度（升维）。

unsqueeze升维
复制代码 
# 4. unsqueeze(): 增加维度
data = torch.tensor([1, 2, 3, 4, 5])
print(data.shape)   # torch.Size([5])
​
data1 = data.unsqueeze(dim=0)
print(data1.shape)  # torch.Size([1, 5])
data2 = data.unsqueeze(dim=1)
print(data2.shape)  # torch.Size([5, 1])
data3 = data.unsqueeze(dim=-1)
print(data3.shape)  # torch.Size([5, 1])
squeeze降维

只可以将维度1的维度删除

复制代码 
# 5. squeeze(): 删除维度
data4 = data3.squeeze()
print(data4.shape)  # torch.Size([5])
data5 = data1.squeeze(dim=0)
print(data5.shape)  # torch.Size([5])

维度交换

transpose 函数可以实现交换张量形状的指定维度,

例如: 一个张量的形状为 (2, 3, 4) 可以通过 transpose 函数把 3 和 4 进行交换, 将张量的形状变为 (2, 4, 3) 。

permute 函数可以一次交换更多的维度。

复制代码 
# 6. 交换维度
data = torch.randint(0, 10, [4, 5, 6])
print(data.shape)   # torch.Size([4, 5, 6])
​
# 交换1和2维度
data1 = torch.transpose(data, 1, 2)
print(data1.shape)  # torch.Size([4, 6, 5])
data2 = data.permute(0, 2, 1)
print(data2.shape)  # torch.Size([4, 6, 5])

张量形状总结

  1. reshape 函数可以在保证张量数据不变的前提下改变数据的维度

  2. squeeze 和 unsqueeze 函数可以用来增加或者减少维度

  3. transpose 函数可以实现交换张量形状的指定维度, permute 可以一次交换更多的维度

  4. view 函数也可以用于修改张量的形状, 但是它要求被转换的张量内存必须连续，所以一般配合 contiguous 函数使用

张量拼接

将多个张量按指定维度(根据维度索引)拼接成一个张量

torch.cat([data1, data2...], dim=维度索引)

复制代码 
import torch
​
data1 = torch.randint(1, 11, [1, 3, 4])
data2 = torch.randint(1, 11, [1, 3, 4])
# print(data1)
# print(data2)
​
# 按0维拼接
data3 = torch.cat([data1, data2], dim=0)
print(data3)
print(data3.shape)
​
# 按1维拼接
data4 = torch.cat([data1, data2], dim=1)
print(data4)
print(data4.shape)
​
# 按2维拼接
data5 = torch.cat([data1, data2], dim=2)
print(data5)
print(data5.shape)

自动微分模块

再反向传播中, 用于计算梯度

正向传播: 由x得到z

反向传播: 由损失更新权重参数

一维

多维

复制代码 
import torch
def test02():
    # 输入张量 2*5
    x = torch.ones(2,5)
    # 目标值是 2*3
    y = torch.zeros(2,3)
    # 设置要更新的权重和偏置的初始值
    w = torch.randn(5, 3,requires_grad=True)
    b = torch.randn(3, requires_grad=True)
    # 设置网络的输出值
    z = torch.matmul(x, w) + b  # 矩阵乘法
    # 设置损失函数，并进行损失的计算
    loss = torch.nn.MSELoss()
    loss = loss(z, y)
    # 自动微分
    loss.backward()
    # 打印 w,b 变量的梯度
    # backward 函数计算的梯度值会存储在张量的 grad 变量中
    print("W的梯度:", w.grad)
    print("b的梯度", b.grad)
​

案例-线性回归

++pytorch模型构建流程:++

  1. 准备训练集数据

    使用 PyTorch 的 data.DataLoader 代替自定义的数据加载器

    打乱数据顺序, 数据分批次

  2. 构建要使用的模型

    使用 PyTorch 的 nn.Linear 代替自定义的假设函数

  3. 设置损失函数和优化器

    使用 PyTorch 的 nn.MSELoss() 代替自定义的平方损失函数

    使用 PyTorch 的 optim.SGD 代替自定义的优化器

  4. 模型训练

++225原则:++

2: 2个初始化参数(损失函数, 优化器)

2: 2个遍历(epoch: 轮次, 数据: 批次大小)

5: 前向传播, 损失函数, 梯度清零, 反向传播, 参数更新

构建数据集

复制代码 
# 导入相关模块
import torch
from torch.utils.data import TensorDataset  # 构造数据集对象
from torch.utils.data import DataLoader  # 数据加载器
from torch import nn  # nn模块中有平方损失函数和假设函数
from torch import optim  # optim模块中有优化器函数
from sklearn.datasets import make_regression  # 创建线性回归模型数据集
import matplotlib.pyplot as plt
​
plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号
​
​
# 定义函数创建数据集: 线性回归: y = kx + b
def creat_datasets():
    x, y, coef = make_regression(
        n_samples=100,
        n_features=1,
        noise=10,
        coef=True,
        bias=1.5,
        random_state=21
    )
    x = torch.tensor(x)
    y = torch.tensor(y)
​
    return x, y, coef
​
​
if __name__ == '__main__':
    x, y, coef = creat_datasets()
    plt.scatter(x, y)
    x = torch.linspace(x.min(), x.max(), 1000)
    # y1 = torch.tensor([coef * i + 1.5 for i in x])    # 报错
    y1 = torch.tensor([i * coef + 1.5 for i in x])  # i为张量, 只可以张量 * 标量
    plt.plot(x, y1, label='predict')
    plt.legend()
    plt.grid()
    plt.xlabel('x')
    plt.ylabel('y')
    plt.show()

构建数据加载器和模型构建

复制代码 
# 构建数据加载器和模型
def data_loader(x, y):
    # 构造数据集对象
    dataset = TensorDataset(x, y)
    # 构造数据加载器
    # batch_size: 批次大小
    # batch: 批次数量
    # shuffle: 是否打乱顺序
    dataloader = DataLoader(dataset, batch_size=10, shuffle=True)
    # 构造模型
    model = nn.Linear(1, 1)
    return dataloader, model

训练参数设置

复制代码 
# 设置损失函数和优化器
def loss_optimizer(model):
    # 设置损失函数: 均方损失函数
    loss_fn = nn.MSELoss()
    # 设置优化器: 随机梯度下降, 学习率0.01
    optimizer = optim.SGD(model.parameters(), lr=0.01)
    return loss_fn, optimizer

模型训练

复制代码 
# 训练模型
def train_model(dataloader, model, loss_fn, optimizer):
    # 训练100轮
    epoch = 100
    # 存储每轮损失
    loss_epoch = []
    total_loss = 0
    train_sample = 0
    # 训练轮次
    for i in range(epoch):
        # 遍历批次
        for train_x, train_y in dataloader:
            # 预测值, 正向传播
            y_pred = model(train_x.type(torch.float32))
            # 计算损失
            loss = loss_fn(y_pred, train_y.reshape(-1, 1).type(torch.float32))
            # 累加损失
            total_loss += loss.item()
            # 累加样本数量
            train_sample += len(train_y)
            # 梯度清零
            optimizer.zero_grad()
            # 反向传播
            loss.backward()
            # 优化器更新参数
            optimizer.step()
        # 存储批次损失
        loss_epoch.append(total_loss / train_sample)
    return loss_epoch, epoch

轮次损失可视化

复制代码 
if __name__ == '__main__':
    x, y, coef = creat_datasets()
    dataloader, model = data_loader(x, y)
    loss_fn, optimizer = loss_optimizer(model)
    loss_epoch, epochs = train_model(dataloader, model, loss_fn, optimizer)
    print(loss_epoch)
    # 绘制损失变化曲线
    plt.plot(range(epochs), loss_epoch)
    plt.title('损失变化曲线')
    plt.grid()
    plt.show()
    # 绘制拟合直线
    plt.scatter(x, y)
    x = torch.linspace(x.min(), x.max(), 1000)
    y1 = torch.tensor([v * model.weight + model.bias for v in x])
    y2 = torch.tensor([v * coef + 1.5 for v in x])
    plt.plot(x, y1, label='训练')
    plt.plot(x, y2, label='真实')
    plt.grid()
    plt.legend()
    plt.show()

案例总结

相关推荐
学不会lostfound11 分钟前
三、计算机视觉_05MTCNN人脸检测
pytorch·深度学习·计算机视觉·mtcnn·p-net·r-net·o-net
红色的山茶花13 分钟前
YOLOv8-ultralytics-8.2.103部分代码阅读笔记-block.py
笔记·深度学习·yolo
龙的爹233314 分钟前
论文翻译 | RECITATION-AUGMENTED LANGUAGE MODELS
人工智能·语言模型·自然语言处理·prompt·gpu算力
白光白光14 分钟前
凸函数与深度学习调参
人工智能·深度学习
sp_fyf_202416 分钟前
【大语言模型】ACL2024论文-18 MINPROMPT：基于图的最小提示数据增强用于少样本问答
人工智能·深度学习·神经网络·目标检测·机器学习·语言模型·自然语言处理
weixin_5436628619 分钟前
BERT的中文问答系统33
人工智能·深度学习·bert
爱喝白开水a22 分钟前
Sentence-BERT实现文本匹配【分类目标函数】
人工智能·深度学习·机器学习·自然语言处理·分类·bert·大模型微调
Jack黄从零学c++43 分钟前
opencv(c++)---自带的卷积运算filter2D以及应用
c++·人工智能·opencv
封步宇AIGC1 小时前
量化交易系统开发-实时行情自动化交易-4.2.3.指数移动平均线实现
人工智能·python·机器学习·数据挖掘
Mr.谢尔比1 小时前
李宏毅机器学习课程知识点摘要（1-5集）
人工智能·pytorch·深度学习·神经网络·算法·机器学习·计算机视觉
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06RAG 实践- Ollama+RagFlow 部署本地知识库0704 - matlab m_map地学绘图工具基础函数 - 设置网格08Unity中PICO实现 隔空取物 和 接触抓取物体09Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO10【目标跟踪】相机运动补偿