NumPy es una biblioteca de Python para realizar cálculos numéricos a gran escala. Es extremadamente útil, especialmente en aprendizaje automático. Veamos lo que Numpy tiene para ofrecer.

Introducción a NumPy

NumPy  es una biblioteca de Python utilizada para realizar cálculos numéricos con grandes conjuntos de datos. El nombre significa numérico y es una biblioteca popular utilizada por los científicos de datos, especialmente para problemas de aprendizaje automático.

NumPy  es útil al preprocesar los datos antes de entrenarlos utilizando un algoritmo de aprendizaje automático.

Trabajar con arreglos n-dimensionales es más fácil en Numpy en comparacion con las listas de Python. Los arreglos Numpy son también más rápidos que las listas de Python, ya que, a diferencia de, los arreglos de Numpy se almacenan en un lugar continuo en la memoria. Esto permite que el procesador realice cálculos de manera eficiente

En este artículo, Veremos los conceptos básicos para trabajar con NumPy incluyendo operaciones con arreglos, transformación de matrices, generación de valores aleatorios, etcétera.

Instalación

Se proporcionan instrucciones claras de instalación en el sitio web oficial de Numpy, Así que  no las repetiré en este artículo. Encuentra las instrucciones aquí.

Trabajando con Numpy

Importando NumPy

Para comenzar a usar Numpy en su script, tienes que importarlo.

import numpy as np

Convirtiendo arreglos en arreglos NumPy

Puedes convertir tus listas de Python existentes en arreglos Numpy usando el método  np.array(), así:

arreglo = [1,2,3]
np.array(arreglo)

Esto también aplica para arreglos multi-dimensionales. NumPy realizará un seguimiento de la forma (dimensiones) del arreglo .

arreglo_anidado = [[1,2],[3,4],[5,6]]
np.array(arreglo_anidado)

Función NumPy arrange

Al trabajar con datos, a menudo te encontrarás con casos de uso donde necesites generar datos.

NumPy tiene un método  “arrange()” con el que puedes generar un rango de valores entre 2 números. La función arrange toma el inicio, el final y un parámetro de distancia opcional.

print(np.arrange(0,10)) # Sin parametro de distancia
OUTPUT:[0 1 2 3 4 5 6 7 8 9]

print(np.arrange(0,10,2)) # con parametro de distancia
OUTPUT: [0 2 4 6 8]

Ceros y unos

Tú también puedes generar un arreglo o matriz de ceros y unos usando Numpy (créeme, lo necesitarás). Así es como funciona.

print(np.zeros(3))
OUTPUT: [0. 0. 0.]

print(np.ones(3))
OUTPUT: [1. 1. 1.]

Ambas  funciones también admiten n-dimensionales. Puedes agregar la forma como una tupla con filas y columnas.

print(np.zeros((4,5)))
OUTPUT:
[
 [0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]
]

print(np.ones((4,5)))
OUTPUT:
[
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
]

Matriz de identidad

También puedes generar una matriz de identidad usando una función incorporada en Numpy llamada “eye”.

np.eye(5)
OUTPUT:
[[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.]]

Función NumPy linspace

NumPy tiene el método linspace que genera puntos uniformemente espaciados entre dos números.

print(np.linspace(0,10,3))
OUTPUT:[ 0.  5. 10.]

En el ejemplo de arriba, el primer y segundo parámetro son los puntos inicial y final, mientras que el tercer parámetro es el número de puntos que necesitas entre el inicio y el final.

Aquí está el mismo rango con 20 puntos.

print(np.linspace(0,10,20))
OUTPUT:[ 0. 0.52631579  1.05263158  1.57894737  2.10526316  2.63157895   3.15789474  3.68421053  4.21052632  4.73684211  5.26315789  5.78947368   6.31578947  6.84210526  7.36842105  7.89473684  8.42105263  8.94736842   9.47368421 10.]

Generación de Números Aleatorios

Cuando trabajes en problemas de aprendizaje automático, a menudo necesitarás generar números aleatorios. NumPy también tiene funciones integradas para eso.

Pero antes de comenzar a generar números aleatorios, veamos dos tipos principales de distribuciones.

Distribución Normal

En una  distribución normal estándar, los valores alcanzan su punto máximo.

La distribución normal es un concepto muy importante en estadística, ya que se ve en muchos fenómenos naturales. También se le llama "curva de campana".

Distribución Uniforme

Si los valores de la distribución tienen la probabilidad como una constante, se llama distribución uniforme.

Por ejemplo, el lanzamiento de una moneda tiene una distribución uniforme, ya que la probabilidad de obtener cara o cruz en un lanzamiento de moneda es la misma.

Ahora que sabes cómo funcionan las dos distribuciones principales, generemos algunos números aleatorios.

  • Para generar números aleatorios en una distribución uniforme, usa la función rand () de np.random:
print(np.random.rand(10)) # arreglo
OUTPUT: [0.46015141 0.89326339 0.22589334 0.29874476 0.5664353  0.39257603  0.77672998 0.35768031 0.95087408 0.34418542]

print(np.random.rand(3,4)) # matriz 3x4
OUTPUT:[[0.63775985 0.91746663 0.41667645 0.28272243]  [0.14919547 0.72895922 0.87147748 0.94037953]  [0.5545835  0.30870297 0.49341904 0.27852723]]
  • Para generar números aleatorios en una distribución normal, use la función randn () np.random:
print(np.random.randn(10))
OUTPUT:[-1.02087155 -0.75207769 -0.22696798  0.86739858  0.07367362 -0.41932541   0.86303979  0.13739312  0.13214285  1.23089936]

print(np.random.randn(3,4))
OUTPUT: [[ 1.61013773  1.37400445  0.55494053  0.23133522]  [ 0.31290971 -0.30866402  0.33093618  0.34868954]  [-0.11659865 -1.22311073  0.36676476  0.40819545]]
  • Para generar enteros aleatorios entre un valor inferior y superior, use la función randint () de np.random:
print(np.random.randint(1,100,10))
OUTPUT:[64 37 62 27  4 33 23 52 70  7]

print(np.random.randint(1,100,(2,3)))
OUTPUT:[[92 42 38]  [87 69 38]]

Se utiliza un valor inicial (semilla) si desea que sus números aleatorios sean los mismos durante cada cálculo. Así es como se establece un valor inicial en NumPy.

  • Para establecer un valor inicial en NumPy, haz lo siguiente:
np.random.seed(42)
print(np.random.rand(4))
OUTPUT:[0.37454012, 0.95071431, 0.73199394, 0.59865848]

Siempre que uses un número de semilla, siempre obtendrás el mismo arreglo generado sin ningún cambio.

Remodelación de Arreglos

Como científico de datos, trabajarás para reorganizar los conjuntos de datos para diferentes tipos de cálculos. En esta sección, veremos cómo trabajar con las formas de arreglos.

  • Para obtener la forma de un arreglo, use la propiedad de shape
arreglo = np.random.rand(2,2)
print(arreglo)
print(arreglo.shape)
OUTPUT:[
[0.19890857 0.00806693]
[0.48199837 0.55373954]
]
(2, 2)
  • Para reorganizar un arreglo, use la función  reshape().
print(arreglo.reshape(1,4))
OUTPUT: [[0.19890857 0.00806693 0.48199837 0.55373954]]
print(arreglo.reshape(4,1))
OUTPUT:[
[0.19890857]
[0.00806693]
[0.48199837]
[0.55373954]
]

Para reorganizar permanentemente un arreglo, debe asignar el arreglo reorganizado a la variable "arreglo"

Además, la reorganización solo funciona si la estructura existente tiene sentido. No puede reorganizar una matriz de 2x2 en una matriz de 3x1.

Datos de Corte

Veamos como obtener datos de arreglos. Los arreglos Numpy trabajan de manera similar a las listas en Python durante las oraciones de recuperación de datos.  

  • Para cortar un arreglo, haz esto:
miarreglo = np.arange(0,11)
print(miarreglo)
OUTPUT:[ 0  1  2  3  4  5  6  7  8  9 10]

cortado = miarreglo[0:5]
print(cortado)
OUTPUT: [0 1 2 3 4]

cortado[:] = 99
print(cortado)
OUTPUT: [99 99 99 99 99]

print(miarreglo)
OUTPUT:[99 99 99 99 99  5  6  7  8  9 10]

Si observas el ejemplo anterior, aunque asignamos el segmento de "miarreglo" a la variable "cortado", el cambio del valor de "cortado" afecta al arreglo original. Esto se debe a que el "la parte cortada" solo apuntaba al arreglo original.

Para hacer una sección independiente de una arreglo, use la función copy ().

 cortado = miarreglo.copy()[0:5]
  • Cortar arreglos multidimensionales funciona de manera similar a los arreglos unidimensionales
mi_arreglo = np.random.randint(1,30,(3,3))
print(mi_arreglo)
OUTPUT: [
[21  1 20]
[22 16 27]
[24 14 22]
]

print(mi_arreglo[0]) # imprime una sola fila
OUTPUT: [21  1 20]

print(mi_arreglo[0][0]) # imprime un solo valor o fila 0, columna 0
OUTPUT: 21

print(mi_arreglo[0,0]) #forma alternativa de imprimir valor de la  fila0,colu0
OUTPUT: 21

Cálculos con Arreglos

Ahora veamos los cálculos con arreglos. NumPy es conocido por su velocidad al realizar cálculos complejos en grandes arreglos multidimensionales

Intentemos con algunas operaciones básicas.

nuevo_arreglo = np.arange(1,11)
print(nuevo_arreglo)
OUTPUT: [ 1  2  3  4  5  6  7  8  9 10]
  • Suma
print(nuevo_arreglo + 5)
OUTPUT: [ 6  7  8  9 10 11 12 13 14 15]
  • Resta
print(nuevo_arreglo - 5)
OUTPUT: [-4 -3 -2 -1  0  1  2  3  4  5]
  • Suma de Arreglos
print(nuevo_arreglo + nuevo_arreglo)
OUTPUT: [ 2  4  6  8 10 12 14 16 18 20]
  • División de Arreglos
print(nuevo_arreglo / nuevo_arreglo)
OUTPUT:[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]

Para errores por dividir en cero, Numpy convertirá el valor a NaN (no es un número).

También hay algunos métodos de cálculo integrados disponibles en NumPy para calcular valores como la media, la desviación estándar, la varianza y otros.

  • Suma — np.sum()
  • Raíz cuadrada — np.sqrt()
  • Media — np.mean()
  • Varianza — np.var()
  • Desviación estándar — np.std()

Mientras trabajas con arreglos 2d, a menudo necesitarás calcular la suma, la media, la varianza, etc., por filas o columnas. Puedes utilizar el parámetro de eje opcional para especificar si desea elegir una fila o una columna.

arreglo2d = np.arange(25).reshape(5,5)
print(arreglo2d)
OUTPUT: [
[ 0  1  2  3  4]
[ 5  6  7  8  9]
[10 11 12 13 14]
[15 16 17 18 19]
[20 21 22 23 24]
]

print(arreglo2d.sum())
OUTPUT: 300

print(arreglo2d.sum(axis=0))  # suma de columnas
OUTPUT: [50 55 60 65 70]

print(arreglo2d.sum(axis=1)) #suma de filas
OUTPUT: [ 10  35  60  85 110]

Operaciones condicionales

También puedes hacer un filtrado condicional con NumPy usando la notación de corchetes. Aquí hay un ejemplo:

arr = np.arange(0,10)
OUTPUT: [0,2,3,4,5,6,7,8,9]

print(arr > 4)
OUTPUT: [False False False False False  True  True  True  True  True]

print(arr[arr > 4])
OUTPUT: [5 6 7 8 9]

Resumen

Cuando se trata de trabajar con grandes conjuntos de datos, NumPy es una herramienta poderosa para tener en su kit de herramientas. Es capaz de manejar cálculos numéricos avanzados y operaciones complejas de arreglos de n dimensiones.

Te recomiendo que aprendas NumPy si planeas comenzar una carrera en el aprendizaje automático.

Aquí hay un cuaderno de colab de google si deseas probar estos ejemplos.

Consigue un resumen de mis artículos  y vídeos enviados a tu correo electrónico todos los lunes por la mañana. También puedes Conectarte conmigo aquí.

Traducido del artículo de Manish Shivanandhan - Python NumPy Crash Course – How to Build N-Dimensional Arrays for Machine Learning