Funciones principales de NumPy

🧮Funciones principales de NumPy

arr = np.random.randint(1, 20, 10)
matriz = arr.reshape(2,5)
matriz
----> array([[18,  8,  3, 11,  1],
       [15, 10, 13,  9, 15]])
arr
----> array([18,  8,  3, 11,  1, 15, 10, 13,  9, 15])
arr.max() ----> 18
matriz.max() ----> 18

Podemos regresar los máximos de cada fila o columna especificando el eje.

matriz.max(1) ----> array([18, 15])
matriz.max(0) ---->array([18, 10, 13, 11, 15])

Tambien tenemos .argmax() que nos devuelve la posición del elemento

arr.argmax() ----> 0
matriz.argmax(0) ----> array([0, 1, 1, 0, 1])

De forma análoga tenemos .min()

arr.min() ----> 1
arr.argmin() ----> 4
matriz.min(0) ----> array([15,  8,  3,  9,  1])
matriz.argmin(1) ----> array([4, 3])

Podemos saber la diferencia de valor más bajo con el más alto.

arr.ptp() # 18 - 1 ----> 17
matriz.ptp(0)  ----> array([ 3,  2, 10,  2, 14])

Para hacer análisis estádistico se tienen la siguientes funciones.

Ordenar los elementos:
arr.sort() ----> array([1, 3, 8, 9,10, 11,13, 15,15,18])

Obtener un percentil:

np.percentile(arr, 0) ----> 1.0

Mediana:

np.median(arr) ----> 10.5

Desviación estándar:

np.std(arr) ----> 5.080354

Varianza:

np.var(arr) ----> 25.81000

Promedio

np.mean(arr) ----> 10.3

Lo mismo aplica para las matrices.

np.median(matriz, 1) ----> array([ 8., 15.])

Se pueden unir dos arrays por medio de la concatenación

a = np.array([[1,2], [3,4]])
b= np.array([5, 6])
np.concatenate((a,b), axis = 0)
----------------------------------------------------
ValueError                  Traceback (most recent call last)
<ipython-input-213-97c6fb2c6837> in <module>()
----> 1 np.concatenate((a,b), axis = 0)

<__array_function__ internals> in concatenate(*args, **kwargs)

ValueError: all the input arrays must have same number of dimensions, but the array at index 0 has 2 dimension(s) and the array at index 1 has 1 dimension(s)

El error anterior es debido a a tiene 2 dimensiones mientras que b tiene 1.

print(a.ndim) ----> 2
b.ndim ----> 1
b = np.expand_dims(b, axis = 0)
np.concatenate((a,b), axis = 0)
----> array([[1, 2],
       [3, 4],
       [5, 6]])

De igual forma podemos agregarlo en el otro eje

np.concatenate((a,b), axis = 1)
-----------------------------------------------
ValueError               Traceback (most recent call last)
<ipython-input-217-3ae7237876ab> in <module>()
      1 # De igual forma podemos agregarlo en el otro eje
----> 2 np.concatenate((a,b), axis = 1)

<__array_function__ internals> in concatenate(*args, **kwargs)

ValueError: all the input array dimensions for the concatenation axis must match exactly, but along dimension 0, the array at index 0 has size 2 and the array at index 1 has size 1

Como b es una fila y no una columna, no se puede concatenar a menos que se aplique la transpuesta.

np.concatenate((a,b.T), axis = 1)
----> array([[1, 2, 5],
       [3, 4, 6]])

Si array.sort() les retorna none

np.sort(arr)

https://stackoverflow.com/questions/45023833/numpy-sort-function-returns-none

Para calcular los percentiles hay que tener los valores ordenados

Con el prefijo NAN a las funciones mediana, media, desvío estándar y varianza tenemos las mismas funciones pero además manejan los nulos.
Útiles para trabajar con dataset faltantes de datos.
Tenemos la matriz 3x3x3 con tipo de dato punto flotante (np.nan es para float).

mtrz_3x3x3 =np.array([[[1,2,3], [4,5,6], [7,8,9]],[[11,12,13], [14,15,16],[17,18,19]],[[21,22,23], [24,25,26],[27,28,29]]], dtype='float64')
# agregamos un SOLO valor en la matriz de 27 elementos
mtrz_3x3x3[0, 1, 2] = np.nan
mtrz_3x3x3

array([[[ 1., 2., 3.],
[ 4., 5., nan],
[ 7., 8., 9.]],
[[11., 12., 13.],
[14., 15., 16.],
[17., 18., 19.]],
[[21., 22., 23.],
[24., 25., 26.],
[27., 28., 29.]]])

Calculamos la media (mean vs nanmean).

np.mean(mtrz_3x3x3),np.nanmean(mtrz_3x3x3)

(nan, 15.346153846153847)

Calculamos la mediana (median vs nanmedian).

np.median(mtrz_3x3x3),np.nanmedian(mtrz_3x3x3)

(nan, 15.5)

Calculamos la desvio estandar (std vs nanstd).

np.std(mtrz_3x3x3),np.nanstd(mtrz_3x3x3)

(nan, 8.539241128651565)

Calculamos la varianza (var vs nanvar).

np.var(mtrz_3x3x3),np.nanvar(mtrz_3x3x3)

(nan, 72.91863905325444)

Con un solo nulo en los 27 elementos de la matriz no podríamos calcular los estadísticos fácilmente si tendríamos a disposición.

Concatenación por columnas

Concatenación por filas

b está con corchetes por que debe tener la misma dimensión que a

Me encantó la emoción con la que dijo “No me lo vas a creer”, cuando explicó el argmin JAJA

visualiza los arrays como cajas que ordenan datos
Para iniciar a entender los arrays tal vez es útil visualizarlos en forma de recta(vector), plano(matriz ) o filas y columnas; será suficiente para analizar datos estructurados, pero este entendimiento quedará corto al momento de tratar de interpretar tensores cuando se trabaja con redes neuronales, en estos casos tratar de visualizar una 4ta dimensión en un gráfico es imposible, y tendrán problemas al querer concatenar tensores a través de un eje que salga de la representación de filas y columnas.
En mi caso yo interpreto los arrays (vectores, matrices o tensores) como una caja que contiene otras cajas que puede contener otras cajas, dependiendo el tamaño de la caja (que depende del nivel donde se encuentre) será igual a su axis. solo intenten visualizar los corchetes como cajas que empaquetan otras cajas que al final contienen nuestros datos organizados. Esta metáfora me ayuda a poder manipular tensores con sus dimensiones y entenderlos de forma más exacta.

Podemos usar np.quantile(arr, 0.25) y np.quantile(arr, 0.75) para encontrar el 1 y el 3 cuartil. muy usado en estadística para el análisis de caja y bigote y/o para encontrar datos extraños.

Mi resumen #8 (Notion + Notas de Cornell)

Exponents and logarithms

exp(x, /[, out, where, casting, order, …])

Calculate the exponential of all elements in the input array.

expm1(x, /[, out, where, casting, order, …])

Calculate exp(x) - 1 for all elements in the array.

exp2(x, /[, out, where, casting, order, …])

Calculate 2**p for all p in the input array.

log(x, /[, out, where, casting, order, …])

Natural logarithm, element-wise.

log10(x, /[, out, where, casting, order, …])

Return the base 10 logarithm of the input array, element-wise.

log2(x, /[, out, where, casting, order, …])

Base-2 logarithm of x.

log1p(x, /[, out, where, casting, order, …])

Return the natural logarithm of one plus the input array, element-wise.

logaddexp(x1, x2, /[, out, where, casting, …])

Logarithm of the sum of exponentiations of the inputs.

logaddexp2(x1, x2, /[, out, where, casting, …])

Logarithm of the sum of exponentiations of the inputs in base-2.

Por si alguien también se enredó con esto:

siempre nos referimos a filas como 0 y columnas como 1, PERO
matriz.max(0) se refiere a columnas
matriz.max(1) se refiere a filas

Se genera mucha confusión pues en la descripción de RECURSOS, se menciona que el axis 0 son las columnas, mientras que axis 1 son las filas (cuando esto es lo inverso).

En los ejemplos de matriz.max(1) ciertamente tomamos el valor máximo entre todas las columnas pero de un vector o row. Para matriz.max(0), de entre todos los rows (vectores), tomaremos el valor maximo sobre esa misma columna.

Les recomiendo este artículo

Por aquí empiezan las funciones de estadísticas

El método .ptp() es básicamente lo que se conoce en estadística como rango 😃.

Información resumida de esta clase
#EstudiantesDePlatzi

• Con la función max puedo obtener el valor más grande de mi array o arreglo

• Con la función min puedo obtener el valor más pequeño de mi array

• Con la función ptp puedo saber cuál es la diferencia entre mi valor más grande y el más pequeño

• Con la función percentil puedo encontrar la mediana de mi array o el porcentaje que yo desee

• Con la función sort puedo organizar mi arreglo de menor a mayor

• Con la función median obtengo la mediana de mi array

• Con la función std puedo encontrar la desviación estándar de mi arreglo

• La desviación estándar al cuadrado es igual a mi varianza

• la media es la suma de todos los valores de mi arreglo, dividido en la cantidad de valores que tengo

• No puedo concatenar 2 arrays de diferentes dimensiones, primero debo modificarlas si es necesario, para que tengan las mismas dimensiones y luego concatenar

• con la T mayúscula creo la transpuesta de una matriz, es decir, cambiar de forma contraria

Me encanta que NumPy es cero verboso y que con pocas líneas es muy eficiente y potente. Gracias Python 💚

• Para obtener la frecuencia de los valores de un array tenemos:

arr ----> array([ 3,  5,  7,  7,  8,  8, 11, 16, 16, 17])
np.bincount(arr)
----->  array([0, 0, 0, 1, 0, 1, 0, 2, 2, 0, 0, 1, 0, 0, 0, 0, 2, 1])

• Para calcular el promedio ponderado de un array tenemos

np.average(arr)
-----> 9.8

• Lo anterior tambien aplica para matrices

Para los que tenemos dudas con los axesm, me parecio muy bueno como se explica en el link que comparto:
https://www.sharpsightlabs.com/blog/numpy-axes-explained/

Le falto un poco de explicacion en esta clase.

Para entender un poco el paso a paso de como funciona el percentil, hice este mini tutorial en codigo para tenerlo un poco mas claro:

arr2 = np.random.randint(1, 21, 10)
print(f'Los valores del array son: {arr2}')
print(f'El valor ubicado en el percentil 50 es: {np.percentile(arr2, 50)}')
print(f'Y por qué es {np.percentile(arr2, 50)}')
print(f'Ordenando los valores del array quedan asi: ')
arr2.sort()
print(arr2)
print(f'Por lo tanto el percentile ubicado en el valor 50 es {np.percentile(arr2, 50)}')

Para ejecutarlo deben por supuesto importar primero la libreria de Numpy.

funciones:

.max()
.max(axis)
.argmax() #devuelve el índice donde se encuentra el mayor valor
.argmax(axis)
.min()
.min(axis)
.argmin()
.argmin(axis)
.ptp()
.ptp(axis) # devuelve la distribucion: max- min
np.percentile(arr,50)
.sort() #ordena de menor a mayor
np.median(arr) #da la mediana
np.std(arr) # desviación estándar
np.var(arr) # varianza
np.mean(arr)
a = np.array([[1,2],[3,4]])

Para leer el axis en el código y no confundirme yo relaciono -como lei en un blog-:
axis 0 - running vertically across rows
axis 1 - running horizontally across columns
Si te vas confundiendo, prueba con ello, aI menos a mi me ayuda.

Aporte

No hay una inversión en el uso de los ejes (axis) entre la función concatenate de NumPy y otras funciones de la biblioteca. La diferencia es que en concatenate, los ejes se interpretan de manera diferente según el tipo de arrays que se estén concatenando.

En la función concatenate de NumPy, el parámetro ‘axis’ indica la dimensión a lo largo de la cual se realizará la concatenación. Si se desea concatenar dos matrices a lo largo del eje horizontal, es decir, agregar columnas a la matriz, se debe usar axis=1. Por otro lado, si se desea concatenar dos matrices a lo largo del eje vertical, es decir, agregar filas a la matriz, se debe usar axis=0.

Es importante tener en cuenta que esta convención es consistente con otras funciones de NumPy y de otras bibliotecas para el manejo de matrices y arreglos. Por ejemplo, en la mayoría de las funciones de NumPy para la manipulación de arreglos, el eje 0 se refiere a las filas y el eje 1 se refiere a las columnas.

A mi si me funciona el

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

c = np.concatenate((a,b), axis=0)
print(c)

Principales funciones de NumPy

• max(), devuelve el valor máximo del array, admite el atributo por defecto axis que se refiere al eje, en tal caso devuelve una lista de valores máximos de acuerdo al eje dado p.e. my_array.max(1) devuelve los valores máximos de las columnas
• min(), devuelve el valor mínimo, de manera similar a max admite el atributo axis
• argmax(), devuelve la ubicación del valor máximo, adimite el atributo axis
• argmin(), devuelve la ubicación del valor mpinimo, admite el atributo axis
• ptp(), peak to peak, devuelve el rango del array, valor máximo menos el valor mínimo
• percentile(a), devueleve el percentil a del array
• sort(), ordena el array
• median(), devuelve la mediana del array
• std(), devuelve la desviación estandar
• var(), devuelve la varianza
• mean(), devuelve la media
• concatenate(ar_1,ar_2,axis=0), concatena (une) los arreglos, estos deben tener las mismas dimensiones de acuerdo al eje dado
• T, atributo que devuelve la transpuesta del array

funciones principales de NumPy Vamos a ver cuáles son las funciones que se utilizan normalmente con NumPy cuando analizamos los datos.
________________________________________
[1]
0 s
import numpy as np 
________________________________________
[11]
0 s
arr = np.random.randint(2,40,20)
________________________________________
[14]
0 s
matriz = arr.reshape(2,10)
matriz
array([[ 3, 22, 21, 27, 20, 28, 24, 13, 31,  6],
       [10, 21, 26, 13, 21,  7,  4, 26, 14, 21]])
________________________________________
[15]
1 s
arr
array([ 3, 22, 21, 27, 20, 28, 24, 13, 31,  6, 10, 21, 26, 13, 21,  7,  4,
       26, 14, 21])
________________________________________
[16]
1 s
arr.max()
#la primera funcion principal es (max) con max puedo identificar el numaro mas
#gende que tenga mi array
31
________________________________________
[18]
1 s
matriz
array([[ 3, 22, 21, 27, 20, 28, 24, 13, 31,  6],
       [10, 21, 26, 13, 21,  7,  4, 26, 14, 21]])
________________________________________
[17]
1 s
matriz.max()
31
________________________________________
[ ]

________________________________________
[19]
1 s
matriz.max(0)
array([10, 22, 26, 27, 21, 28, 24, 26, 31, 21])
________________________________________
[21]
0 s
matriz.max(1)
#de esta forma puedo navergar en la matriz de o cualquier estructura dimencional 
#de las diferentes dimensiones de Max 
array ([31, 26])
________________________________________
[22]
matriz.argmax()
#con argmax encontramos el indice, donde se encuentra el valos mas grande 
8
________________________________________
[24]
matriz.argmax(0)
#con mas.argmax nos muetra la posiscion de un array
array([1, 0, 1, 0, 1, 0, 0, 1, 0, 1])
________________________________________
[25]
arr.min()
# con min de devuelve el valor más pequeño del array 
3
________________________________________
[26]
0 s
matriz.min(0)
array([ 3, 21, 21, 13, 20,  7,  4, 13, 14,  6])
________________________________________
[27]
arr.argmin()
#como sabemos con arg podemos mirar la posicion en nuetro array del elemento
#con menos valor 
0
________________________________________
[28]
matriz.argmin(1)
#al igual a nivel matricial podemos saver los indices de nuetro elemento menor 
#valor
array([0, 6])
________________________________________
[29]
0 s
arr
array([ 3, 22, 21, 27, 20, 28, 24, 13, 31,  6, 10, 21, 26, 13, 21,  7,  4,
       26, 14, 21])
________________________________________
[30]
arr.ptp()
#con (ptp), osea del pico mas bajo al mas alto, hay una diferencia de 28, de esta 
#esta manera puedo ver la distribución que tengo en mi array
28
________________________________________
[34]
1 s
matriz.ptp(1)
#esta función es muy útil cuando quiero analizar mis datos 
array([28, 22])
________________________________________
[42]
0 s
arr.sort()
arr
#con (sort), me ordena los números en orden en mi arreglo
array([ 3,  4,  6,  7, 10, 13, 13, 14, 20, 21, 21, 21, 21, 22, 24, 26, 26,
       27, 28, 31])
________________________________________
[37]
0 s
np.percentile(arr,1)
np.percentile(arr,50)
np.percentile(arr,100)
#los amantes de la estadistica esta funcion es muy util, (percentile), con el podemos
#ver el valor que tenemos en la mita, como no tenemos una mitad exata con esta 
#funcion los podemos encontrar.
#ya sea que le demos los valores (1 el mas vajo), (50 mediana), (100 el mas alto)
31.0
________________________________________
[45]
0 s
np.median(arr)
#hay otra operacion de la estadistica se utiliza mucho a nivel de numpy, esta funcion
#me entrega la mediana de un arreglo
21.0
________________________________________
[46]
np.median(matriz,1)

#a nivel matricial
array([11.5, 25. ])
________________________________________
[48]
0 s
np.std(arr)
#con std me muestra la desviación estandar que tengo 
8.324061508662703
________________________________________
[49]
np.var(arr)
#(la desviación estándar es igual a mi variancia)
#aunque en mi caso me dios valores diferentes ambos 
69.28999999999999
________________________________________
[50]
np.mean(arr)
#con (mean), puedo sacar la mediana de los valores de mi array
17.9
________________________________________
[51]
1 s
a = np.array([[4,6],[6,8]])
b = np.array([10,12])
________________________________________
[52]
np.concatenate((a,b),axis=0)
#condo quiero unir ambos arrays (a y b) los hacemos con concatenate, pero en este 
#caso me arrojara un herror, porque no puedo concatenar ambos array
________________________________________
[53]
0 s
a.ndim
b.ndim
1
________________________________________
[57]
b = np.expand_dims(b,axis=0)
#cuando ampliamos las dimenciones podemos hacer una concatenacion simple
________________________________________
[58]
0 s
np.concatenate((a,b),axis=0)
array([[ 4,  6],
       [ 6,  8],
       [10, 12]])
________________________________________
[60]
0 s
np.concatenate((a,b),axis=1)
________________________________________
[61]
np.concatenate((a,b.T),axis=1)
#la (T) mayuscula es la transpuesta de la matris lo que hace la t mayuscula es 
#cambiar la forma
 
 
array([[ 4,  6, 10],
       [ 6,  8, 12]])

Algo que me pareció interesante y no es tan fácil de comprender a la primera, es que si queremos concatenar algo a una columna, debo ordenarlo en forma de fila y viceversa.
Aunque pensándolo gráficamente es muy obvio.

En esta clase se nota que hay bastantes funciones aritmeticas y estadisticas que nos permitiran a mejorar como buenos programadores de machine learning. Es bueno saber esto para no estar perdidos.

Resumen simple de las funciones vistas:
Funcion .max()

Valor de el elemento mayor de un array

Funcion .argmax()

Ubicacion de el mayor elemento de un array

Funcion .min()

Valor de el elemento menor de un array

Funcion .argmin()

Ubicacion de el mayor elemento de un array

Funcion .ptp()

Diferencia entre el mayor y el menor elemento de un array

Funcion .percentile()

Nos devuelve el percentile de un array

Funcion .median()

Nos devuelve la mediana de un array

Funcion .std()

Nos devuelve la desviacion estandart de un array

Funcion .mean()

Nos devuelve la media de un array

Funcion .var()

Nos devuelve la varianza de un array

Funcion .T (Transpuesta)

Invierte un array o matriz

✅

Creo que al ser max(0) para columnas y max(1) para filas, esto tiende a confundir un poco con relacion al los ejes de las dimensiones en los tensores. Pero supongo que con retencion del aprendizaje y la practica, eso no sera problema.

import numpy as np

arr=np.random.randint(5,50, (4,3))

arr.shape

arr.reshape(1,12)

arr.reshape(6,2)
arr.reshape(2,6)

Código de la clase un poco mas minucioso para entender el comportamiento de la matriz con las diferentes funciones

https://colab.research.google.com/drive/1_K1hObdB0SZdE2YozU9bIQvvei7XPapU?usp=sharing

np.percentile(arr,50)
Resultado de esta operación:
10.5

Este fue nuestro array --> array([14, 1, 5, 7, 13, 11, 13, 8, 10, 13])

Fórmula para calcular la posición del percentil 50

Fórmula de las posiciones
n.k/100
k= subíndice --> 50 si es para calcular el percentil 50, 25 (percentil 25), 75 (percentil 75), etc.
n= cantidad de datos de nuestro array
= 5 --> resultado de la operación

10 (n) x 50 (k) / 100 = 5 --> posición inicial para tomar en cuenta --> Tomamos la posición 5 y 6 del array pero deben estar ordenados de menor a mayor

Una vez nos dé el resultado, en este caso es la posición 5, hacemos el promedio de la posición 5 y posición 6, que en nuestro array es 10 (posición 5), y 11 (posición 6) —> 10+ 11 = 21 / 2 = 10.5

Para calcular el percentil, aunque Numpy lo hace de manera automática, ordenamos los datos para tener una mejor perspectiva
arr.sort()
array([ 1, 5, 7, 8, 10, 11, 13, 13, 13, 14])
Acá sí podemos ver que es el promedio de 10 y 11 = 10.5

Con dos filas y dos columnas Transpuse en x

Con tres filas y tres columnas transpuse en z y x

7. Funciones principales de NumPy

import numpy as np

arr = np.random.randint(1,20,10)

matriz = arr.reshape(2,5)
matriz

arr.max() # trae el número mas grande de nuestro array

matriz

matriz.max(0) # mayor número por filas, se puede especificar el eje

arr.argmax() # indice del valor más grande de nuestro array

matriz.argmax(0)

arr.min() # devuelve el menor valor del array

matriz.min(0)

arr.argmin()

matriz.argmin(1)

arr.ptp() # peak to peak resto entre el máximo array y el mínimo

matriz.ptp(0)

np.percentile(arr,50)  # devuelve el percentil que quiera del array

arr.sort() # ordena de menor a mayor mi array
arr

np.median(arr) # mediana

np.median(matriz,0)

np.std(arr) # desviación estándar

np.var(arr) # varianza

np.mean(arr) # media

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

np.concatenate((a,b),axis=0)

a.ndim
b.ndim

b=np.expand_dims(b,axis=0) # expande la dimensión del array

np.concatenate((a,b),axis=0) # concatena dos arrays

np.concatenate((a,b),axis=1)

np.concatenate((a,b.T),axis=1) #T transpuesta de una matriz

b.T

concatenate

b = np.array([7,8,9]
c = np.array([[1,2,3],[4,5,6],[10,11,12]])

np.concatenate((c,b.T), axis=1)

En la documentación de Numpy encontré que existe una combinación entre C y Python llamada Cython 😮
Putting the Inner Loop in Cython

Cree una función que hace lo mismo que ptp:

def ptpm(arr):
  arrmax = arr.max()
  arrmin = arr.min()
  result = arrmax - arrmin
  return result

https://www.youtube.com/watch?v=Mqiqdys6YFE

Hola!
He convetido un tensor de dimensiones 3x3x4x5

my_tensor = np.random.rand(3,3,4,5)

En uno de dimensiones 9x20

np.reshape(my_tensor,(9,20))

Me quedo clarito, clarito lo de la traspuesta, claro primero regrese a secundaria…

b = np.expand_dims(b, axis = 0)

np.concatenate((a,b), axis = 0)

array([[1, 2],
[3, 4],
[4, 6]])

np.concatenate((a, b.T), axis = 1)

https://numpy.org/doc/stable/reference/routines.statistics.html?highlight=statistic

Funciones principales de NumP

En las notas de los recursos de la clase hay un error en .argmax() debido a que el índice donde se encuentra el valor mayor es cero y no nueve.

Aqeui dejo mis apuntes de la clase: Aqui

Lo bueno de este curso es que arma los verdaderos cimientos para la escuela de matemáticas con Python en Data Science.