Continuado del artículo anterior, continúe actualizando el uso de algunas funciones comunes bajo numpy, aquí se encuentran principalmente operaciones matriciales, creando matrices, matrices de identidad, resolviendo matrices inversas, etc. y realizando codificación one-hot, vectores propios de matriz lineal, características Cálculo de valores, valores singulares, determinantes.
1 、 np ojo ()
np.eye (): se utiliza para devolver una matriz diagonal bidimensional para crear una matriz de identidad
numpy.eye (N, M = Ninguno, k = 0, dtype = <class 'float'>, order = 'C)
-
N : tipo int, que significa el número de líneas de salida
-
M : tipo int, opcional, el número de columnas de salida, si no, el valor predeterminado es N
-
k : tipo int, opcional, subíndice de la diagonal, el valor predeterminado es 0 significa la diagonal principal, un número negativo significa la diagonal baja y un número positivo significa la diagonal alta.
-
dtype : tipo de datos, opcional, tipo de datos de los datos devueltos
-
order : {'C', 'F'}, opcional, es decir, el formato de la matriz de salida se almacena en la memoria de acuerdo con la fila primero'C 'del lenguaje C o la columna primero'F' del formulario Fortran
Uso común:
# 创建单位矩阵
A = np.eye(2)
print("A:",A)
A1 = np.eye(3, k=1)
print("A1:",A1)
A2 = np.eye(3, k=-1)
print("A2:",A2)
A3 = np.eye(3, k=-3)
print("A3",A3)
"""
A: [[1. 0.]
[0. 1.]]
A1: [[0. 1. 0.]
[0. 0. 1.]
[0. 0. 0.]]
A2: [[0. 0. 0.]
[1. 0. 0.]
[0. 1. 0.]]
A3: [[0. 0. 0.]
[0. 0. 0.]
[0. 0. 0.]]
"""Uso en aprendizaje profundo:
Codificación one-hot:
Cuando se construye un algoritmo de clasificación, las etiquetas suelen estar codificadas como one_hot. De hecho, las etiquetas pueden ser números enteros, por lo que todos necesitamos convertir los números enteros en códigos one_hot.
La codificación One-Hot, también conocida como codificación efectiva de un bit, utiliza principalmente registros de estado de N bits para codificar estados N. Cada estado tiene su propio bit de registro independiente, y solo un bit es válido en cualquier momento.
La codificación One-Hot es la representación de variables categóricas como vectores binarios. Esto primero requiere mapear valores de clasificación a valores enteros. Luego, cada valor entero se representa como un vector binario, excepto el índice del entero, que es todo cero, y se marca como 1.
Ejemplo 1:
#设置类别的数量
num_classes = 10
#需要转换的整数
arr = [1,3,4,5,9]
#将整数转为一个10位的one hot编码
print(np.eye(10)[arr])
"""
运行结果：
[[0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]]
"""Ejemplo 2:
labels=np.array([[1],[2],[0],[1]])
print("labels的大小：",labels.shape,"\n")
#因为我们的类别是从0-2，所以这里是3个类
a=np.eye(3)[1]
print("如果对应的类别号是1，那么转成one-hot的形式",a,"\n")
a=np.eye(3)[2]
print("如果对应的类别号是2，那么转成one-hot的形式",a,"\n")
a=np.eye(3)[1,0]
print("1转成one-hot的数组的第一个数字是：",a,"\n")
#这里和上面的结果的区别，注意!!!
a=np.eye(3)[[1,2,0,1]]
print("如果对应的类别号是1,2,0,1，那么转成one-hot的形式\n",a)
res=np.eye(3)[labels.reshape(-1)]
print("labels转成one-hot形式的结果：\n",res,"\n")
print("labels转化成one-hot后的大小：",res.shape)
"""
运行结果：
labels的大小： (4, 1)
如果对应的类别号是1，那么转成one-hot的形式 [0. 1. 0.]
如果对应的类别号是2，那么转成one-hot的形式 [0. 0. 1.]
1转成one-hot的数组的第一个数字是： 0.0
如果对应的类别号是1,2,0,1，那么转成one-hot的形式
[[0. 1. 0.][0. 0. 1.][1. 0. 0.][0. 1. 0.]]
labels转成one-hot形式的结果：
[[0. 1. 0.][0. 0. 1.] [1. 0. 0.] [0. 1. 0.]]
labels转化成one-hot后的大小：(4, 3)
"""2 、 np.identidad ()
np.identity () : se utiliza para crear una matriz cuadrada n * n
np.identity (n, dtype = Ninguno)
-
n: tipo int indica que el número de filas y columnas de la matriz de salida es n
-
dtype: indica el tipo de salida, el valor predeterminado es flotante
-
Valor de retorno: una matriz donde la diagonal principal de n * n es 1 y el resto es 0
La diferencia entre esta función y la función np.eye () es que esta función solo puede crear una matriz cuadrada, es decir, N = M
a=np.identity(3)
print(a)
"""
运行结果：
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
"""3 、 np.mat ()
np.mat () : se utiliza para crear una matriz, que debe ser bidimensional.
np.mat (datos, dtype = Ninguno)
-
datos: matriz
-
dtype: indica el tipo de salida
# 创建矩阵
A = np.mat('1 2 3; 4 5 6; 7 8 9')
B=np.mat([[1,9,7], [3,9,4]])
print('A:',A)
print('B:',B)
print('A的转置:',A.T) # 矩阵的转置
print('B逆矩阵：',B.I) # 逆矩阵
"""
运行结果：
A: [[1 2 3] [4 5 6] [7 8 9]]
B: [[1 9 7] [3 9 4]]
A的转置: [[1 4 7] [2 5 8] [3 6 9]]
B逆矩阵：[[-0.17138599 0.20938897]
[-0.04023845 0.12742176]
[ 0.21907601 -0.19374069]]
"""4. np.linalg.inv ()
np.linalg.inv () : calcula la matriz inversa
np.linalg.inv (A): donde A es la forma matricial
# 创建A矩阵
A = np.mat("0 1 2; 1 0 3; 4 -3 8")
print("A:", A)
# 计算逆矩阵
inverse = np.linalg.inv(A)
print("inverse of A:", inverse)
"""
运行结果：
A: [[ 0 1 2] [ 1 0 3] [ 4 -3 8]]
inverse of A: [[-4.5 7. -1.5]
[-2. 4. -1. ] [ 1.5 -2. 0.5]]
"""5. np.linalg.solve （）
np.linalg.solve (): Resuelve ecuaciones matriciales lineales o ecuaciones escalares lineales
np.linalg.solve (a, b)
-
a: matriz de coeficientes
-
b: valor de ordenada o "variable dependiente"
Ejemplo 1: Resuelva la solución de ecuaciones lineales 3 * x0 + x1 = 9 y x0 + 2 x1 = 8:
# 求解方程系统3 * x0 + x1 = 9和x0 + 2 x1 = 8
a = np.array([[3,1], [1,2]])
b = np.array([9,8])
x = np.linalg.solve(a, b)
print("solution",x)
# 使用dot函数检查是否正确
np.allclose(np.dot(a, x), b)
"""
运行结果：
solution [2. 3.]
True
"""Ejemplo 2: Resuelva la solución de x0-2 * x1 + x2 = 0, 2 * x1-8 * x2 = 8, -4 * x0 + 5 * x1 + 9 * x2 = -9
# 求解线性方程组
# x0 - 2*x1+x2=0，2*x1-8*x2=8, -4*x0+5*x1+9*x2=-9
A = np.mat("1 -2 1;0 2 -8; -4 5 9")
print("A:",A)
b = np.array([0, 8, -9])
print("b:",b)
# 调用solve函数求解线性方程组
x = np.linalg.solve(A, b)
print("solution", x)
# 使用dot函数检查是否正确
print("check:", np.dot(A, x))
"""
运行结果：
A: [[ 1 -2 1] [ 0 2 -8] [-4 5 9]]
b: [ 0 8 -9]
solution [29. 16. 3.]
check: [[ 0. 8. -9.]]
"""6. np.linalg.eig ()
numpy.linalg.eig (A): Calcule el valor propio y el vector propio derecho de la matriz, A es un número complejo o una matriz de valor real
np.linalg.eigvals (A): Calcula los valores propios de la matriz general
# 求解特征值和特征向量
A = np.mat("3 -2;1 0")
print(A)
# 求解特征值
print("eigenvalues",np.linalg.eigvals(A))
# 求解特征向量和特征值
# eig函数返回一个元组， 按列排放着特征值和特征向量
eig_values, eig_vectors = np.linalg.eig(A)
print("eig_values:", eig_values)
print("eig_vectors:", eig_vectors)
# 使用dot函数验证是否正确计算 Ax = ax
for i in range(len(eig_values)):
print("left:", np.dot(A, eig_vectors[:,i]))
print("right:", eig_values[i] * eig_vectors[:,i])
"""
运行结果：
[[ 3 -2][ 1 0]]
eigenvalues [2. 1.]
eig_values: [2. 1.]
eig_vectors: [[0.89442719 0.70710678][0.4472136 0.70710678]]
left: [[1.78885438][0.89442719]]
right: [[1.78885438][0.89442719]]
left: [[0.70710678][0.70710678]]
right: [[0.70710678][0.70710678]]
"7. np.linalg.svd ()
np.linalg.svd (): descomposición de valor singular, el valor de retorno es s, u, v
numpy.linalg.svd (a, full_matrices = 1, compute_uv = 1)
-
a: es una matriz de la forma (M, N)
-
full_matrices: El valor es 0 o 1, y el valor predeterminado es 1. En este momento, el tamaño de u es (M, M) y el tamaño de v es (N, N). De lo contrario, el tamaño de u es (M, K), el tamaño de v es (K, N) y K = min (M, N).
-
compute_uv: el valor es 0 o 1. El valor predeterminado es 1, lo que significa que se calculan u, s, v. Cuando es 0, solo se calcula s.
# 奇异值分解
A = np.mat("4 11 14;8 7 -2")
# 使用svd函数分解矩阵
U, Sigma, V = np.linalg.svd(A, full_matrices=False)
print(U.shape, V.shape, Sigma.shape)
print("svd: ",U * np.diag(Sigma) *V)
"""
运行结果：
(2, 2) (2, 3) (2,)
svd: [[ 4. 11. 14.][ 8. 7. -2.]]
"""8. np.linalg.det ()
np.linalg.det (A): Calcula el determinante de una matriz
# 计算矩阵的行列式
A = np.mat("3 4;5 6")
print("行列式：", np.linalg.det(A))
"""
运行结果：
行列式：-1.9999999999999971
"""Adquisición de código: escanee el código QR a continuación en WeChat y responda "numpy" en segundo plano para obtener el código
artículo recomendado:
Cálculo de similitud de imagen de reconocimiento de imagen de Python
Implementación de código de reconocimiento de código de verificación simple
Instale la versión de GPU de TensorFlow (cuda + cudnn) en win10
Código de visualización de regresión lineal TensorFlow-GPU y resumen del problema
Clasificación de todos los artículos sobre rastreadores
Descifrado de código de verificación deslizante automático basado en selenio