De un traductor: esta es una traducción del material de Rakshit Vasudev, quien ha estado estudiando DataScience durante mucho tiempo y utilizando el lenguaje Python en él. El autor habla sobre la poderosa biblioteca Numpy, que le permite implementar muchas funciones de aprendizaje automático y trabajar con grandes datos.
Numpy es una biblioteca matemática para Python. Le permite realizar todo tipo de cálculos de manera eficiente y rápida. Amplía enormemente la funcionalidad de Python gracias a las soluciones especiales que se utilizan en él. Este artículo habla sobre las características básicas de Numpy, y esta es solo la primera parte; otros serán publicados un poco más tarde. Este artículo es para aquellos que recién comienzan a aprender Numpy, entrando al valiente mundo de las matemáticas en Python.
Skillbox recomienda: El programa práctico Python Developer desde cero .
Le recordamos: para todos los lectores de "Habr": un descuento de 10.000 rublos al registrarse en cualquier curso de Skillbox con el código de promoción "Habr".
Importar biblioteca
import numpy as np
En este punto, le decimos a Python que np es la referencia para Numpy, que continuará usándose.
Ahora cree una matriz de python y una matriz de np.
No hay mucha diferencia en el retiro.
print(a) print(A) ==================================================================== [1, 2, 3, 4, 5, 6, 7, 8, 9] [1 2 3 4 5 6 7 8 9]
Bueno, ¿por qué es mejor usar una matriz numpy en lugar de la habitual? La respuesta es porque np nos permitirá hacer cálculos más rápido y modificar la arquitectura general de la aplicación.
np.arange ()
np.arange(0,10,2) ==================================================================== array([0, 2, 4, 6, 8])
([inicio], detener, [paso]) ordena los números. Esto es lo que significa para un automóvil.
Creamos una lista np, comenzando de 0 a 10, pero no incluimos 10, además aumentamos los números en 2 cada vez.
Por lo tanto, obtenemos esto:
matriz ([0, 2, 4, 6, 8])
Es importante recordar que el último dígito no está incluido en la lista.
Otro ejemplo:
np.arange(2,29,5) ==================================================================== array([2, 7, 12, 17, 22, 27])
Esta matriz también se puede llamar matriz o vector. Por lo tanto, no se preocupe cuando digo, por ejemplo: "La forma de la matriz es 2 * 3". Todo esto significa que nuestra matriz finalmente se verá así:
array([2, 7, 12], [17, 22, 27])
Ahora hablemos de un parámetro como la forma de la matriz np predeterminada. La forma aquí es un atributo. Un ejemplo de su uso está a continuación.
A = [1, 2, 3, 4, 5, 6, 7, 8, 9] A.shape ==================================================================== (9,)
Esta es una matriz de números, donde en una fila solo hay 9 elementos. En principio, una matriz 1 * 9 es ideal, ¿verdad?
Básicamente, sí, y para esto, reshape () entra en juego. Este es un método que redimensiona la matriz original como nos gustaría.
Aquí hay un ejemplo del uso de reshape () en la práctica.
A = [1, 2, 3, 4, 5, 6, 7, 8, 9] A.reshape(1,9) ==================================================================== array([[1, 2, 3, 4, 5, 6, 7, 8, 9]])
Tenga en cuenta que la remodelación devuelve una matriz multidimensional. Esto se indica mediante dos corchetes al principio. [[1, 2, 3, 4, 5, 6, 7, 8, 9]] es una matriz potencialmente multidimensional, a diferencia de [1, 2, 3, 4, 5, 6, 7, 8, 9].
Otro ejemplo:
B = [1, 2, 3, 4, 5, 6, 7, 8, 9] B.reshape(3,3) ==================================================================== array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
Si tomamos el parámetro de forma para B, entonces será (3.3):
B.shape ==================================================================== (3,3)
Pasemos a np.zeros ()
¿Qué se explica en este código?
np.zeros((4,3)) ==================================================================== ???????????
A saber: aquí se da una matriz de formato 3 * 4 llena de ceros. Aquí está la conclusión:
np.zeros((4,3)) ==================================================================== array([[0., 0., 0.], [0., 0., 0.], [0., 0., 0.], [0., 0., 0.]])
np.zeros ((n, m)) devuelve una matriz de formato n * m llena de ceros. Todo es simple
¿Qué hace np.eye ()?
Nos devuelve una matriz unitaria con ciertas características.
np.eye(5) ==================================================================== array([[1., 0., 0., 0., 0.], [0., 1., 0., 0., 0.], [0., 0., 1., 0., 0.], [0., 0., 0., 1., 0.], [0., 0., 0., 0., 1.]])
¿Cómo multiplicar dos matrices?
No hay problema: para esto se usa np.dot (). Esta función es un producto escalar si se le pasan vectores y el producto matriz (el más común).
Ejemplo: A = (2,3) y B = (3,2). Aquí el número de columnas en A es 3. El número de filas en B es 3. Dado que las características coinciden, es posible la multiplicación.
Hemos preparado matrices para la multiplicación. A continuación, actuamos.
Ahora agreguemos los elementos individuales a la matriz.
np.sum () agrega elementos a la matriz.
Sin embargo, tenemos dos opciones.
1. Doblar en filas
6 - la suma de la primera fila (1, 2, 3).
15 - segundo (4, 5, 6).
24 - tercero (7, 8, 9).
2. Doblar en columnas
12 - la suma de la primera columna (1, 4, 7).
15 - según el segundo (2, 5, 7).
18 - según el tercero (3, 6, 9).
A continuación se muestra un video creado por el autor, donde todo lo descrito anteriormente se explica nuevamente, más claramente.
Skillbox recomienda: