pytorch 入门基础知识一(Pytorch 01)

一 深度学习基础相关

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

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

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

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

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

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

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

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

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

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

二 pytorch 基础操作

2.1 数据生成 (pytorch叫张量)

import torch
import torchvisionx = 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.))

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.hqwc.cn/news/544584.html

如若内容造成侵权/违法违规/事实不符,请联系编程知识网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

Vue3+TypeScript 学习回顾,温故而知新

文章简介: (1)简介: 在 Vue3 中编码规范如下: 编码语言: JavaScript代码风格: 组合式API选项式、API简写形式: setup语法糖 (2)复习内容: 1.核心: ref、reactive、computed、w…

阿里EMO模型:AI生成表情丰富的视频

引言 在数字多媒体的时代,人们对于互动性和个性化视频内容的需求不断增长。阿里巴巴的EMO(Emote Portrait Alive)模型,作为一项前沿的人工智能技术,正引领着这一领域的革新之路。 EMO模型概述 EMO模型是阿里巴巴智能计…

​​SQLiteC/C++接口详细介绍之sqlite3类(十)

返回目录:SQLite—免费开源数据库系列文章目录 上一篇:SQLiteC/C接口详细介绍之sqlite3类(九) 下一篇:​​SQLiteC/C接口详细介绍之sqlite3类(十一) 30.sqlite3_enable_load_extension&#x…

手机中的8款万能App推荐!

目录 1.全能AI工具箱——HuluAI 2.AI视频生成——巨日禄 3.全能办公套件——鲸鲮Office 4.视频音频转换器——VideotoMP3Converter 5.特效滤镜摄影——PicsArt 6.智能工具箱——SmartTools 7.手机视频编辑软件——KineMaster 8.安卓版万能文档阅读器——AllDocumentRea…

实现兼容性良好的前端页面开发

🤍 前端开发工程师、技术日更博主、已过CET6 🍨 阿珊和她的猫_CSDN博客专家、23年度博客之星前端领域TOP1 🕠 牛客高级专题作者、打造专栏《前端面试必备》 、《2024面试高频手撕题》 🍚 蓝桥云课签约作者、上架课程《Vue.js 和 E…

切面条-蓝桥杯?-Lua 中文代码解题第1题

切面条-蓝桥杯?-Lua 中文代码解题第1题 一根高筋拉面,中间切一刀,可以得到2根面条。 如果先对折1次,中间切一刀,可以得到3根面条。 如果连续对折2次,中间切一刀,可以得到5根面条。 那么&#xf…

sqlalb第二十五关通关笔记

知识点: or and # 被过滤了有回显可以用联合注入这里可以利用双写绕过(亲测有效,) oorranandd这样的话可以使用错误注入(不演示了,有兴趣可以试一下) 又是一个id输入 测试是什么类型的注入 构…

宝塔 安装对外服务Tomcat和JDK

一、安装Tomcat\JDK 切记1:如果选择下载节点失败,请到软件商城安装 。 切记2:提醒安装Nginx或Apache ,先点安装,进入再打叉关闭。因为Tomcat服务足够为我们搭建JavaWeb网站服务了。 切记3:Nginx占用80端口…

回答自己一年前的一个问题,python如何动态拼接sql

首先谈谈应用场景吧,前提是针对查询接口做接口自动化,接口校验的脚本中,一般以响应报文作为预期值,通过sql查出的数据库值作为实际值,二者对比通过则认为接口输出正确。而sql从何而来呢,对于查询接口一般是…

高可用系统有哪些设计原则

1.降级 主动降级:开关推送 被动降级:超时降级 异常降级 失败率 熔断保护 多级降级2.限流 nginx的limit模块 gateway redisLua 业务层限流 本地限流 gua 分布式限流 sentinel 3.弹性计算 弹性伸缩—K8Sdocker 主链路压力过大的时候可以将非主链路的机器给…

校园博客系统 |基于springboot框架+ Mysql+Java的校园博客系统设计与实现(可运行源码+数据库+设计文档)

推荐阅读100套最新项目 最新ssmjava项目文档视频演示可运行源码分享 最新jspjava项目文档视频演示可运行源码分享 最新Spring Boot项目文档视频演示可运行源码分享 目录 前台功能效果图 管理员功能登录前台功能效果图 系统功能设计 数据库E-R图设计 lunwen参考 摘要 研究…

maven工程,未被idea识别为maven工程怎么办?

示例:以下工程的pom文件图标不是一个蓝色的m,所以未被识别为maven工程。 解决办法:打开pom.xml文件—>右键—>add as maven project 问题解决: