东莞社保官方网站,云南网站推广,软件开发公司简介模板,上海网站建设哪个平台好目录 引言
1 pytorch中Tensor
1.1 什么是Tensor
1.2 为什么需要Tensor
1.3 如何创建Tensor
1.3.1 从已有其他数据结构转化创建为Tensor
1.3.2 随机初始化一个Tensor
1.3.3 从已保存文件加载一个Tensor
1.4 Tensor的特性
1.4.1 丰富的常用函数操作
1.4.2 灵活的dtype和…目录 引言
1 pytorch中Tensor
1.1 什么是Tensor
1.2 为什么需要Tensor
1.3 如何创建Tensor
1.3.1 从已有其他数据结构转化创建为Tensor
1.3.2 随机初始化一个Tensor
1.3.3 从已保存文件加载一个Tensor
1.4 Tensor的特性
1.4.1 丰富的常用函数操作
1.4.2 灵活的dtype和CPU/GPU自由切换
1.4.3 自动梯度求解
2 Numpy
2.1 什么是Numpy
2.2 NumPy有哪些优势
2.2.1 ndarray支持并行化运算向量化运算
2.2.2 效率远高于纯Python代码
2.2.3 存储数据地址连续
2.3 如何创建Numpy对象
2.3.1 使用Numpy创建ndarray数组
2.3.2 查看数组维数并改变维度
2.3.3 通过ndarray的属性也可以操作数组 2.3.4 创建元素均为 0 的数组
2.3.4 创建1填充的指定形状大小与数据类型的新数组
2.3.5 将一个 Python 序列转化为 ndarray 对象 2.3.6 使用指定的缓冲区创建数组 2.3.7 迭代对象转换为 ndarray 数组
2.3.8 创建给定数值范围的数组 2.3.9 创建指定的数值区间内的数组 2.3.10 创建等比数组
2.4 Numpy运算
2.4.1 平铺数组元素
2.4.2 以一维数组的形式返回一份数组副本
2.4.2 转化成连续的扁平数组
2.4.3 Numpy 的位运算
2.4.4 算术运算
2.4.5 Numpy矩阵操作
2.4.5 两个矩阵的逐元素乘法 2.4.6 两个数组的矩阵乘积
2.4.7 两个矩阵的点积
2.4.8 两个矩阵内积
2.4.9 解线性矩阵方程
2.4.10 计算矩阵的逆矩阵
3 Tensor和Numpy的相互转换
3.1 Tensor转Numpy
3.2 Numpy转Tensor
3.2.1 使用torch.tensor
3.2.2 使用torch.from_numpy
4 Tensor转其他
4.1 Tensor转数值
4.2 Tensor转List
4.3 Tensor转List Tensor 引言
在我们构建深度学习模型的过程中Tensor和Numpy必不可少而且经常会面临两种数据结构的相互转换。
这两个数据结构到底有什么区别什么时候选择哪种数据结构使用两种数据结构之间如何转换
本文通过定义、应用场景、转换方式等多个维度给出问题的答案。
1 pytorch中Tensor
1.1 什么是Tensor
Tensor是深度学习中最为基础也最为关键的数据结构
Tensor之于PyTorch就好比是array之于Numpy或者DataFrame之于Pandas都是构建了整个框架中最为底层的数据结构Tensor与普通的数据结构不同具有一个极为关键的特性——自动求导。 定义Tensor英文原义是张量在Pytorch官网中对其有如下介绍 一个Tensor是一个包含单一数据类型的高维矩阵一般而言描述Tensor的高维特性通常用三维及以上的矩阵来描述例如下图所示单个元素叫标量scalar一个序列叫向量vector多个序列组成的平面叫矩阵matrix多个平面组成的立方体叫张量tensor。当然就像矩阵有一维矩阵和二维矩阵乃至多维矩阵一样张量也无需严格限制在三维以上才叫张量在深度学习的范畴内标量、向量和矩阵都统称为张量。 Tensor也不是PyTorch特有的定义而是众多深度学习框架广泛使用的数据结构如TensorFlow。
1.2 为什么需要Tensor
PyTorch中的Tensor是深度学习中广泛使用的数据结构本质上就是一个高维的矩阵甚至将其理解为NumPy中array的推广和升级也不为过。但由于其支持的一些特殊特性Tensor在用于支撑深度学习模型和训练时更为便利。
1.3 如何创建Tensor
一般而言创建一个Tensor大体有三种方式
从已有其他数据结构转化创建为Tensor随机初始化一个Tensor从已保存文件加载一个Tensor
1.3.1 从已有其他数据结构转化创建为Tensor
这可能是实际应用中最常用的一种形式常用于数据集的加载比如从一个列表、从一个NumPy的array中读取数据而后生成一个新的Tensor。为了实现这一目的常用的有两种方式 torch.tensor torch.Tensor
二者的区别就是前者用的是tensor函数t是小写后者用的是Tensor类T是大写。二者在创建Tensor的默认数据类型、支持传参以及个别细节的处理方面。
首先是创建的Tensor默认数据类型不同
import torcht1 torch.tensor([1,2,3])
t2 torch.Tensor([1,2,3])
print(t1, t2)
print(t1.dtype, t2.dtype)
运行显示如下
tensor([1, 2, 3]) tensor([1., 2., 3.])
torch.int64 torch.float32
其次应用Tensor类初始化输入一个整数将返回一个以此为长度的全零一维张量而tensor函数则返回一个只有该元素的零维张量
import torcht1 torch.tensor(3)
t2 torch.Tensor(3)
print(t1, t2)
运行结果显示
tensor(3) tensor([0., 0., 0.])
有一个细节需要优先提及应用Tensor类接收一个序列创建Tensor时返回的数据类型为float型这是因为Tensor是FloatTensor的等价形式即除此之外还有ByteTensorIntTensorLongTensor以及DoubleTensor等不同的默认数据类型。
基于已有数据创建Tensor另外两个常用函数 from_numpy as_tensor
二者与上述方法最大的不同在于它们返回的Tensor与原有数据是共享内存的而前述的tensor函数和Tensor类则是copy后创建一个新的对象。
import torch
import numpy as npn1 np.array([1,2,3])
n2 np.array([1,2,3])
n3 np.array([1,2,3])
t1 torch.tensor(n1)
t2 torch.from_numpy(n2)
t3 torch.as_tensor(n3)
print(t1:, t1)
print(t2:, t2)
print(t3:, t3)n1[0] 100
n2[0] 100
n3[0] 100print(t1:, t1)
print(t2:, t2)
print(t2:, t3)
运行结果显示
t1: tensor([1, 2, 3])
t2: tensor([1, 2, 3])
t3: tensor([1, 2, 3])
t1: tensor([1, 2, 3])
t2: tensor([100, 2, 3])
t2: tensor([100, 2, 3])
1.3.2 随机初始化一个Tensor
随机初始化是一种常用的形式在搭建一个神经网络模型中在添加了一个模块的背后也自动随机初始化了该模块的权重。这类方法分为两种形式 创建一个特定类型的tensor例如torch.onestorch.randn等等 根据一个已有Tensor创建一个与其形状一致的特定类型tensor例如torch.ones_liketorch.randn_like等等
import torchfunc_name [x for x in dir(torch) if x.endswith(like)]
print(func_name)
运行结果显示
[empty_like, full_like, ones_like, rand_like, randint_like, randn_like, zeros_like]随机构建一个PyTorch中的全连接单元Linear其会默认创建相应的权重系数和偏置由于网络参数一般是需要参与待后续的模型训练所以默认requires_gradTrue
import torchlinear torch.nn.Linear(2,3)
print(weight:, linear.weight)
print(bias:, linear.bias)
运行结果显示
weight: Parameter containing:
tensor([[-0.5380, -0.6481],[ 0.0144, 0.0627],[-0.6560, 0.0382]], requires_gradTrue)
bias: Parameter containing:
tensor([-0.2800, 0.0235, -0.6940], requires_gradTrue)
1.3.3 从已保存文件加载一个Tensor
PyTorch不会刻意区分要保存和加载的对象是何种形式可以是训练好的网络也可以是数据这在Python中就是pickle通过torch.save和torch.load两个函数实现。保存后的文件没有后缀格式要求常用的后缀格式有 .pkl、.pth、.pt三种此方法常用于模型以及大规模数据集的保存。
import torcht1 torch.tensor([1,2,3,4,5])
torch.save(t1, tensor.pkl)ret_t torch.load(tensor.pkl)
print(ret_t, ret_t) 运行结果如下
ret_t tensor([1, 2, 3, 4, 5])
1.4 Tensor的特性
PyTorch之所以定义了Tensor来支持深度学习而没有直接使用Python中的一个list或者NumPy中的array是因为Tensor被赋予了一些独有的特性。Tensor的主要特性为以下三个方面 丰富的常用操作函数 灵活的dtype和CPU/GPU自由切换存储 自动梯度求解
1.4.1 丰富的常用函数操作
Tensor本质上是一个由数值型元素组成的高维矩阵深度学习的过程就是各种矩阵运算的过程Tensor作为其基础数据结构支持丰富的函数操作。
Tensor自身进行操作函数例如tensor.max(), tensor.abs()等等Tensor其他tensor进行相关操作例如tensor.add()用于与另一个tensor相加tensor.mm()用于与另一个tensor进行矩阵乘法等等。这里的相加和相乘对操作的两个tensor尺寸有所要求。
除了支持的函数操作足够丰富外tensor的API函数还有另一个重要的便利特性绝大多数函数都支持两个版本带下划线版和不带下划线版例如tensor.abs()和tensor.abs_()二者均返回操作后的Tensor但同时带下划线版本属于inplace操作即调用后自身数据也随之改变。
1.4.2 灵活的dtype和CPU/GPU自由切换
Tensor中dtype的概念类似于NumPy和Pandas中的用法用于指定待创建Tensor的数据结构。PyTorch中定义了10种不同的数据结构包括不同长度的整型、不同长度的浮点型整个Tesor的所有元素必须数据类型相同且必须是数值类型NumPy中的array也要求数组中的元素是同质的但支持字符串类型的 除了支持不同的数值数据类型外Tensor的另一大特色是其支持不同的计算单元CPU或GPU支持GPU加速也是深度学习得以大规模应用的一大关键。为了切换CPU计算数据存储于内存或GPU计算数据存储于显存Tensor支持灵活的设置存储设备包括如下两种方式 创建tensor时通过device参数直接指定 通过tensor.to()函数切换to()既可用于切换存储设备也可切换数据类型
此外除了dtype和device这两大特性之外其实Tensor还有第三个特性即layout布局。主要包括strided和sparse_coo两种该特性一般不需要额外考虑。
1.4.3 自动梯度求解
Tensor自动梯度求解是支撑深度学习的基石深度学习模型的核心是在于神经元的连接而神经元之间连接的关键在于网络权重也就是各个模块的参数。正因为网络参数的不同所以才使得相同的网络结构能实现不同的模型应用价值。那么如何学习最优网络参数呢这就是深度学习中的的优化利器梯度下降法而梯度下降法的一大前提就是支持自动梯度求解。
Tensor为了支持自动梯度求解大体流程如下
Tensor支持grad求解即requires_gradTrue根据Tensor参与计算的流程将Tensor及相应的操作函数记录为一个树结构或称之为有向无环图DAG计算的方向为从叶节点流向根节点根据根节点Tensor与目标值计算相应的差值loss然后利用链式求导法则反向逐步计算梯度也即梯度的反向传播
2 Numpy
2.1 什么是Numpy
Numpy 是 Numerical Python 的缩写它是一个由多维数组对象ndarray和处理这些数组的函数function集合组成的库。使用 Numpy 库可以对数组执行数学运算和相关逻辑运算。Numpy 不仅作为 Python 的扩展包它同样也是 Python 科学计算的基础包。Numpy 提供了大量的数学函数主要用来计算、处理一维或多维数组支持常见的数组和矩阵操作。NumPy 的底层主要用 C语言编写因此它能够高速地执行数值计算。Numpy 还提供了多种数据结构这些数据结构能够非常契合的应用在数组和矩阵的运算上。 Numpy 作为一个开源项目它由许多协作者共同开发维护随着数据科学Data Science简称 DS包括大数据分析与处理、大数据存储、数据抓取等分支的蓬勃发展像 Numpy、SciPyPython科学计算库、Pandas基于NumPy的数据处理库 等数据分析库都有了大量的增长它们都具有较简单的语法格式。Numpy 通常会和Matplotlib等搭配一块使用。
2.2 NumPy有哪些优势
2.2.1 ndarray支持并行化运算向量化运算
numpy内置了并行运算功能当系统有多个核心时做某种计算时numpy会自动做并行计算。
2.2.2 效率远高于纯Python代码
Numpy底层使用C语言编写内部解除了GIL全局解释器锁其对数组的操作速度不受Python解释器的限制所以其效率远高于纯Python代码。
2.2.3 存储数据地址连续
ndarray在存储数据的时候数据与数据的地址都是连续的这样就使得批量操作数组元素时速度更快。 ndarray中的所有元素的类型都是相同的而Python列表中的元素类型是任意的所以ndarray在存储元素时内存可以连续而python原生list就只能通过寻址方式找到下一个元素这虽然也导致了在通用性能方面Numpy的ndarray不及Python原生list但在科学计算中Numpy的ndarray就可以省掉很多循环语句代码使用方面比Python原生list简单的多。
2.3 如何创建Numpy对象
Numpy 定义了一个 n 维数组对象简称 ndarray 对象它是一个一系列相同类型元素组成的数组集合。数组中的每个元素都占有大小相同的内存块使用索引或切片的方式可以获取数组中的每个元素。ndarray 对象有一个 dtype 属性该属性用来描述元素的数据类型。ndarray 对象采用了数组的索引机制将数组中的每个元素映射到内存块上并且按照一定的布局对内存块进行排列常用的布局方式有两种即按行或者按列。
通过 Numpy 的内置函数 array() 可以创建 ndarray 对象其语法格式如下
numpy.array(object, dtype None, copy True, order None,ndmin 0)2.3.1 使用Numpy创建ndarray数组
import numpy as npa np.array([1,2,3])
b np.array([[1,2,3], [4,5,6]])print(fa:{a})
print(ftype(a):{type(a)})print(b:{b})
运行结果显示
a:[1 2 3]
type(a):class numpy.ndarray
b:{b}
2.3.2 查看数组维数并改变维度
import numpy as npa np.array([[1,2], [3,4], [5,6]])print(a.ndim)
print(old array:, a)a a.reshape(2,3)
print(new array:, a.ndim, a)
运行结果显示
old array: [[1 2][3 4][5 6]]
new array: 2 [[1 2 3][4 5 6]]
2.3.3 通过ndarray的属性也可以操作数组
ndarray的属性 import numpy as npa np.array([[1,2], [3,4], [5,6]])
print(a.shape:, a.shape)
print(a:, a)
a.shape (2, 3)
print(a[2,3]:, a)
print(a[3,2]:, a.reshape(3, 2))print(a.ndim:, a.ndim)
print(a.itemsize:, a.itemsize)
print(a.flags:, a.flags) dd
a.shape: (3, 2)
a: [[1 2][3 4][5 6]]
a[2,3]: [[1 2 3][4 5 6]]
a[3,2]: [[1 2][3 4][5 6]]
a.ndim: 2
a.itemsize: 4
a.flags: C_CONTIGUOUS : TrueF_CONTIGUOUS : FalseOWNDATA : TrueWRITEABLE : TrueALIGNED : TrueWRITEBACKIFCOPY : False
ndarray的类型 Numpy中的数据类型标识码Numpy 中每种数据类型都有一个唯一标识的字符码如下所示
i - 整数b - 布尔u - 无符号整数f - 浮点c - 复合浮点数m - timedeltaM - datetimeO - 对象S - 字符串U - unicode 字符串V - 固定的其他类型的内存块 ( void )
通常Numpy 与 SciPy 程序包一起使用SciPy 可以看做对 Numpy 库的扩展它在 Numpy 的基础上又增加了许多工程计算函数。
2.3.4 创建未初始化的数组
numpy.empty(shape, dtype float, order C)
numpy.empty() 创建未初始化的数组可以指定创建数组的形状shape和数据类型dtype。
参数shape指定数组的形状dtype数组元素的数据类型默认值是值 floatorder指数组元素在计算机内存中的储存顺序默认顺序是“C”“C”代表以行顺序存储“F”则表示以列顺序存储。
import numpy as np
n1 np.empty([2, 2])
print(n1)
运行结果显示
[[0.0e000 5.4e-323][9.9e-324 9.9e-324]] 2.3.4 创建元素均为 0 的数组
numpy.zeros(shape,dtypefloat,orderC)
该函数用来创建元素均为 0 的数组同时还可以指定被数组的形状。
参数shape指定数组的形状dtype数组元素的数据类型默认值是值 floatorder指数组元素在计算机内存中的储存顺序默认顺序是“C”“C”代表以行顺序存储“F”则表示以列顺序存储。
import numpy as np
n1 np.zeros([2, 2])
print(n1)
运行结果显示
[[0. 0.][0. 0.]]
2.3.4 创建1填充的指定形状大小与数据类型的新数组
numpy.ones(shape, dtype None, order C)
返回指定形状大小与数据类型的新数组并且新数组中每项元素均用 1 填充。
import numpy as np
n1 np.ones([2, 2])
print(n1)
运行结果显示
[[1. 1.][1. 1.]]
2.3.5 将一个 Python 序列转化为 ndarray 对象
numpy.asarraysequencedtype None order None
asarray() 能够将一个 Python 序列转化为 ndarray 对象。
参数sequence接受一个 Python 序列可以是列表或者元组dtype可选参数数组的数据类型默认值是值 floatorder指数组元素在计算机内存中的储存顺序默认顺序是“C”“C”代表以行顺序存储“F”则表示以列顺序存储。
import numpy as nparray [1, 2, 3, 4, 5]
n1 np.asarray(array)
print(n1)
print(type(n1))
运行结果显示
[1 2 3 4 5]
class numpy.ndarray 2.3.6 使用指定的缓冲区创建数组
numpy.frombuffer(buffer, dtype float, count -1, offset 0)
表示使用指定的缓冲区创建数组。
参数buffer将任意对象转换为流的形式读入缓冲区dtype返回数组的数据类型默认是 float32count要读取的数据数量默认为 -1 表示读取所有数据offset读取数据的起始位置默认为 0。
import numpy as npdata bhello world!
res np.frombuffer(data,dtypeS3,offset0)
print(res) 运行结果显示
[bhel blo bwor bld!] 2.3.7 迭代对象转换为 ndarray 数组
numpy.fromiter(iterable, dtype, count -1)
把迭代对象转换为 ndarray 数组其返回值是一个一维数组。
参数iterable可迭代对象dtype数组元素的数据类型默认值是值 floatcount读取的数据数量默认为 -1读取所有数据。
import numpy as npiterable (x * x*x for x in range(4))
n1 np.fromiter(iterable, int)print (n1) 运行结果显示
[ 0 1 8 27]
2.3.8 创建给定数值范围的数组
numpy.arange(start, stop, step, dtype)
参数start 起始值默认是 0。stop 终止值注意生成的数组元素值不包含终止值。step 步长默认为 1。dtype 可选参数指定 ndarray 数组的数据类型。
import numpy as npA np.arange(5)
print(A)
print(type(A))A np.arange(1, 5)
print(A)A np.arange(1, 5, 2)
print(A)A np.arange(1, 5.2, 0.6)
print(A)
运行结果显示
[0 1 2 3 4]
class numpy.ndarray
[1 2 3 4]
[1 3]
[1. 1.6 2.2 2.8 3.4 4. 4.6 5.2] 2.3.9 创建指定的数值区间内的数组
numpy.linspace(start, stop, num50, endpointTrue, retstepFalse, dtypeNone)
参数start代表数值区间的起始值stop代表数值区间的终止值num表示数值区间内要生成多少个均匀的样本。默认值为 50endpoint默认为 True表示数列包含 stop 终止值反之不包含retstep默认为 True表示生成的数组中会显示公差项反之不显示dtype代表数组元素值的数据类型。import numpy as npn1 np.linspace(start 0, stop 1, num 11)
n2 np.linspace(start 0, stop 100, num 11)
n3 np.linspace(start 1, stop 5, num 4, endpoint False)
n4 np.linspace(start 0, stop 100, num 5, dtype int)
print(n1)
print(n2)
print(n3)
print(n4) 运行结果显示
[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]
[ 0. 10. 20. 30. 40. 50. 60. 70. 80. 90. 100.]
[1. 2. 3. 4.]
[ 0 25 50 75 100] 2.3.10 创建等比数组
numpy.logspace(start, stop, num50, endpointTrue, base10.0, dtypeNone)
参数start 序列的起始值base**start。stop 序列的终止值base**stop。num 数值范围区间内样本数量默认为 50。endpoint 默认为 True 包含终止值反之不包含。base 对数函数的 log 底数默认为10。dtype 可选参数指定 ndarray 数组的数据类型。logspace中开始点和结束点是10的幂
import numpy as npn1 np.logspace(0,0,10)
n2 np.logspace(0,9,10)
n3 np.logspace(0,9,10,base2)print(n1)
print(n2)
print(n3) 运行结果显示
[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
[1.e00 1.e01 1.e02 1.e03 1.e04 1.e05 1.e06 1.e07 1.e08 1.e09]
[ 1. 2. 4. 8. 16. 32. 64. 128. 256. 512.]
2.4 Numpy运算
2.4.1 平铺数组元素
numpy.ndarray.flat()
返回一个数组迭代器可以用 for 循环遍历其中的每一个元素。
import numpy as npa np.arange(8).reshape(2, 4)
print (a:, a)for e in a.flat:print (e, end )
运行结果显示
a: [[0 1 2 3][4 5 6 7]]
0 1 2 3 4 5 6 7
2.4.2 以一维数组的形式返回一份数组副本
numpy.ndarray.flatten()
以一维数组的形式返回一份数组副本对副本修改不会影响原始数组。
import numpy as npa np.arange(8).reshape(2, 4)
print(a)
print(a.flatten())
运行结果显示
[[0 1 2 3][4 5 6 7]]
[0 1 2 3 4 5 6 7]
2.4.2 转化成连续的扁平数组
numpy.ravel()
返回一个连续的扁平数组即展开的一维数组与 flatten不同它返回的是数组视图修改视图会影响原数组。
import numpy as npa1, a2 np.mgrid[1:4:1, 2:3:1]
print(a1:\n, a1, \n, a2:\n, a2)n1 a1.ravel()
n2 a2.ravel()print(n1:, n1)
print(n2:, n2)
sum n1 n2
print(sum)运行结果显示
a1:[[1][2][3]] a2:[[2][2][2]]
n1: [1 2 3]
n2: [2 2 2]
[3 4 5]
2.4.3 Numpy 的位运算 import numpy as npn1 np.bitwise_and([11,7], [4,25])
n2 np.bitwise_and(np.array([2,5,255]), np.array([3,14,16]))
n3 np.bitwise_and([True, True], [False, True])n4 np.bitwise_or([11,7], [4,25])
n5 np.bitwise_or(np.array([2,5,255]), np.array([3,14,16]))
n6 np.bitwise_or([True, True], [False, True])print(n1)
print(n2)
print(n3)
print(n4)
print(n5)
print(n6)
运行结果显示
[0 1]
[ 2 4 16]
[False True]
[15 31]
[ 3 15 255]
[ True True]
2.4.4 算术运算
NumPy 数组的“加减乘除”算术运算分别对应 add()、subtract()、multiple() 以及 divide() 函数。
numpy.reciprocal()函数对数组中的每个元素取倒数并以数组的形式将它们返回。numpy.power()将 a 数组中的元素作为底数把 b 数组中与 a 相对应的元素作幂 最后以数组形式返回两者的计算结果。numpy.mod()返回两个数组相对应位置上元素相除后的余数
import numpy as npa np.random.randint(9, size(3, 3))
print(a , a)
b np.random.randint(9, size(3, 3))
print(b , b)
print(a b , np.add(a, b))
print(a - b , np.subtract(a, b))
print(a x b , np.multiply(a, b))
print(a / b , np.divide(a, b))
运行结果显示
a [[8 0 2][7 8 4][3 5 1]]
b [[2 3 5][1 8 3][4 1 2]]
a b [[10 3 7][ 8 16 7][ 7 6 3]]
a - b [[ 6 -3 -3][ 6 0 1][-1 4 -1]]
a x b [[16 0 10][ 7 64 12][12 5 2]]
a / b [[4. 0. 0.4 ][7. 1. 1.33333333][0.75 5. 0.5 ]]
2.4.5 Numpy矩阵操作
NumPy 提供了一个 矩阵库模块numpy.matlib该模块中的函数返回的是一个 matrix 对象而非 ndarray 对象。矩阵由 m 行 n 列m*n元素排列而成矩阵中的元素可以是数字、符号或数学公式等。
numpy.matlib.empty() 返回一个空矩阵它的创建速度非常快。numpy.matlib.zeros() 创建一个以 0 填充的矩阵。numpy.matlib.ones() 创建一个以 1 填充的矩阵。numpy.matlib.eye() 返回一个对角线元素为 1而其他元素为 0 的矩阵 。numpy.matlib.identity()该函数返回一个给定大小的单位矩阵矩阵的对角线元素为 1而其他元素均为 0。numpy.matlib.rand() 创建一个以随机数填充并给定维度的矩阵。
import numpy as np
import numpy.matlibprint(np.matlib.empty((3, 4)))
print(np.matlib.zeros((3, 4)))
print(np.matlib.ones((3, 4)))运行结果显示
[[0.00000000e000 nan 1.69759663e-313 0.00000000e000][0.00000000e000 0.00000000e000 0.00000000e000 0.00000000e000][0.00000000e000 0.00000000e000 0.00000000e000 0.00000000e000]]
[[0. 0. 0. 0.][0. 0. 0. 0.][0. 0. 0. 0.]]
[[1. 1. 1. 1.][1. 1. 1. 1.][1. 1. 1. 1.]]
2.4.5 两个矩阵的逐元素乘法
multiple()
函数用于两个矩阵的逐元素乘法。
import numpy as npa1np.array([[1,2], [3,4]], ndmin2)
a2np.array([[1,2], [3,4]], ndmin2)print(np.multiply(a1, a2))
[[ 1 4][ 9 16]] 2.4.6 两个数组的矩阵乘积
matmul() 用于计算两个数组的矩阵乘积。
import numpy as npa1np.array([[1,2], [3,4]], ndmin2)
a2np.array([[1,2], [3,4]], ndmin2)print(np.matmul(a1, a2)) 运行结果显示
[[ 7 10][15 22]]
2.4.7 两个矩阵的点积
dot() 函数用于计算两个矩阵的点积。
import numpy as npa1np.array([[1,2], [3,4]], ndmin2)
a2np.array([[1,2], [3,4]], ndmin2)print(np.dot(a1, a2))
[[ 7 10][15 22]]
2.4.8 两个矩阵内积
numpy.inner() 用于计算数组之间的内积。
import numpy as np
n1np.inner(np.array([1,2,3,4]),np.array([1,2,3,4]))
a1np.array(([[1,2],[3,4]]))
a2np.array(([[11,12],[13,14]]))
n2np.inner(a1,a2)print(n1)
print(n2)
运行结果显示
30
[[35 41][81 95]]2.4.9 解线性矩阵方程
numpy.linalg.solve() 该函数用于求解线性矩阵方程组并以矩阵的形式表示线性方程的解。
解方程组x0 2 * x1 1和3 * x0 5 * x1 2:
import numpy as npa np.array([[1, 2], [3, 5]])
b np.array([1, 2])
x np.linalg.solve(a, b)
print(x)
运行结果显示
[-1. 1.]
2.4.10 计算矩阵的逆矩阵
numpy.linalg.inv() 该函数用于计算矩阵的逆矩阵逆矩阵与原矩阵相乘得到单位矩阵。
import numpy as npa np.array([[[1., 2.], [3., 4.]], [[1, 3], [3, 5]]])
n np.linalg.inv(a)
print(a)
print(n)
运行结果显示
[[[1. 2.][3. 4.]][[1. 3.][3. 5.]]]
[[[-2. 1. ][ 1.5 -0.5 ]][[-1.25 0.75][ 0.75 -0.25]]]
[[[-2. 2. ][ 4.5 -2. ]][[-1.25 2.25][ 2.25 -1.25]]]
3 Tensor和Numpy的相互转换
3.1 Tensor转Numpy
import numpy as np
import torcht torch.arange(1, 10).reshape(3, 3)
x t.numpy()
print(fa{t})
print(fb{x})
运行结果显示
atensor([[1, 2, 3],[4, 5, 6],[7, 8, 9]])
b[[1 2 3][4 5 6][7 8 9]]3.2 Numpy转Tensor
3.2.1 使用torch.tensor
import numpy as np
import torch
a np.random.normal(0, 1, (2, 3))
b torch.tensor(a)
print(fa{a}, b{b}) 运行结果显示
a[[ 1.77128009 2.02509013 0.38144148][ 1.14920329 -0.30733646 -1.20198951]]
btensor([[ 1.7713, 2.0251, 0.3814],[ 1.1492, -0.3073, -1.2020]], dtypetorch.float64)
3.2.2 使用torch.from_numpy
import numpy as np
import torcha np.random.normal(0, 1, (4, 5))
b torch.from_numpy(a)
print(fa{a})
print(fb{b}) 运行结果显示
a[[ 1.27357033 0.43722359 -0.74243293 -0.19531152 0.95053336][-0.52235811 0.95262418 -0.11157708 0.65592213 0.04188334][ 0.14932165 -0.40966126 0.09067062 0.3212764 -2.41411188][ 0.63391603 0.29742247 -0.43064322 1.08767221 -0.95699876]]
btensor([[ 1.2736, 0.4372, -0.7424, -0.1953, 0.9505],[-0.5224, 0.9526, -0.1116, 0.6559, 0.0419],[ 0.1493, -0.4097, 0.0907, 0.3213, -2.4141],[ 0.6339, 0.2974, -0.4306, 1.0877, -0.9570]], dtypetorch.float64)
4 Tensor转其他
4.1 Tensor转数值
import torcha torch.tensor([1])
b a.item()print(fa{a})
print(fb{b})
运行结果显示
atensor([1])
b1
4.2 Tensor转List
import torcht1 torch.arange(10)
t2 t1.tolist() print(ft1{t1})
print(ft2{t2})
运行结果显示
t1tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
t2[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
4.3 Tensor转List Tensor
import torcht1 torch.arange(10)
t3 list(t1)print(ft1{t1})
print(ft3{t3})
运行结果显示
t1tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
t3[tensor(0), tensor(1), tensor(2), tensor(3), tensor(4), tensor(5), tensor(6), tensor(7), tensor(8), tensor(9)]
