Operaciones

Una operación muy interesante que encontré es la llamada “unique”, con esta operación quitaremos los valores repetidos de nuestro array. Lo mas increíble es que se pueden hacer algunas operaciones extras como lo es “Sabes cuantas veces se repiten dichos datos” (Hay varias operaciones extras que puede retornar).

Algo que debe quedar claro con las operaciones matemáticas es que Python no puede resolver directamente al operar un vector o matriz por un escalar. Internamente Python usa algo llamado Broadcasting.

Es importante que esto quede claro, quizá no todos los lenguajes de programación soporten esto.

Pero que es el broadcasting: Cuando se hace una operación básica con vectores o matrices, por regla, abos objetos deben tener la misma dimensión, es decir, si tenemos un vector de 5 elementos, y a cada elemento queremos sumar 2, originalmente deberiamos hacer los siguiente:

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

sumar_2 = np.array([2,2,2,2,2)]

vetor_+_2 = vector + sumar_2

Con esta configuración cumplimos que ambos vectores deben tener la misma dimensión.

Pero, al usar numpy, no solemos hacer eso, usamos algo como sigue:

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

vetor_+_2 = vector + 2

Aquí es donde entra la mágia del broadcasting, internamente, numpy y python lo que hacen es crear el vector sumar_2 = np.array([2,2,2,2,2)] sin que el usuario se de cuenta, para así poder efectura la operación.

El mismo proceso sucede con las matrices. Para efectuar operaciones con sus elementos debemos de tener las mismas dimensiones en ambas matrices.

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

sumar_2 = np.array([[2,2],
                   [2,2]])

matriz_+_2 = matriz + sumar_2

Está claro que la anterior operación se realiza de manera sencilla solo con la operación matriz += 2 gracias al broadcasting.

Aquí un video

🔣Operaciones

Existen diferentes operaciones que se pueden usar para los arrays de NumPy.

lista = [1,2]
lista ----> [1, 2]

Una lista de Python entiende que quieres duplicar los datos. Cosa que no buscamos.

lista * 2 ----> [1, 2, 1, 2]
arr = np.arange(0,10)
arr2 = arr.copy()
arr ----> array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

Ahora multiplicamos por un escalar:

arr * 2 ----> array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])

Operación suma de escalar:

arr + 2 ----> array([ 2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

División con un escalar
Como en este caso la primera posición del array es 0, muestra un error pero no detiene el proceso.

1/arr
/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:1: RuntimeWarning: divide by zero encountered in true_divide
  """Entry point for launching an IPython kernel.
array([       inf, 1.        , 0.5       , 0.33333333, 0.25      ,
       0.2       , 0.16666667, 0.14285714, 0.125     , 0.11111111])

Elevar a un escalar:

arr**2 ----> array([ 0,  1,  4,  9, 16, 25, 36, 49, 64, 81])

Sumar dos arrays de igual dimensiones las hace elemento por elemento:

arr + arr2 ----> array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])

Lo mismo aplica para matrices.

matriz = arr.reshape(2,5)
matriz2 = matriz.copy()
matriz
----> array([[0, 1, 2, 3, 4],
      	 [5, 6, 7, 8, 9]])
matriz - matriz2
----> array([[0, 0, 0, 0, 0],
      	 [0, 0, 0, 0, 0]])

Una operación importante es la de punto por punto, aquí dos formas de hacerla:

np.matmul(matriz, matriz2.T)
----> array([[ 30,  80],
      	 [ 80, 255]])
matriz @ matriz2.T
----> array([[ 30,  80],
       [ 80, 255]])

Para entender por qué se debe utilizar la transpuesta, es importante recordar que el producto punto de dos matrices solo se puede operar si la dimensión de las columnas de la primera es igual a la de las filas de la segunda.

En el ejemplo :

	(2 x  5)      (5 x 2) 
		    ^ _______^

Otro dato es que la matriz resultante queda con dimensiones de las dimensiones que no se usaron, o sea con las filas de la primera y las columnas de la segunda.

Por esto la matriz queda de 2x2.

	(2 x 5)    (5 x 2)
	 ^______________^

Redimensionar matrices a una dimensión haciendo una copia o referencia a la matriz original.
Las funciones flatten() y ravel() redimensionar una matriz a una dimensión.
La diferencia entre ambas es que los elementos de vector resultante con el método ravel() son referencia de los elementos de la matriz original y en flatten() no.
El método ravel() es más eficiente en el uso de memoria (más cuando la matrices son de gran tamaño).
Pero como se comentó antes sino se quiere modificar la matriz original: induce a error.

import numpy as np
# MATRIZ 3D 3x3x3 INT 64
matriz3x3x3 = 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]]])
matriz3x3x3

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]]])

Las funciones flatten() y ravel() redimensionar una matriz a una dimensión.

arrflatten = matriz3x3x3.flatten()
arrravel = matriz3x3x3.ravel()
arrflatten,arrravel

(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]),
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]))

Los elementos del vector flatten son copia de los elementos originales de la matriz.

arrflatten[0] = 99
print (arrflatten)
matriz3x3x3

[99 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]

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]]])

Los elementos del vector ravel son una referencia a los elementos originales de la matriz.

arrravel[0] = 99
print (arrravel)
matriz3x3x3

[99 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]

array([[[99, 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]]])

Otra forma de hacer producto punto:

Como algunos ya comentaron, se puede hacer con la función np.dot(), pero también puede ser después del primer array en la multiplicación. Como ser ve en el siguiente ejemplo.
*Recordar que el orden de las matrices sí importa en la mayoría de los casos *

matriz = np.array([[1,2],[3,4]])
matriz2 = matriz.copy()
print(np.matmul(matriz,matriz2.T)==matriz.dot(matriz2.T))
->>>> 
[[ True  True]
 [ True  True]]

My challenge:

Este vídeo explica bien la multiplicación de matrices
https://www.khanacademy.org/math/precalculus/x9e81a4f98389efdf:matrices/x9e81a4f98389efdf:multiplying-matrices-by-matrices/v/multiplying-a-matrix-by-a-matrix