PyTorch 基础--NumPy基础知识（1）

1.1生成Numpy数组

NumPy是Python的第三方库 要先导入NumPy

import numpy as np

在terminal中输入

pip install numpy

在机器学习中，把图像、自然语言、语音等内容在上输入模型前，都需要数字化。这里我们用cv2

(OpenCV 2) 把一个图像转换为NumPy多维数组，然后查看该多维数组的基本属性。

# 使用OpenCV 开源库读取图像数据
import matplotlib.pyplot as plt
import numpy as np
import cv2

#读取一张照片，把图像转换为2维的NumPy数组
img = cv2.imread('C:/Users/yoop5/Desktop/OIP-C.jpg')
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)  # 转换颜色通道顺序

#使用plt显示图像
plt.imshow(img_rgb)
plt.show()

print("数据类型：{}，形状：{}".format(type(img), img.shape))

1.1.1 数组属性

在NumPy中，维度被称为轴，上述图片转换为一个3维NumPy数组，这个数组有3个轴，长度分别为270、240、3

NumPy的ndarray对象有3个重要的属性

1.ndarray.ndim:数组的维度（轴）的个数

2.ndarray.shap:数组的维度，值是一个整数元组，元组的值代表其所对应的轴的长度 eg:二维数组用于表示这是一个几行几列的矩阵，值为（x,y) 则表示这个数组中有x行，y列

3.ndarray.dtype:数据类型，描述数组中元素的类型

1.1.2 利用已有的数据生成数组

1）将列表转换成ndarray

import numpy as np

lst1 = [3.14,2.17,0,1,2]
nd1 = np.array(lst1)
print(nd1)
print(type(nd1))

2)将嵌套列表转换为多维数组

import numpy as np

lst2 = [[3.14,2.17,0,1,2]
        ,[1,2,3,4,5]]
nd2 = np.array(lst2)
print(nd2)
print(type(nd2))

1.1.3利用random模块生成数组

在深度学习中，我们常对参数进行初始化，来更好的训练模型，提高模型的性能，有的初始化还要满足某些条件，比如正态分布或均匀分布

import numpy as np
print('生成形状（4，4），值在0-1之间的随机数：')
print(np.random.random((4,4)),end='\n\n')
#生成形状（4，4），值在0-1之间的随机数：
 #[[0.76363107 0.62717214 0.54675401 0.19322813]
 #[0.94485713 0.14473766 0.50228588 0.94105746]
 #[0.55322036 0.05071659 0.99197735 0.91542198]
 #[0.84876956 0.75260229 0.00920488 0.00333783]]

#产生一个取值范围在[1,50)之间的数组，数组的形状是（3，3）
#参数的起始值（low)默认值为0 终止值（high）默认为1
print('生成形状为（3，3），值在low到high之间的随机整数：')
print(np.random.randint(low=1,high=3,size=(3,3)),end='\n\n')
#生成形状为（3，3），值在low到high之间的随机整数：
#[[2 2 1]
 #[2 1 2]
 #[2 1 1]]

print('产生的数组元素是均匀分布的随机数：')
print(np.random.uniform(low=1,high=3,size=(3,3)),end='\n\n')
#产生的数组元素是均匀分布的随机数：
#[[2.14834394 2.33586897 1.26789435]
 #[1.25359727 1.09119575 1.90612673]
 #[1.68569386 1.09481009 2.50043458]]
print('生成满足正态分布的形状为(3,3)的矩阵：')
print(np.random.randn(3,3))
#生成满足正态分布的形状为(3,3)的矩阵：
#[[-0.65401079 -0.74337458 -0.84035649]
 #[-1.71273116  0.30534686 -0.67414231]
 #[-0.85083875  0.76047707 -2.31373982]]

以上的方法生成的随机数是没有办法重现的。但是我们可以使用np.random.seed函数设置种子。先设置一个种子，然后调用随机函数产生一个数组，如果想要再次得到一个一摸一样的数组，只要再次设置相同的种子即可。

import numpy as np
np.random.seed(10)

print("按指定随机种子，第1次生成随机数：")
print(np.random.randint(1,2,(2,2)))

#想要生成同样的数据，必须再次设置相同的种子
np.random.seed(10)

print("按指定随机种子，第2次生成随机数：")
print(np.random.randint(1,2,(2,2)))

1.1.4生成特定形状的多维数组

import numpy as np
#生成全0的3*3矩阵
nd5 = np.zeros([3,3])
np.zeros_like(nd5)

#生成全1的3*3矩阵
nd6 = np.ones([3,3])
np.ones_like(nd6)

#生成3阶的单位矩阵
nd7 = np.eye(3)
#生成3阶对角矩阵
nd8 = np.diag([1,2,3])
print("*"*6+"nd5"+"*"*6)
print(nd5)
print("*"*6+"nd6"+"*"*6)
print(nd6)
print("*"*6+"nd7"+"*"*6)
print(nd7)
print("*"*6+"nd8"+"*"*6)
print(nd8)

有时我们可能需要把生成的数据暂时保存起来，以备后续使用

import numpy as np
nd9 = np.random.random([5,5])
np.savetxt(X=nd9,fname= './test1.txt')
nd10 = np.loadtxt('./test1.txt')
print(nd10)

1.1.5 利用arange、linspace函数生成数组

arange([start,]stop[,step,],dtype=None)

其中start与stop用于指定范围，step用于设定步长，生成一个数组，start的默认值为0，步长step可为小数，与python中的range的功能相似

np.linspace（start,stop,num=50,endpoint=True,retstep=Flase,dtype=None)

linspace可以根据输入的指定数据范围以及数量自动生成一个线性等分向量，会包含起点和终点。

print(np.arange(10))
#[0 1 2 3 4 5 6 7 8 9]
print(np.arange(0,10))
#[0 1 2 3 4 5 6 7 8 9]
print(np.arange(1,4,0.5))
#[1.  1.5 2.  2.5 3.  3.5]
print(np.arange(9,-1,-1))
#[9 8 7 6 5 4 3 2 1 0]
print(np.linspace(0,1,10))
#[0.         0.11111111 0.22222222 0.33333333 0.44444444 0.55555556
 #0.66666667 0.77777778 0.88888889 1.        ]
print(np.linspace(0.1,1,10))
#[0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]

1.2读取数据

通过索引标签获取数组中的部分数据

import numpy as np
np.random.seed(2024)
nd11 = np.random.random(10)
#获取指定位置的数据，获取第4个数据
nd11[3]
#截取一段数据
nd11[3:6]
#截取固定间隔数据
nd11[1:6:2]
#倒序取数
nd11[::2]
#截取一个多维数组的某个区域内的数据
nd12 = np.arange(25).reshape([5,5])
nd12[1:3,1:3]
#截取一个多维数组中数值在某个值域之内的数据
nd12[(nd12>3)&(nd12<10)]
#截取多维数组中指定的行,第2、3行
nd12[1:3:]
#截取多维数组中指定的列，第2、3列
nd12[:1:3]

通过random.choice函数从指定的样本中随机抽取数据

import numpy as np
from numpy import random as nr
a = np.arange(1,25,dtype=float)
c1 = nr.choice(a,size=(3,4))
c2 = nr.choice(a,size=(3,4),replace=False,)#replace默认为True,即可重复抽取
#p 表示每个元素对应的抽取概率，默认为每个元素被抽取的概率相同
c3 = nr.choice(a,size=(3,4),p=a / np.sum(a))
print("随机可重复抽取")
print(c1)
print("随机但不重复抽取")
print(c2)
print("随机但按制度概率抽取")
print(c3)

1.3NumPy的算术运算

1.1.3逐元素操作

逐元素操作就是两个矩阵中对应元素相乘，即通过np.multiply函数计算数组或矩阵对应的元素乘积，输出的大小与相乘数组或矩阵的大小一致。注意对应元素相乘遵守广播机制的相关规定

A = np.array([[1,2],[-1,4]])
B = np.array([[2,0],[3,4]])
A*B
#[[ 2  0]
 #[-3 16]]
np.multiply(A,B)
#[[ 2  0]
 #[-3 16]]

NumPy数组的每一个元素与标量进行运算，其间会用到广播机制

print(A*2.0)
#[[ 2.  4.]
# [-2.  8.]]
print(A/2.0)
#[[ 0.5  1. ]
# [-0.5  2. ]]

 由此，数组通过一些激活函数处理后，输出与输入形状一致。

1.3.2 点积运算

点积运算又称为内积运算

numpy.dot(a,b,out=None)

X1 = np.array([[1,2],[3,4]])
X2 = np.array([[5,6,7],[8,9,10]])
X3 = np.dot(X1,X2)
print(X3)
#[[21 24 27]
# [47 54 61]]

点积运算在神经网络中使用非常频繁，如下图，输入与权重矩阵之间的运算就是点积运算