pytorch 基础知识一（Pytorch 01）

已于 2024-03-26 08:36:09 修改
阅读量1k 收藏 16
点赞数 24
分类专栏： Pytorch 文章标签： pytorch 人工智能 python
于 2024-03-16 17:37:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/March_A/article/details/136763612
版权

一 深度学习基础相关

深度学习三个主要的方向：计算机视觉，自然语言，语音识别。

机器学习核心组件：1 数据集(data)，2 前向传播的model(net)，3 目标函数(loss)， 4 调整模型参数和优化函数的算法(adam)。

数据集：用于模型训练的数据。

模型：用于前向传播计算的model, 其中涉及各种复杂的网络，Alexnet, CNN等都属于这个模块的内容，对于传统模型，常规使用公式计算结果的公式其实就是模型的一种，模型主要作用是通过记录的参数计算想要的目标值。

目标函数：常用的均方误差，平方误差都是，目标函数的一直，用于评估预测值和实际结果的偏差。

优化算法：深度学习常用的梯度下降算法，在训练模型参数时用于减小损失误差。

不管是回归还是分类问题其实都是监督学习的内容，就是在训练模型是有一个目标值，而聚类算法，对抗性网络等属于无监督学习。

强化学习更考虑与环境的互动，在实际环境中根据实际结果做反馈实时修正模型。

PS：机器学习很吃数据，如果数据量不够，可能得考虑传统方法，比如之前遇到的一个项目，训练数据不够，属于前期就介入，根本没太多历史数据，不能够拟合出正确应对实际场景的应用，最后使用传统反馈调整的模式解决了问题，做视觉其实也遇到了这个问题，异常数据太少，而且不是很普遍，还是考虑传统方式处理，起码稳定。

计算机算力确实发生了很大的变化，近两年还是风云突变：

二 pytorch 基础操作

2.1 数据生成 (pytorch叫张量)

import torch
import torchvision

x = torch.arange(12)
x   # tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

 查看数据形状：

x.shape

# torch.Size([12])

查看张量的总数据量：

x.numel()   # 矩阵元素数量  # 12

调整张量的形状：

X = x.reshape(3, 4)
X
# tensor([[ 0,  1,  2,  3],
#         [ 4,  5,  6,  7],
#         [ 8,  9, 10, 11]])

生成指定形状的数组：

torch.zeros((2, 3, 4))
# tensor([[[0., 0., 0., 0.],
#          [0., 0., 0., 0.],
#          [0., 0., 0., 0.]],

#         [[0., 0., 0., 0.],
#          [0., 0., 0., 0.],
#          [0., 0., 0., 0.]]])

指定形状数据为1的张量：

torch.ones((2, 3, 4))
# tensor([[[1., 1., 1., 1.],
#          [1., 1., 1., 1.],
#          [1., 1., 1., 1.]],

#         [[1., 1., 1., 1.],
#          [1., 1., 1., 1.],
#          [1., 1., 1., 1.]]])

正太分布的张量：

torch.randn(3, 4)
# tensor([[ 1.2365,  0.2051,  1.0180,  1.2629],
#         [-1.2494, -0.3436, -0.7135, -2.0160],
#         [-1.2806,  1.5036, -0.2523, -0.1456]])

直接将列表转换为tensor张量：

torch.tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
# tensor([[2, 1, 4, 3],
#         [1, 2, 3, 4],
#         [4, 3, 2, 1]])

2.2 pytorch 运算符

可以直接 + - * /：

x = torch.tensor([1.0, 2, 4, 8])
y = torch.tensor([2, 2, 2, 2])
x + y, x - y, x * y, x / y, x ** y # **运算符是求幂运算
# (tensor([ 3.,  4.,  6., 10.]),
#  tensor([-1.,  0.,  2.,  6.]),
#  tensor([ 2.,  4.,  8., 16.]),
#  tensor([0.5000, 1.0000, 2.0000, 4.0000]),
#  tensor([ 1.,  4., 16., 64.]))

求幂：

torch.exp(x)   # e^x
# tensor([2.7183e+00, 7.3891e+00, 5.4598e+01, 2.9810e+03])

张量拼接，通过dim指定行还是列拼接：

X = torch.arange(12, dtype=torch.float32).reshape((3,4))
Y = torch.tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
torch.cat((X, Y), dim=0), torch.cat((X, Y), dim=1)
# (tensor([[ 0.,  1.,  2.,  3.],
#          [ 4.,  5.,  6.,  7.],
#          [ 8.,  9., 10., 11.],
#          [ 2.,  1.,  4.,  3.],
#          [ 1.,  2.,  3.,  4.],
#          [ 4.,  3.,  2.,  1.]]),
#  tensor([[ 0.,  1.,  2.,  3.,  2.,  1.,  4.,  3.],
#          [ 4.,  5.,  6.,  7.,  1.,  2.,  3.,  4.],
#          [ 8.,  9., 10., 11.,  4.,  3.,  2.,  1.]]))

逻辑运算：

X == Y
# tensor([[False,  True, False,  True],
#         [False, False, False, False],
#         [False, False, False, False]])

所有元素求和：

X.sum()
# tensor(66.)

2.3 广播机制

a = torch.arange(3).reshape((3, 1))
b = torch.arange(2).reshape((1, 2))
a, b
# (tensor([[0],
#          [1],
#          [2]]),
#  tensor([[0, 1]]))

自动广播：

a + b
# tensor([[0, 1],
#         [1, 2],
#         [2, 3]])

2.4 索引和切片

张量切片：

X = torch.arange(12, dtype=torch.float32).reshape((3,4))
X[-1], X[1:3]
# (tensor([ 8.,  9., 10., 11.]),
#  tensor([[ 4.,  5.,  6.,  7.],
#          [ 8.,  9., 10., 11.]]))

指定位置写入数据：

X[1, 2] = 9
X
# tensor([[ 0.,  1.,  2.,  3.],
#         [ 4.,  5.,  9.,  7.],
#         [ 8.,  9., 10., 11.]])

同时写入多个值：

X[0:2, :] = 12
X
# tensor([[12., 12., 12., 12.],
#         [12., 12., 12., 12.],
#         [ 8.,  9., 10., 11.]])

2.5 原地更新参数

查看内存地址：

before = id(Y)
Y = Y + X
id(Y) == before
# False

张量原地更新：

Z = torch.zeros_like(Y)
print('id(Z):', id(Z))
Z[:] = X + Y
print('id(Z):', id(Z))
# id(Z): 2385633027792
# id(Z): 2385633027792

也可以直接写入原地址：

before = id(X)
X += Y
id(X) == before
# True

2.6 转换为python其他数据类型

numpy转换, torch.tensor() :

A = X.numpy()
B = torch.tensor(A)
type(A), type(B)
# (numpy.ndarray, torch.Tensor)

直接转换，a.item() 用于获取张量（Tensor）中单个元素 的值：

a = torch.tensor([3.5])
a, a.item(), float(a), int(a)
# (tensor([3.5000]), 3.5, 3.5, 3)

三 数据预处理

3.1 读取数据集

创建数据写入 house_tiny.csv 文件：

import os
os.makedirs(os.path.join('..', 'data'), exist_ok=True)
data_file = os.path.join('..', 'data', 'house_tiny.csv')
with open(data_file, 'w') as f:
    f.write('NumRooms,Alley,Price\n') # 列名
    f.write('NA,Pave,127500\n') # 每行表示一个数据样本
    f.write('2,NA,106000\n')
    f.write('4,NA,178100\n')
    f.write('NA,NA,140000\n')

pd.read_csv() 读取数据：

import pandas as pd
data = pd.read_csv(data_file)
print(data)
#    NumRooms Alley   Price
# 0       NaN  Pave  127500
# 1       2.0   NaN  106000
# 2       4.0   NaN  178100
# 3       NaN   NaN  140000

3.2 处理缺失值

第一列均值填充：

inputs, outputs = data.iloc[:, 0:2], data.iloc[:, 2]
# 使用均值填充第一列的缺失值
inputs.iloc[:, 0] = inputs.iloc[:, 0].fillna(inputs.iloc[:, 0].mean())
print(inputs)
#    NumRooms Alley
# 0       3.0  Pave
# 1       2.0   NaN
# 2       4.0   NaN
# 3       3.0   NaN

第二列独热编码：

inputs = pd.get_dummies(inputs, dummy_na=True)
print(inputs)
#    NumRooms  Alley_Pave  Alley_nan
# 0       3.0        True      False
# 1       2.0       False       True
# 2       4.0       False       True
# 3       3.0       False       True

数据格式转换为张量：

import torch
X = torch.tensor(inputs.to_numpy(dtype=float))
y = torch.tensor(outputs.to_numpy(dtype=float))
X, y
# (tensor([[3., 1., 0.],
#          [2., 0., 1.],
#          [4., 0., 1.],
#          [3., 0., 1.]], dtype=torch.float64),
#  tensor([127500., 106000., 178100., 140000.], dtype=torch.float64))

四 线性代数

标量：

import torch
x = torch.tensor(3.0)
y = torch.tensor(2.0)
x + y, x * y, x / y, x**y
# (tensor(5.), tensor(6.), tensor(1.5000), tensor(9.))

向量可以被视为标量值组成的列表：

x = torch.arange(4)
x
# tensor([0, 1, 2, 3])

下标 取元素：

x[3]
# tensor(3)

向量 长度：

len(x)
# 4

张量形状：

x.shape
# torch.Size([4])

4.1 矩阵

向量将标量从零阶推广到一阶，矩阵将向量从一阶推广到二阶。

A = torch.arange(20).reshape(5, 4)
A
# tensor([[ 0,  1,  2,  3],
#         [ 4,  5,  6,  7],
#         [ 8,  9, 10, 11],
#         [12, 13, 14, 15],
#         [16, 17, 18, 19]])

矩阵转置：

A.T
# tensor([[ 0,  4,  8, 12, 16],
#         [ 1,  5,  9, 13, 17],
#         [ 2,  6, 10, 14, 18],
#         [ 3,  7, 11, 15, 19]])

对称矩阵，一个矩阵和它的转置矩阵一样的时候该矩阵为对称矩阵：

B = torch.tensor([[1, 2, 3], [2, 0, 4], [3, 4, 5]])
B
# tensor([[1, 2, 3],
#         [2, 0, 4],
#         [3, 4, 5]])
B == B.T
# tensor([[True, True, True],
#         [True, True, True],
#         [True, True, True]])

4.2 张量

张量是一个更广泛的概念，可以包括标量、向量以及更高维度的数组。

X = torch.arange(24).reshape(2, 3, 4)
X
# tensor([[[ 0,  1,  2,  3],
#          [ 4,  5,  6,  7],
#          [ 8,  9, 10, 11]],

#         [[12, 13, 14, 15],
#          [16, 17, 18, 19],
#          [20, 21, 22, 23]]])

4.3 张量算法的基本性质

给定具有相同形 状的任意两个张量，任何按元素二元运算的结果都将是相同形状的张量。例如，将两个相同形状的矩阵相加， 会在这两个矩阵上执行元素加法，张量形状不变。

A = torch.arange(20, dtype=torch.float32).reshape(5, 4)
B = A.clone() # 通过分配新内存，将A的一个副本分配给B
A, A + B
# (tensor([[ 0.,  1.,  2.,  3.],
#          [ 4.,  5.,  6.,  7.],
#          [ 8.,  9., 10., 11.],
#          [12., 13., 14., 15.],
#          [16., 17., 18., 19.]]),
#  tensor([[ 0.,  2.,  4.,  6.],
#          [ 8., 10., 12., 14.],
#          [16., 18., 20., 22.],
#          [24., 26., 28., 30.],
#          [32., 34., 36., 38.]]))
A * B
# tensor([[  0.,   1.,   4.,   9.],
#         [ 16.,  25.,  36.,  49.],
#         [ 64.,  81., 100., 121.],
#         [144., 169., 196., 225.],
#         [256., 289., 324., 361.]])

将张量乘以或加上一个标量不会改变张量的形状，其中张量的每个元素都将与标量相加或相乘，广播机制。

a = 2
X = torch.arange(24).reshape(2, 3, 4)
a + X, (a * X).shape
# (tensor([[[ 2,  3,  4,  5],
#           [ 6,  7,  8,  9],
#           [10, 11, 12, 13]],
 
#          [[14, 15, 16, 17],
#           [18, 19, 20, 21],
#           [22, 23, 24, 25]]]),
#  torch.Size([2, 3, 4]))

4.4 降维

x = torch.arange(4, dtype=torch.float32)
x, x.sum()
# (tensor([0., 1., 2., 3.]), tensor(6.))

 sum() 可以对所有元素求和，算预测结果损失和有用：

A.shape, A.sum()
# (torch.Size([5, 4]), tensor(190.))

axis 指定张量降维维度：

A_sum_axis0 = A.sum(axis=0)
A_sum_axis0, A_sum_axis0.shape
# (tensor([40., 45., 50., 55.]), torch.Size([4]))
A_sum_axis1 = A.sum(axis=1)
A_sum_axis1, A_sum_axis1.shape
# (tensor([ 6., 22., 38., 54., 70.]), torch.Size([5]))
A.sum(axis=[0, 1]) # 结果和A.sum()相同
# tensor(190.)

求所有元素均值：

A.mean(), A.sum() / A.numel()
# (tensor(9.5000), tensor(9.5000))

指定维度均值：

A.mean(axis=0), A.sum(axis=0) / A.shape[0]
# (tensor([ 8.,  9., 10., 11.]), tensor([ 8.,  9., 10., 11.]))

非降维求和：

sum_A = A.sum(axis=1, keepdims=True)
sum_A
# # tensor([[ 6.],
#         [22.],
#         [38.],
#         [54.],
#         [70.]])

 由于sum_A在对每行进行求和后仍保持两个轴，我们可以通过广播将A除以sum_A，求该行每个元素的占比。

A / sum_A
# tensor([[0.0000, 0.1667, 0.3333, 0.5000],
#         [0.1818, 0.2273, 0.2727, 0.3182],
#         [0.2105, 0.2368, 0.2632, 0.2895],
#         [0.2222, 0.2407, 0.2593, 0.2778],
#         [0.2286, 0.2429, 0.2571, 0.2714]])

沿某个轴计算A元素的累积总和，比如axis=0（按行计算），可以调用cumsum函数。

print(A)
A.cumsum(axis=0)
# tensor([[ 0.,  1.,  2.,  3.],
#         [ 4.,  5.,  6.,  7.],
#         [ 8.,  9., 10., 11.],
#         [12., 13., 14., 15.],
#         [16., 17., 18., 19.]])
# tensor([[ 0.,  1.,  2.,  3.],
#         [ 4.,  6.,  8., 10.],
#         [12., 15., 18., 21.],
#         [24., 28., 32., 36.],
#         [40., 45., 50., 55.]])

4.5 点积

深度学习中线性模型在 前向传播中使用的就是点积：

x = torch.arange(4, dtype=torch.float32)
y = torch.ones(4, dtype = torch.float32)
x, y, torch.dot(x, y)
# (tensor([0., 1., 2., 3.]), tensor([1., 1., 1., 1.]), tensor(6.))

可以通过执行按元素乘法，然后进行求和来表示两个向量的点积：

torch.sum(x * y)
# tensor(6.)

矩阵向量积，结果是一个新的向量，A的列维数（沿轴1的长度）必须与x的维数（其长度）相同：

print(A)
print(x)
A.shape, x.shape, torch.mv(A, x)
# tensor([[ 0.,  1.,  2.,  3.],
#         [ 4.,  5.,  6.,  7.],
#         [ 8.,  9., 10., 11.],
#         [12., 13., 14., 15.],
#         [16., 17., 18., 19.]])
# tensor([0., 1., 2., 3.])
# (torch.Size([5, 4]), torch.Size([4]), tensor([ 14.,  38.,  62.,  86., 110.]))

矩阵-矩阵乘法，torch.mm 用于计算两个矩阵的乘积：

B = torch.ones(4, 3)
A, B, torch.mm(A, B)
# (tensor([[ 0.,  1.,  2.,  3.],
#          [ 4.,  5.,  6.,  7.],
#          [ 8.,  9., 10., 11.],
#          [12., 13., 14., 15.],
#          [16., 17., 18., 19.]]),
#  tensor([[1., 1., 1.],
#          [1., 1., 1.],
#          [1., 1., 1.],
#          [1., 1., 1.]]),
#  tensor([[ 6.,  6.,  6.],
#          [22., 22., 22.],
#          [38., 38., 38.],
#          [54., 54., 54.],
#          [70., 70., 70.]]))

4.6 范数

欧几里得距离是一个L2范数，向量元素平方和的平方根：

u = torch.tensor([3.0, -4.0])
torch.norm(u)
# tensor(5.)

L1范数，我们将元素绝对值求和 组合起来：

torch.abs(u).sum()
# tensor(7.)

Frobenius范数 满足向量范数的所有性质，它就像是 矩阵形向量的L2范数。

n = torch.ones((4, 9))
n, torch.norm(n)
# (tensor([[1., 1., 1., 1., 1., 1., 1., 1., 1.],
#          [1., 1., 1., 1., 1., 1., 1., 1., 1.],
#          [1., 1., 1., 1., 1., 1., 1., 1., 1.],
#          [1., 1., 1., 1., 1., 1., 1., 1., 1.]]),
#  tensor(6.))

处女座_三月
关注
  • 24
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Pytorch入门基础知识（一）
qq_42681787的博客
10-26 2546
pytorch入门基础知识点
pytorch 基础知识2.0
01-20
PyTorch 基础知识2.0 PyTorch 是一个基于 Python 的机器学习框架，广泛应用于深度学习和人工智能领域。下面是 PyTorch 基础知识2.0 中的知识点： 1. torch.mean() torch.mean() 函数用于计算 tensor 的均值。在...
PyTorch基础知识
m0_60773218的博客
07-11 1357
PyTorch最基本的操作对象是Tensor（张量）。张量是一个数字容器，同时也是定义张量转换来生成新张量的一组规则。
pytorch基础知识一
qq_42368048的博客
01-25 896
pytorch系列，其中可能会有一些小项目，持续更新
PyTorch基础知识(超基础)
一名在读大学生，正在学习深度学习，会定期分享一些该领域内容。欢迎大家一起交流学习~
07-05 1965
PyTorch是在2017年1月由Facebook推出的。它是经典机器学习库Torch框架的一个端口，主要编程语言为python。PyTorch“曾经”的优点是动态图，现在的优点是开源代码和开源社区。PyTorch是一个年轻的框架。2017年1月28日，PyTorch 0.1版本正式发布，这是Facebook公司在机器学习和科学计算工具Torch的基础上，针对Python语言发布的全新的深度学习工具包。PyTorch类似NumPy，并且支持GPU，有着更高级而又易用的功能，可以用来快捷地构建和训练深度神经网
Pytorch 基础知识总结（一）
m0_56144250的博客
10-11 1805
Pytorch基础知识点：张量类型的理解和创建，通过张量的创建构造一个带有随机噪声的线性分布人造数据集。
pytorch基础知识
lemonHe的博客
05-19 668
参考pytorch官方教程，撸pytorch基础知识，记录学习的过程 主要参考DEEP LEARNING WITH PYTORCH: A 60 MINUTE BLITZ，再加上一些numpy的基础知识，这算是一篇对pytorch和numpy的基础知识的总结吧，共分5个方面，这里主要记录1，2部分的学习，英语较好的同学可以直接看参考[1]。 pytorch是基于python的一个科学计算包，主要面...
【PyTorch基础】 -- 基础知识
qq_46656857的博客
03-11 543
PyTorch的学习笔记
【PyTorch学习】PyTorch基础知识
QianT
03-30 1985
一、Pytorch介绍 1.1 什么是Pytorch PyTorch 是 Torch7 团队开发的，从它的名字就可以看出，其与 Torch 的不同之处在于 PyTorch 使用了 Python 作为开发语言。 PyTorch 既可以看做加入了 GPU 支持的 numpy，同时也可以看 成一个拥有自动求导功能的强大的深度神经网络，除了 Facebook之外，它还已经被 Twitter、CMU ...
PyTorch基础知识（可入门）
weixin_43421371的博客
04-14 2492
PyTorch基础 核心是张量Tensor，一种多维数据的数学对象。 使用torch包创建张量，具体的很简单，不多说了。 （1）如果想用特定的值填充张量，可以使用 fill_() 方法。【任何带有下划线(_)的PyTorch方法都是指原位操作，即不用创建新对象就地修改内容】 （2）当使用torch.Tensor构造函数时，默认张量类型是torch.FloatTensor。可以在使用时进行类型转换 或 利用torch.tensor()中的dtype参数。 加减乘除操作都和其他类似。 torch.transp
Pytorch基础知识学习
weixin_43999801的博客
02-26 325
pytorch基础知识大全【持续更新ing】
pytorch基础知识1.0
01-20
PyTorch 基础知识 1.0 PyTorch 是一个基于 Python 的机器学习库，特别适合深度学习。下面是 PyTorch 基础知识 1.0 的相关知识点...这些知识点只是 PyTorch 基础知识 1.0 的一部分，更多的知识点还需要继续学习和实践。
pytorch基础知识，入门学习
11-23
pytorch基础知识，入门学习，从框架到深度学习训练
基于自编码器的心电信号异常检测（Pytorch）
最新发布
weixin_39402231的博客
06-17 446
基于自编码器的心电信号异常检测（Pytorch）
PyTorch -- 最常见损失函数 LOSS 的选择
CODE_RabbitV的博客
06-13 801
MSE CEL ...
Pytorch--Convolution Layers
qq_44815135的博客
06-12 676
输出形状为 (batch_size, out_channels, output_height, output_width)，其中 output_height 和 output_width 是输出特征图的高度和宽度，取决于输入图像的大小、卷积核大小、填充和步幅等参数。一维卷积层的输入形状为 (batch_size, in_channels, input_length)，其中 batch_size 是批次大小，input_length 是输入序列的长度。因此，转置卷积层通常用于生成更高分辨率的特征图。
【PyTorch 新手基础】一分钟快速部署 learning rate decay
CODE_RabbitV的博客
06-13 423
当设定指标在最近几个epoch中都没有变化时，调整学习率。】每 n=step_size 轮，调整学习率。
pytorch基础代码知识
10-10
下面是一些PyTorch的基础代码知识： 1. 张量（Tensor）操作： - 创建张量：使用`torch.tensor()`函数可以创建一个张量。 - 张量的属性：可以使用`.shape`属性获取张量的形状，使用`.dtype`属性获取张量的数据类型...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值