由浅入深,走进深度学习(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

相关文章

SpringCloud动态配置注解@RefreshScope与@Component的深度解析

《SpringCloud动态配置注解@RefreshScope与@Component的深度解析》在现代微服务架构中,动态配置管理是一个关键需求,本文将为大家介绍SpringCloud中相关的注解@Re... 目录引言1. @RefreshScope 的作用与原理1.1 什么是 @RefreshScope1.

Python 中的异步与同步深度解析(实践记录)

《Python中的异步与同步深度解析(实践记录)》在Python编程世界里,异步和同步的概念是理解程序执行流程和性能优化的关键,这篇文章将带你深入了解它们的差异,以及阻塞和非阻塞的特性,同时通过实际... 目录python中的异步与同步:深度解析与实践异步与同步的定义异步同步阻塞与非阻塞的概念阻塞非阻塞同步

Redis中高并发读写性能的深度解析与优化

《Redis中高并发读写性能的深度解析与优化》Redis作为一款高性能的内存数据库,广泛应用于缓存、消息队列、实时统计等场景,本文将深入探讨Redis的读写并发能力,感兴趣的小伙伴可以了解下... 目录引言一、Redis 并发能力概述1.1 Redis 的读写性能1.2 影响 Redis 并发能力的因素二、

最新Spring Security实战教程之表单登录定制到处理逻辑的深度改造(最新推荐)

《最新SpringSecurity实战教程之表单登录定制到处理逻辑的深度改造(最新推荐)》本章节介绍了如何通过SpringSecurity实现从配置自定义登录页面、表单登录处理逻辑的配置,并简单模拟... 目录前言改造准备开始登录页改造自定义用户名密码登陆成功失败跳转问题自定义登出前后端分离适配方案结语前言

Java进阶学习之如何开启远程调式

《Java进阶学习之如何开启远程调式》Java开发中的远程调试是一项至关重要的技能,特别是在处理生产环境的问题或者协作开发时,:本文主要介绍Java进阶学习之如何开启远程调式的相关资料,需要的朋友... 目录概述Java远程调试的开启与底层原理开启Java远程调试底层原理JVM参数总结&nbsMbKKXJx

Redis 内存淘汰策略深度解析(最新推荐)

《Redis内存淘汰策略深度解析(最新推荐)》本文详细探讨了Redis的内存淘汰策略、实现原理、适用场景及最佳实践,介绍了八种内存淘汰策略,包括noeviction、LRU、LFU、TTL、Rand... 目录一、 内存淘汰策略概述二、内存淘汰策略详解2.1 ​noeviction(不淘汰)​2.2 ​LR

Python与DeepSeek的深度融合实战

《Python与DeepSeek的深度融合实战》Python作为最受欢迎的编程语言之一,以其简洁易读的语法、丰富的库和广泛的应用场景,成为了无数开发者的首选,而DeepSeek,作为人工智能领域的新星... 目录一、python与DeepSeek的结合优势二、模型训练1. 数据准备2. 模型架构与参数设置3

Java深度学习库DJL实现Python的NumPy方式

《Java深度学习库DJL实现Python的NumPy方式》本文介绍了DJL库的背景和基本功能,包括NDArray的创建、数学运算、数据获取和设置等,同时,还展示了如何使用NDArray进行数据预处理... 目录1 NDArray 的背景介绍1.1 架构2 JavaDJL使用2.1 安装DJL2.2 基本操

最长公共子序列问题的深度分析与Java实现方式

《最长公共子序列问题的深度分析与Java实现方式》本文详细介绍了最长公共子序列(LCS)问题,包括其概念、暴力解法、动态规划解法,并提供了Java代码实现,暴力解法虽然简单,但在大数据处理中效率较低,... 目录最长公共子序列问题概述问题理解与示例分析暴力解法思路与示例代码动态规划解法DP 表的构建与意义动

Go中sync.Once源码的深度讲解

《Go中sync.Once源码的深度讲解》sync.Once是Go语言标准库中的一个同步原语,用于确保某个操作只执行一次,本文将从源码出发为大家详细介绍一下sync.Once的具体使用,x希望对大家有... 目录概念简单示例源码解读总结概念sync.Once是Go语言标准库中的一个同步原语,用于确保某个操