由浅入深,走进深度学习(4)

2024-06-23 13:20

本文主要是介绍由浅入深,走进深度学习(4),希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

各位小伙伴大家好,这期内容是深度学习基础的一个进阶,也可以说是夯实一下很多细节内容

个人感受:动手敲一遍,带着思考,会有不一样的感受!!!

代码是比较多的,有很多内容我也是都在代码上面注释了~

正片开始!!!

首先,机器学习用的最多的是N维数组,N维数组是机器学习和神经网络的主要数据结构

注:

创建数组需要 形状(3×4) 数据类型(浮点数32位) 元素值(随机数)
访问元素 根据切片或者间隔步长访问元素  such as [::3, ::2] 每隔3行 2列 访问
访问 一个元素 [1, 2] 一行 [1, :] 一列 [:, 1] 子区域 [1:3, 1:]
张量数据操作

import torch
input = torch.arange(12) # 初始化一个0-11张量
print(input)# 访问张量形状
print(input.shape)# 张量中元素总数
print(input.numel())# 改变张量形状
input_reshape = input.reshape(3, 4) # 一维张量改为3行 4列张量
print(input_reshape)# 创建全0 全1 张量
zero = torch.zeros(2, 3, 4)
print(zero)one = torch.ones(2, 3, 4)
print(one)# 创建特定值张量
tensor1 = torch.tensor([[1, 2, 3],[2, 1, 5],[1, 5, 3]]) # 二维 tensor
tensor2 = torch.tensor([[[2, 2, 5],[1, 3, 2],[1, 2, 4]]]) # 三维 tensorprint(tensor1.shape)
print(tensor2.shape)

张量运算操作
常见的标准算术运算符(+、-、*、/、和 **)都可以被升级为按元素运算

import torch
input1 = torch.tensor([1.0, 2, 4, 8])
input2 = torch.tensor([2, 2, 2, 2])
print(input1 + input2)
print(input1 - input2)
print(input1 * input2)
print(input1 / input2)
print(input1 ** input2) # 运算符是求幂运算# 对每个元素应用更多的计算
output = torch.exp(input1) # e的x次方
print(output)# 张量合并操作
x = torch.arange(12, dtype = torch.float32).reshape((3, 4))
y = torch.tensor([[1, 2, 3, 2],[0.5, 4, 6, 3.0],[2, 1, 1, 0]])
m = torch.cat((x, y), dim = 0) # 按行拼
n = torch.cat((x, y), dim = 1) # 按列拼print(m)
print(n)# 张量逻辑符运算
# 通过逻辑运算符构建二元张量
import torch
x = torch.arange(12, dtype = torch.float32).reshape(3, 4)
y = torch.tensor([[1, 2, 3, 2],[0.5, 4, 6, 3.0],[2, 1, 1, 0]])
print(x, y)
print(x == y) # 对应元素相等为True 不相等为False# 张量累加运算
import torch
x = torch.arange(16, dtype = torch.float32).reshape(4, 4)
print(x.sum())# 张量广播运算
a = torch.arange(3).reshape((3, 1))
b = torch.arange(2).reshape((1, 2))
print(a, b)
print(a + b) # a会复制出一个3*2的矩阵,b复制出一个3*2的矩阵,然后再相加,会得到一个3*2矩阵  

张量访问计算
可以用[-1]选择最后一个元素,可以用[1:3]选择第二个和第三个元素

import torch
x = torch.arange(12, dtype = torch.float32).reshape((3, 4))
print(x)
print(x[-1])
print(x[1:3])# 张量元素改写
# 除读取外,还可以通过指定索引来将元素写入矩阵
import torch
x = torch.arange(12, dtype = torch.float32).reshape((3, 4))
print(x)
x[1, 2] = 9
print(x)# 为多个元素赋值相同的值,只需要索引所有元素,然后为它们赋值
import torch
x = torch.arange(12, dtype = torch.float32).reshape((3, 4))
print(x)
x[0:2, :] = 12  # 0:2 第一个 第二个 0:3 第一个 第二个 第三个 1:3 第二个 第三个 1:4 第二个 第三个 第四个
print(x)# 张量内存变化
# 运行一些操作可能会导致为新结果分配内容
import torch
x = torch.arange(12, dtype = torch.float32).reshape((3, 4))
y = torch.tensor([[1, 1, 2, 2],[2, 2, 3, 3],[4, 4, 2, 3]])
before = id(y)
print(before)
y = x + y
print(id(y) == before) # 运行操作后,赋值后的y的id和原来的id不一样   z = torch.zeros_like(y) # z 的数据类型、尺寸和y一样,里面的元素全为0print('id(z):', id(z))
z[:] = x + y
print('id(z):', id(z))# 如果在后续计算中没有重复使用X,即内存不会过多复制,也可以使用X[:] = X + Y 或 X += Y 来减少操作的内存开销
before1 = id(x)
x += y
print(id(x) == before1)# 张量转numpy
import torch
x = torch.arange(16, dtype = torch.float32).reshape((4, 4))
a = x.numpy()
b = torch.tensor(a)
print(type(a), a)
print(type(b), b)# 将大小为1的张量转为 Python 标量
import torch
a = torch.tensor([3.5])
print(a)
print(a.item())
print(float(a))
print(int(a))

线性代数
标量
标量由只有一个元素的张量表示

import torch
x = torch.tensor([3.5])
y = torch.tensor([4.0])
print(x + y)
print(x - y)
print(x * y)
print(x / y)
print(x ** y)# 访问向量元素
# 通过张量的索引来访问任一元素
import torch
z = torch.arange(12)
print(z)
print(z[3]) # 索引从0开始# 访问向量长度
# 访问张量长度
print(len(z))# 访问向量维度
# 只有一个轴的张量形状只有一个元素
print(z.shape)
# 矩阵
# 创建矩阵
# 通过指定两个分量m n 来创建一个形状为m×n的矩阵
import torch
A = torch.arange(20).reshape((4, 5))
print(A)# 矩阵的转置
print(A.T)# 对称矩阵
# 对称矩阵 等于其转置
B = torch.tensor([[1, 2, 3],[2, 0, 4],[3, 4, 5]])
print(B)
print(B.T)
print(B == B.T)# 多维矩阵
# 就像向量是标量的推广 矩阵是向量的推广一样 可以构建更多轴的数据结构
D = torch.arange(24).reshape((2, 3, 4))
print(D)# 矩阵克隆
import torch
x = torch.arange(20, dtype = torch.float32).reshape((4, 5))
y = x.clone() # 通过分配新内存 将x的一个副本分配给y
print(x)
print(y)
print(x + y)# 矩阵相乘 对应元素相乘
# 两个矩阵按元素乘法称为哈达玛积
import torch
A = torch.arange(20, dtype = torch.float32).reshape((5, 4))
B = A.clone()
print(A)
print(B)
print(A * B)
# 矩阵加标量
x = 2
A = torch.arange(24).reshape((2, 3, 4))
print(A)
print(A + x)
print((A + x).shape)# 向量求和
# 计算所有元素的和
M = torch.arange(4, dtype = torch.float32)
print(M)
print(M.sum())# 矩阵求和
# 表示任意形状张量的元素和
N = torch.arange(20 * 2).reshape((2, 4, 5))
print(N.shape)
print(N.sum())# 矩阵某轴求和 维度丢失
# 指定张量沿哪一个轴来通过求和降低维度
N_sum_axis0 = N.sum(axis = 0) #(2, 4, 5) 对第一个维度进行求和 剩下两个维度留下来
print('-------------------')
print(N)
print(N_sum_axis0)
print(N_sum_axis0.shape)
N_sum_axis1 = N.sum(axis = 1) #(2, 4, 5) 对第二个维度进行求和 剩下两个维度留下来
print('-------------------')
print(N_sum_axis1)
print(N_sum_axis1.shape)
N_sum_axis2 = N.sum([0 ,1]) #(2, 4, 5) 对第一 二个维度进行求和 剩下一个维度留下来
print('--------------------')
print(N_sum_axis2)
print(N_sum_axis2.shape)# 矩阵平均值
# 一个与求和相关的量是平均值
import torch
X = torch.arange(20, dtype = torch.float32).reshape((4, 5))
print(X)
print(X.mean())
print(X.numel())
print(X.mean() / X.numel())print('- - - - - - - - - -')
print(X.mean(axis = 0))  # 4×5 第二个维度留下来 5列
print(X.sum(axis = 0))  # 第二个维度留下来 5列
print(X.shape)
print(X.shape[0])
print(X.shape[1])
print(X.sum(axis = 0) / X.shape[0])
print(X.sum(axis = 0) / X.shape[1])# 矩阵某轴求和 维度不丢失
# 计算总和或均值时保持轴数不变
import torch
X = torch.arange(20, dtype = torch.float32).reshape((5, 4)) 
X_sum = X.sum(axis = 1, keepdims = True) # keepdims=True不丢掉维度,否则三维矩阵按一个维度求和就会变为二维矩阵,二维矩阵若按一个维度求和就会变为一维向量
print(X)
print(X_sum)
print(X_sum.shape) # 维度没有丢失,方便使用广播# 矩阵广播
# 通过广播将X除以X_sum
print('------------------')
print(X / X_sum)# 矩阵某轴累加总和
print('- - - - - - - - -')
print(X.cumsum(axis = 0))# 向量点积
# 点积是相同位置的按元素乘积的和
import torch
x = torch.arange(4, dtype = torch.float32)
y = torch.ones(4, dtype = torch.float32)
print(x)
print(y)
print(torch.dot(x, y))# 可以通过执行按元素乘法 然后进行求和来表示两个向量的点积
print(torch.sum(x * y))# 矩阵向量积
# A是一个m×n的矩阵,x是一个n×1的矩阵,矩阵向量积 是一个长度为m的列向量,其第i个元素是点积
import torch
A = torch.arange(20, dtype = torch.float32).reshape((5, 4))
x = torch.arange(4, dtype = torch.float32)
print(A)
print(x)
print(A.shape)
print(x.shape)
print(torch.mv(A, x))

矩阵相乘 线性代数相乘
可以将矩阵-矩阵乘法 AB 看作是简单地执行m次矩阵-向量积 并将结果拼接在一起 形成一个n×m矩阵

import torch
A = torch.arange(20 ,dtype = torch.float32).reshape((5, 4))
B = torch.ones(4, 3)
print(A)
print(B)
print(torch.mm(A, B))
# 矩阵L2范数
# L2范数是向量元素平方和的平方根
import torch
u = torch.tensor([3.0, -4.0])
print(torch.norm(u))# 矩阵L1范数
# L1范数 表示为向量元素的绝对值之和
print(torch.abs(u).sum())# 矩阵F范数
# 矩阵的弗罗贝尼乌斯范数(Frobenius norm)是矩阵元素的平方和的平方根
print(torch.norm(torch.ones((4, 9)))) # 把矩阵拉成一个向量,然后再求和

注:上述内容参考b站up主“我是土堆”的视频,参考吴恩达深度学习,机器学习内容,参考李沐动手学深度学习!!!

这篇关于由浅入深,走进深度学习(4)的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/1087271

相关文章

HarmonyOS学习(七)——UI(五)常用布局总结

自适应布局 1.1、线性布局(LinearLayout) 通过线性容器Row和Column实现线性布局。Column容器内的子组件按照垂直方向排列,Row组件中的子组件按照水平方向排列。 属性说明space通过space参数设置主轴上子组件的间距,达到各子组件在排列上的等间距效果alignItems设置子组件在交叉轴上的对齐方式,且在各类尺寸屏幕上表现一致,其中交叉轴为垂直时,取值为Vert

Ilya-AI分享的他在OpenAI学习到的15个提示工程技巧

Ilya(不是本人,claude AI)在社交媒体上分享了他在OpenAI学习到的15个Prompt撰写技巧。 以下是详细的内容: 提示精确化:在编写提示时,力求表达清晰准确。清楚地阐述任务需求和概念定义至关重要。例:不用"分析文本",而用"判断这段话的情感倾向:积极、消极还是中性"。 快速迭代:善于快速连续调整提示。熟练的提示工程师能够灵活地进行多轮优化。例:从"总结文章"到"用

【前端学习】AntV G6-08 深入图形与图形分组、自定义节点、节点动画(下)

【课程链接】 AntV G6:深入图形与图形分组、自定义节点、节点动画(下)_哔哩哔哩_bilibili 本章十吾老师讲解了一个复杂的自定义节点中,应该怎样去计算和绘制图形,如何给一个图形制作不间断的动画,以及在鼠标事件之后产生动画。(有点难,需要好好理解) <!DOCTYPE html><html><head><meta charset="UTF-8"><title>06

学习hash总结

2014/1/29/   最近刚开始学hash,名字很陌生,但是hash的思想却很熟悉,以前早就做过此类的题,但是不知道这就是hash思想而已,说白了hash就是一个映射,往往灵活利用数组的下标来实现算法,hash的作用:1、判重;2、统计次数;

零基础学习Redis(10) -- zset类型命令使用

zset是有序集合,内部除了存储元素外,还会存储一个score,存储在zset中的元素会按照score的大小升序排列,不同元素的score可以重复,score相同的元素会按照元素的字典序排列。 1. zset常用命令 1.1 zadd  zadd key [NX | XX] [GT | LT]   [CH] [INCR] score member [score member ...]

【机器学习】高斯过程的基本概念和应用领域以及在python中的实例

引言 高斯过程(Gaussian Process,简称GP)是一种概率模型,用于描述一组随机变量的联合概率分布,其中任何一个有限维度的子集都具有高斯分布 文章目录 引言一、高斯过程1.1 基本定义1.1.1 随机过程1.1.2 高斯分布 1.2 高斯过程的特性1.2.1 联合高斯性1.2.2 均值函数1.2.3 协方差函数(或核函数) 1.3 核函数1.4 高斯过程回归(Gauss

【学习笔记】 陈强-机器学习-Python-Ch15 人工神经网络(1)sklearn

系列文章目录 监督学习:参数方法 【学习笔记】 陈强-机器学习-Python-Ch4 线性回归 【学习笔记】 陈强-机器学习-Python-Ch5 逻辑回归 【课后题练习】 陈强-机器学习-Python-Ch5 逻辑回归(SAheart.csv) 【学习笔记】 陈强-机器学习-Python-Ch6 多项逻辑回归 【学习笔记 及 课后题练习】 陈强-机器学习-Python-Ch7 判别分析 【学

系统架构师考试学习笔记第三篇——架构设计高级知识(20)通信系统架构设计理论与实践

本章知识考点:         第20课时主要学习通信系统架构设计的理论和工作中的实践。根据新版考试大纲,本课时知识点会涉及案例分析题(25分),而在历年考试中,案例题对该部分内容的考查并不多,虽在综合知识选择题目中经常考查,但分值也不高。本课时内容侧重于对知识点的记忆和理解,按照以往的出题规律,通信系统架构设计基础知识点多来源于教材内的基础网络设备、网络架构和教材外最新时事热点技术。本课时知识

线性代数|机器学习-P36在图中找聚类

文章目录 1. 常见图结构2. 谱聚类 感觉后面几节课的内容跨越太大,需要补充太多的知识点,教授讲得内容跨越较大,一般一节课的内容是书本上的一章节内容,所以看视频比较吃力,需要先预习课本内容后才能够很好的理解教授讲解的知识点。 1. 常见图结构 假设我们有如下图结构: Adjacency Matrix:行和列表示的是节点的位置,A[i,j]表示的第 i 个节点和第 j 个

Node.js学习记录(二)

目录 一、express 1、初识express 2、安装express 3、创建并启动web服务器 4、监听 GET&POST 请求、响应内容给客户端 5、获取URL中携带的查询参数 6、获取URL中动态参数 7、静态资源托管 二、工具nodemon 三、express路由 1、express中路由 2、路由的匹配 3、路由模块化 4、路由模块添加前缀 四、中间件