Aumentar la eficiencia matemática Navegando por las operaciones de matrices Numpy

Aumentar eficiencia matemática en operaciones de matrices Numpy

 

En este artículo, descubriremos la potencia de una de las famosas y útiles bibliotecas de Python para el análisis de datos, NumPy, donde la estructura de datos principal para almacenar los elementos y realizar operaciones es una matriz multidimensional. Veremos cómo esta biblioteca dinámica hace que la tarea matemática compleja sea eficiente en cuanto a la complejidad espacial y temporal. También veremos cómo la manipulación y transformación de datos pueden ser más fáciles con respecto a las operaciones sin esfuerzo.

 

¿Qué es NumPy?

 

NumPy, Scipy y Matplotlib son bibliotecas de Python utilizadas en proyectos de Ciencia de Datos, que proporcionan funcionalidad similar a MATLAB.

   

Principalmente, NumPy tiene las siguientes características:

  1. Arrays multidimensionales con tipo de dato definido (matrices)
  2. Cálculos numéricos rápidos (matemáticas de matrices)
  3. Funciones matemáticas de alto nivel

NumPy significa Python Numérico, el paquete fundamental requerido para la computación de alto rendimiento y el análisis de datos. NumPy es necesario para cálculos numéricos en Python porque está diseñado para ser eficiente en matrices de datos grandes.

 

Diferentes formas de crear arrays en NumPy

 

Antes de comenzar a realizar operaciones en arrays de NumPy, nuestro primer objetivo es convertirnos en expertos en la creación de un array de NumPy basado en nuestros requisitos según la declaración del problema.

Existen múltiples formas de crear arrays de NumPy. A continuación se mencionan algunos métodos estándar y prácticos:

Caso 1: Utilizando el método np.ones para crear un array de unos:

Si tenemos que crear un array de solo “unos”, podemos utilizar este método.

np.ones((3,5), dtype=np.float32)
# Salida
[[1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]

 

Caso 2: Utilizando el método np.zeros para crear un array de ceros:

Si tenemos que crear un array de solo “ceros”, podemos utilizar este método.

np.zeros((6,2), dtype=np.int8)
# Salida
[[0 0]
 [0 0]
 [0 0]
 [0 0]
 [0 0]
 [0 0]]

 

Caso 3: Utilizando el método np.arange:

Podemos utilizar este método si tenemos que crear un array de elementos siguiendo una secuencia.

np.arange(1334,1338)
# Salida
[1334 1335 1336 1337]

 

Caso 4: Utilizando el método np.concatenate:

Este método es adecuado cuando el array requerido combina uno o más arrays.

A = np.ones((2,3))
B = np.zeros((4,3))
C = np.concatenate([A, B])
# Salida
[[1. 1. 1.]
 [1. 1. 1.]
 [0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]

 

Caso 5: Utilizando el método np.random.random:

Es útil cuando se crea un array con valores aleatorios.

np.random.random((2,3))
# Salida
[[0.30512345 0.10055724 0.89505387]
 [0.36219316 0.593805   0.7643694 ]]

 

Operaciones con Arrays en NumPy

 

Discutamos las propiedades básicas de un array de NumPy con un ejemplo:

Código:

a = numpy.array([[1,2,3],[4,5,6]],dtype=numpy.float32)
# Dimensiones del array, forma y tipos de datos
print (a.ndim, a.shape, a.dtype)
Salida:
2 (2, 3) float32

 

Basado en el código anterior, tenemos los siguientes puntos para recordar como conclusión:

  1. Los arrays pueden tener cualquier dimensión como un número entero positivo, incluyendo cero (corresponde a un valor escalar).
  2. Los arrays tienen un tipo y pueden tener tipos de datos como np.uint8, np.int64, np.float32, np.float64
  3. Los arrays son densos. Cada elemento del array existe y tiene el mismo tipo.

Código:

# Reshape de arrays
a = numpy.array([1,2,3,4,5,6])
a = a.reshape(3,2)              
# Salida: 
[[1 2]                 
[3 4]                           
[5 6]]

a = a.reshape(2,-1)
# Salida: 
[[1 2 3]
 [4 5 6]]

a = a.ravel()
# Salida:  
[1 2 3 4 5 6]

 

Puntos importantes para recordar:

  1. El número total de elementos en el array no puede cambiar después de la operación de reshaping.
  2. Para inferir la forma del eje, se utiliza -1.
  3. Por defecto, almacena los elementos en formato de fila principal, mientras que en MATLAB es columna principal.

 

Broadcasting de Arrays en Numpy 

 

El broadcasting permite realizar operaciones en arrays de diferentes formas siempre y cuando sean compatibles. Las dimensiones más pequeñas de un array se expanden virtualmente para coincidir con las dimensiones del array más grande.

   

Código:

# Broadcasting de arrays
a = numpy.array([[1, 2], [3, 4], [5, 6]])
b = numpy.array([10, 20])
c = a + b  # Broadcasting el array 'b' para coincidir con las dimensiones de 'a'

 

El ejemplo implica un array NumPy 2D ‘a’ con dimensiones (3, 2) y un array 1D ‘b’ con forma (2). El broadcasting permite que la operación ‘a + b’ expanda virtualmente ‘b’ para que coincida con ‘a’ en la segunda dimensión, resultando en una suma elemento a elemento entre ‘a’ y ‘b’ expandido.

 

Indexación y Slicing de Arrays

 

  1. Los slices son vistas. Al escribir en un slice se sobrescribe el array original.
  2. Una lista o un array booleano también se pueden utilizar como índice.
  3. Sintaxis de indexación en Python: 

índice_inicio : índice_fin: tamaño_paso

Código:

a = list(range(10)) 

 # primeros 3 elementos
a[:3] # índices 0, 1, 2 

# últimos 3 elementos
a[-3:] # índices 7, 8, 9 

# índices 3, 5, 7 
a[3:8:2] 

# índices 4, 3, 2 (este es complicado)
a[4:1:-1] 

 

Como sabes, una imagen también se puede visualizar como un array multidimensional. Por lo tanto, el slicing también puede ser útil para realizar algunas operaciones matemáticas en imágenes. A continuación, se mencionan algunos ejemplos importantes y avanzados para aumentar tu comprensión:

# Seleccionar todo excepto el borde de un píxel 
pixel_matrix[1:-1,1:-1]         

# Cambiar el orden de los canales 
pixel_matrix = pixel_matrix[:,:,::-1]

# Establecer los píxeles oscuros en negro  
pixel_matrix[pixel_matrix<10] = 0

# seleccionar la segunda y cuarta fila        
pixel_matrix[[1,3], :]  

 

Agregación y Reducción de Arrays

 

Ahora, comenzaremos con las operaciones de agregación en arrays de numpy. En general, las operaciones que se pueden realizar son las siguientes:

  1. Encontrar la suma y el producto de todos los elementos del array.
  2. Encontrar el elemento máximo y mínimo en el array
  3. Encontrar el número de ocurrencias de un elemento particular en un array
  4. También se pueden encontrar otros parámetros utilizando el módulo de álgebra lineal, incluyendo el determinante de una matriz, la traza de una matriz, los autovalores y autovectores de una matriz, etc.

Comencemos a discutir cada funcionalidad con ejemplos:

Caso 1: Suma algebraica de todos los elementos presentes en el arreglo

array_1 = numpy.array([[1,2,3], [4,5,6]])
print(array_1.sum())
#Resultado: 
21

 

Caso 2: Elemento máximo en el arreglo

array_1 = numpy.array([[1,2,3], [4,5,6]])
print(array_1.max())
#Resultado: 
6

 

Caso 3: Elemento mínimo en el arreglo

array_1 = numpy.array([[1,2,3], [4,5,6]])
print(array_1.min())
#Resultado: 
1

 

Caso 4: Posición/Índice del elemento en el arreglo donde se encuentra el elemento máximo

array_1 = numpy.array([[1,2,3], [4,5,6]])
print(array_1.argmax())
#Resultado: 
5

 

Caso 5: Posición/Índice del elemento en el arreglo donde se encuentra el elemento mínimo

array_1 = numpy.array([[1,2,3], [4,5,6]])
print(array_1.argmin())
#Resultado: 
0

 

Al encontrar la posición, puedes observar que considera cualquier arreglo multidimensional como un arreglo 1-D y luego lo calcula.

Caso 6: Media/Promedio de todos los elementos en un arreglo

array_1 = numpy.array([[1,2,3], [4,5,6]])
print(array_1.mean())
#Resultado: 
3.5

 

Caso 7: Producto punto/Producto escalar de dos arreglos multidimensionales

array_1 = numpy.array([[1,2], [4,5]])
array_2 = numpy.array([[1,-1,2], [3,7,-2]])
t = array_1.dot(array_2)
print(t)
#Resultado: 
[[ 7 13 -2]
 [19 31 -2]]

 

Vectorización en Arreglos Numpy

 

La vectorización permite realizar operaciones en arreglos completos en lugar de iterar a través de elementos individuales. Aprovecha rutinas optimizadas de bajo nivel, lo que resulta en un código más rápido y conciso.

Código:

a = numpy.array([1, 2, 3, 4, 5])
b = numpy.array([10, 20, 30, 40, 50])
c = a + b  # Suma de elementos sin bucles explícitos

 

Basado en el ejemplo anterior, puedes ver que se crean dos arreglos NumPy llamados ‘a’ y ‘b’. Al realizar la operación ‘a + b’, donde se realiza una suma de elementos entre los arreglos utilizando el concepto de vectorización, se obtiene un nuevo arreglo ‘c’ que contiene la suma de los elementos correspondientes de ‘a’ y ‘b’. Por lo tanto, debido a la operación elemento a elemento, el programa evita ejecutar bucles explícitos y utiliza rutinas optimizadas para un cálculo eficiente.

 

Concatenación de Arreglos

 

Caso 1: Supongamos que tienes dos o más arreglos para concatenar utilizando la función concatenate, donde tienes que unir la tupla de los arreglos.

Código:

# concatenar 2 o más arreglos utilizando la función concatenate fila por fila
numpy_array_1 = numpy.array([1,2,3])
numpy_array_2 = numpy.array([4,5,6])
numpy_array_3 = numpy.array([7,8,9])
array_concatenate = numpy.concatenate((numpy_array_1, numpy_array_2, numpy_array_3))
print(array_concatenate)
#Resultado:
[1 2 3 4 5 6 7 8 9]

 

Caso 2: Supongamos que tienes un arreglo con más de una dimensión; entonces, para concatenar los arreglos, debes mencionar el eje a lo largo del cual se deben concatenar. De lo contrario, se realizará a lo largo de la primera dimensión. 

Código:

# concatenar 2 o más matrices utilizando la función concatenate columna por columna
array_1 = numpy.array([[1,2,3], [4,5,6]])
array_2 = numpy.array([[7,8,9], [10, 11, 12]])
array_concatenate = numpy.concatenate((array_1, array_2), axis=1)
print(array_concatenate)
# Salida:
[[ 1  2  3  7  8  9]
 [ 4  5  6 10 11 12]]

 

Funciones Matemáticas y Funciones Universales

 

Estas funciones universales también se conocen como ufuncs. Se realizan operaciones elemento por elemento en estas funciones. Por ejemplo:

  1. np.exp
  2. np.sqrt
  3. np.sin
  4. np.cos
  5. np.isnan

Código:

A = np.array([1,4,9,16,25])
B = np.sqrt(A)
# Salida
[1. 2. 3. 4. 5.]

 

Comparaciones de Rendimiento

 

Al realizar cálculos numéricos, Python requiere mucho tiempo si tenemos cálculos grandes. Si tomamos una matriz de forma 1000 x 1000 y realizamos la multiplicación de matrices, entonces el tiempo requerido por Python y numpy es:

  1. El bucle triple de Python tarda más de 10 minutos
  2. Numpy tarda aproximadamente 0.03 segundos

Por lo tanto, a partir del ejemplo anterior, podemos ver que numpy requiere significativamente menos tiempo que Python estándar, por lo que nuestra latencia se reduce en proyectos de la vida real relacionados con la Ciencia de Datos, que tienen datos masivos para procesar. 

 

Conclusión

 

En este artículo, discutimos las matrices numpy. Entonces, para concluir nuestra sesión, resumamos las ventajas de numpy sobre Python:

  1. Numpy tiene cálculo orientado a matrices.
  2. Numpy implementa eficientemente matrices multidimensionales.
  3. Numpy está diseñado principalmente para computación científica.
  4. Numpy contiene funciones matemáticas estándar para una computación más rápida en matrices sin bucles.
  5. Numpy tiene álgebra lineal incorporada y módulos de generación de números aleatorios para trabajar con capacidades de transformación de Fourier.
  6. Numpy también contiene herramientas para leer y escribir matrices en disco y trabajar con archivos mapeados en memoria.

    Aryan Garg es un estudiante de Ingeniería Eléctrica de B.Tech., actualmente en el último año de su carrera de pregrado. Su interés se encuentra en el campo del Desarrollo Web y el Aprendizaje Automático. Ha seguido este interés y está ansioso por trabajar más en estas direcciones.  

We will continue to update Zepes; if you have any questions or suggestions, please contact us!

Share:

Was this article helpful?

93 out of 132 found this helpful

Discover more

Inteligencia Artificial

15+ Herramientas de IA para Desarrolladores (Diciembre 2023)

GitHub Copilot GitHub Copilot se destaca como un asistente de codificación impulsado por IA líder en el mercado. Dise...

Inteligencia Artificial

EE.UU. busca malware chino que podría interrumpir las operaciones militares

Funcionarios de seguridad de Estados Unidos dicen que la Casa Blanca está buscando malware supuestamente oculto por C...

Aprendizaje Automático

Conoce BITE Un Nuevo Método Que Reconstruye la Forma y Poses 3D de un Perro a Partir de una Imagen, Incluso con Poses Desafiantes como Sentado y Acostado.

Múltiples campos, incluyendo la biología y la conservación, así como el entretenimiento y el desarrollo de contenido ...

Inteligencia Artificial

CEO de OpenAI, Sam Altman Empleos en riesgo a medida que la IA demuestra su poderío

El CEO de OpenAI, Sam Altman, ha expresado públicamente sus preocupaciones sobre los posibles peligros de la intelige...

Inteligencia Artificial

Toma el control NVIDIA NeMo SteerLM permite a las empresas personalizar las respuestas de un modelo durante la inferencia

Los desarrolladores tienen un nuevo volante de conducción asistida por IA para ayudarles a mantenerse en la carretera...