深度学习中的Numpy知识

Derek Runfar

已于 2023-04-26 20:20:35 修改

阅读量188

点赞数 1

分类专栏：深度学习文章标签： numpy 深度学习 python

于 2023-03-27 19:15:11 首次发布

本文链接：https://blog.csdn.net/m0_73599738/article/details/129801683

版权

深度学习专栏收录该内容

12 篇文章 2 订阅

订阅专栏

本文列举了在深度学习中常用的Numpy函数，包括创建数组、零矩阵、单位矩阵、随机数生成、矩阵运算、转置、重塑、求和与平均值计算等，旨在提供一个实用的Numpy知识参考。

摘要由CSDN通过智能技术生成

整理了一些深度学习中可以用到的Numpy知识，可能不是很详尽，毕竟使用目的是片面的，而不是奔着全面学习Numpy而去，只是深度学习中可能用到的，在这里整理一下我所学的知识。代码+注释的形式，可能更加方便。

下面是知识点列表：

打印numpy库的版本
创建一维数组和二维数组
用zeros创建指定形状的零矩阵
用ones创建一个指定形状的值为1的矩阵
用full填充矩阵
arange创建等差数列
eye生成单位矩阵
rand生成0-1的随机浮点数
randint生成指定范围的随机整数
sum求矩阵所有值的和
设置sum的参数，求行和与列和
mean求矩阵所有值的平均数
设置mean的参数，求列平均与行平均
元素四则运算
矩阵乘法——点乘
矩阵转置
reshape方法，重塑数组或者矩阵形状

import numpy as np
print("numpy's version:",np.__version__)

a1 = np.array([1, 2, 3])
a2 = np.array([[1, 2, 3],
               [2, 4, 5],
               [3, 2, 1]])
print("创建一个1*3矩阵和一个3*3矩阵：")
print(a1, a2)
#!  array本质上生成的是一个数组，只不过矩阵和数组形式长得一样，我们默认其为矩阵
#!  但是当用array企图生成行向量或者是列向量的时候，生成出来的不是向量，而是数组
#!  这会导致后面的转置不能发挥作用，因为一维数组不能转置，
#!  如果想要生成一个1*n或者m*1的向量的话，建议使用mat方法
#!  后面的方法生成的都是数组而非矩阵，它们只是形式上与矩阵相同，如果要刻意生成一个矩阵
#!  考虑mat方法。

print("创建一个3*4零矩阵")
#!  zeros方法有一个参数，是一个元组，元组有三个元素，第一个元素是矩阵层数，
#!  第二个元素是行数，第三个元素是列数，这个参数被称为矩阵形状参数
A = np.zeros((3, 4))
print(A)

#*  ones方法也是只有一个参数，是矩阵形状参数
print("创建一个值都为1的矩阵，")
B = np.ones((2, 3, 4))  #*  确定一个2层，3*4的三维矩阵
print(B)

#!  注意full方法有两个参数，第一个是矩阵形状参数，第二个是指定数
print("生成一个指定数填满的矩阵")
C = np.full((3, 4), 2)
print(C)

print("生成一个等差数列")
#*  arange参数有两个，表示等差数列范围，为左闭右开
A = np.arange(1, 6)
print(A)

print("生成一个[0,5]范围的矩阵")
B = np.arange(6).reshape(2, 3)
#TODO   通过reshape方法，可以修改矩阵形状，上面把一个1*5的等差数列
#TODO   转化为一个2*3的等差数列矩阵
print(B)

print("生成一个3*3的单位矩阵")
#*  eye方法一般只允许有一个参数，就是行列数
#!  其实可以有两个参数，但是此时生成的是单位矩阵的一部分而已
C = np.eye(3)
print(C)

print("随机生成一个值为0-1的2*3矩阵")
#*  numpy内置了random模块，可以直接调用random里面的方法，通过点号.就能实现
#*  rand方法生成0-1的随机浮点数，参数是矩阵形状，或者是数组形状
D = np.random.rand(2, 3)
print(D)

print("随机生成值值小于5的2*3矩阵")
E = np.random.randint(5, size=(2, 3))
#*  randint方法生成指定范围的随机整数，第一个参数是最小值，第二个参数是最大值，第三个参数是矩阵的形状，或者说数组的形状
print(E)

a = np.array([[1, 2],
              [3, 4]])
print("这是一个2*2方阵:", a)
print("求矩阵所有值的和：")
b = np.sum(a)
print(b)
print("求矩阵每一列的和，并通过行向量形式返回:")
b = np.sum(a, axis= 0)
print(b)
print("求矩阵每一行的和，并以行向量的形式返回：")
b = np.sum(a, axis= 1)
print(b)

print("求出矩阵所有值的平均值:")
b = np.mean(a)
print(b)
print("求出矩阵行的平均值：")
b = np.mean(a, axis=1)
print(b)
print("求出矩阵行的平均值:")
b = np.mean(a, axis=0)
print(b)

a = np.array([[1, 2],
              [3, 4]])
b = np.array([[3, 4],
              [8, 9]])
print("ab进行元素加法：")
c = a + b
print(c)
c = a - b
print("ab进行元素减法：")
print(c)
print("ab进行元素乘法：")
c = a * b
print(c)
print("ab进行元素除法：")
c = a / b
print(c)
#!  注意到，这里的乘法和除法，必须保证维度相同
#!  每个相同位置元素进行乘除，并不是经典的矩阵乘法，
#!  更加准确来说，这是元素乘除法，但是，当a和b是由mat方法定义的，那么a和b就是矩阵，
#!  这时候的*就是真正的矩阵乘法

print("真正的矩阵乘法：")
c = np.dot(a, b)
print(c)

s = np.array([2, 3])
print("矩阵转置：")
c = a.T
d = s.T
print(c, d)
#!  注意，一维数组不能用T转置，必须用mat方法生成一个行向量，才能用T转置
#!  可以用reshape修改数组形状，这样就可以将一维数组修改为列向量形式或者行向量形式的数组，
#!  但是这时候还是一个数组，只不过形式长得和向量相似
d = s.reshape(2, 1)
print(d)
#*  所以，一般想要建立一个向量，考虑用mat方法更好点，尽量不用array建立一个向量。

#    这里细讲一下reshape，reshape的参数其实就是矩阵形状，或是数组形状，如果矩阵或者数组的维度是（a， b， c， d），如果设置为（-1，a），那么numpy会自动计算行数，于是行数row = （a*b*c*d） / a，列数就是固定自己设的a。当然对于列也是这样，如果设置成（b， -1），那么列数自动计算：rank =（a*b*c*d） / b。
print("求逆矩阵：")
c = np.linalg.inv(a)
print(c)

print("求矩阵的行列式：")
c = np.linalg.det(a)
print(c)

print("只计算矩阵的特征值：")
c = np.linalg.eigvals(a)
print(c)
print("矩阵特征值和它的特征向量：")
c = np.linalg.eig(a)
print(c)

print("可以解线性方程组:")
a = np.mat(a)
b = np.mat([1, 2]).T
x = np.linalg.solve(a, b)
print(x)

print("a的形状是：")
b = a.shape
print(b)

#    这里细讲一下shape[0]，shape[1]这类。shape[0]是第一维度的大小，shape[1]是第二维度的大小，以此类推，比如，如果数组为array[4][3]，那么shape[0]——二维，就是4，shape[1]——一维，就是3。
v = np.mat([1, 2, 3, 4, 5])
v.T
print("以每个元素为e的指数：")
print(np.exp(v))
print("求每个元素的log值")
print(np.log(v))
print("求每个元素的绝对值：")
print(np.abs(v))
print("把每个元素和0作比较，取出最大值，形成矩阵")
print(np.maximum(v, 0))
print("求矩阵，向量，数组每个元素的倒数")
print(1 / v)