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)
	 ^______________^

Ojo, Hay que diferenciar el producto punto y la multiplicación entre matrices.
El producto punto se da entre vectores y el resultado es un número, por ejemplo,
[1,2,3] \cdot [3,4,5]=1(3)+2(4)+3(5)=26

y otra es la multiplicación entre matrices que da como resultado otra matriz y se realiza como lo describen en el vídeo.

Otra forma de hacer producto punto:

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

Algo interesante es que con NumPy también podemos escribir funciones trigonométricas como seno y coseno con np.cos() y np.sin(). Es de notar que los valores que toma numpy para estas funciones son en radianes. Así mismo nos da la capacidad de escribir el número pi con np.pi.

Dejo dos formas mas en las que tmb se puede hacer el producto punto con Numpy:

matriz.dot(matriz2.T) 

np.dot(matriz,matriz2.T)

Información resumida de esta clase
#EstudiantesDePlatzi

• Es importante realizar las operaciones que deseemos desde las funcionalidades de Numpy, es decir, una lista normal en Python se comporta diferente a un array de Numpy cuando realizamos operaciones

• Existen muchísimas operaciones matemáticas que podemos hacer con nuestros arreglos, debemos practicar

• El producto punto es una operación muy usada en la ciencia de datos

Mi resumen #11 (Notion + Notas de Cornell)

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

Aunque hagan [a*2 for a in lista] para multiplicar cada uno de los elementos de la lista, es muy ineficiente ya que es uno por uno. NumPy lo hace de forma paralela.

NumPy nos ofrece un sin fin de herramientas de operaciones en algebra, aritmética y mucho más
________________________________________
[2]
0 s
import numpy as np
________________________________________
[1]
1 s
list = [1,2,3,4,5,6,7,8,9,0]
list
[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
________________________________________
[6]
list * 2
#esto es poco eficiente para la ciencia de datos 
[1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
________________________________________
[4]
0 s
arr = np.arange(0,20)
arr2 = arr.copy()
________________________________________
operaciones
________________________________________
[5]
0 s
arr
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
       17, 18, 19])
________________________________________
[7]
arr * 2
#aplicando desde numpy o objectos púedo hacer operaciones sencillas o muy complejas
#y va hacer muy rápido y eficiente 
array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32,
       34, 36, 38])
________________________________________
[8]
arr + 4
#tambien podemos hacer sumas así de fácil con NumPy 
array([ 4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
       21, 22, 23])
________________________________________
[9]
2 / arr
#aca nos da error al principio porque dividir entre cero no se puede 
#pero es muy competente a la hora de realizar operaciones 
/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, 2.        , 1.        , 0.66666667, 0.5       ,
       0.4       , 0.33333333, 0.28571429, 0.25      , 0.22222222,
       0.2       , 0.18181818, 0.16666667, 0.15384615, 0.14285714,
       0.13333333, 0.125     , 0.11764706, 0.11111111, 0.10526316])
________________________________________
[13]
arr ** 5
#asi de rápido puedo potencializar mi array
array([      0,       1,      32,     243,    1024,    3125,    7776,
         16807,   32768,   59049,  100000,  161051,  248832,  371293,
        537824,  759375, 1048576, 1419857, 1889568, 2476099])
________________________________________
[16]
0 s
arr + arr2
print(arr + arr2)
#tambien puedo sumar ambos array
print("esto nos funciona con cualquier operacion aritmetica que hagamos ")
[ 0  2  4  6  8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38]
esto nos funciona con cualquier operacion aritmetica que hagamos 
________________________________________
[19]
matriz = arr.reshape(2,10)
matriz2 = matriz.copy()
#aca estamos declarando las matrices con la que queremos trabajara aracmeticamente
________________________________________
[20]
matriz + matriz2
#depues de declarar las matrices las puedo sumar 
array([[ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18],
       [20, 22, 24, 26, 28, 30, 32, 34, 36, 38]])
________________________________________
[33]
1 s
matriz2 + matriz ** 3 
array([[   0,    2,   10,   30,   68,  130,  222,  350,  520,  738],
       [1010, 1342, 1740, 2210, 2758, 3390, 4112, 4930, 5850, 6878]])
________________________________________
[35]
0 s
matriz ^ 2
print(matriz ^ 2)
print("super trabajar con operaciones jejejej ")
[[ 2  3  0  1  6  7  4  5 10 11]
 [ 8  9 14 15 12 13 18 19 16 17]]
super trabajar con operaciones jejejej 
________________________________________
[24]
matriz - matriz2
# también las puedo restar 
#y todas las apariciones aritméticas que quiera 
array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])
________________________________________
[28]
0 s
matriz2.T
#trabajando con la transpuesta en el punto
array([[ 0, 10],
       [ 1, 11],
       [ 2, 12],
       [ 3, 13],
       [ 4, 14],
       [ 5, 15],
       [ 6, 16],
       [ 7, 17],
       [ 8, 18],
       [ 9, 19]])
________________________________________
[27]
np.matmul(matriz,matriz2.T)
#para los amante del algebra podemos resolver con el producto punto (.)
#para resulver el producto punto debemos trabajar con la traspuesta(T)
#como ya sabemos esto es muy util en el mundo de la ciencia de datos 
array([[ 285,  735],
       [ 735, 2185]])
________________________________________
[30]
0 s
matriz @  matriz2.T
#otra forma de operar array de producto punto es con (@)
array([[ 285,  735],
       [ 735, 2185]])
________________________________________
[23]
matriz + matriz2 * 2 / 5
# en esta linae mezcle algunas operaciones, podemos tranajar y mezclar muchas operaciones
#aritmeticas 
 
 
array([[ 0. ,  1.4,  2.8,  4.2,  5.6,  7. ,  8.4,  9.8, 11.2, 12.6],
       [14. , 15.4, 16.8, 18.2, 19.6, 21. , 22.4, 23.8, 25.2, 26.6]])
________________________________________
con estas operaciones ya se trabajar cualquier operación aritmética con NumPy

Producto punto es distinto de multiplicación de matrices

Aunque Numpy los maneje de manera similar con:

• .dot() => dot product
• .matmul() => matrix multiplication

El Producto punto de dos vectores será un numero escalar y se hará de la siguiente manera:
Teniendo los vectores U = (X1,Y1,Z1) y V = (X2,Y2,Z2)
El producto punto es U.V y sería igual a = X1.X2 + Y1.Y2 + Z1.Z2 = K

Estudie derecho porque no tenía o tenían pocas matemáticas. No sé cómo termine aquí

Otra forma de realizar el producto punto

matriz.dot(matriz2.T)

Me parecio muy interesante el uso de la multiplicacion de las matrices. Si que aprendi mucho con respecto a este tema. Espero seguir aprendiendo ahora con pandas.

El cuadrado de los resultados del producto matricial

<
import numpy as np
matriz = np.random.rand(4,4)
matriz2 = matriz.copy()
np.sqrt(matriz @ matriz2.T)
> 

✅

Esto me recuerda a la casa: ‘lea el pdf joven’

Tambien se pueden hacer operaciones con string, lo cual me parecio interesante

Para los que ya vienen de cursos de python, hacer esto

arr2 = np.arange(1,11)
arr2 * 2

es lo mismo que hacer esto en python

lista = [1,2,3,4,5,6,7,8,9,10]
newList = []
for i in lista:
  i = i *2 
  newList.append(i)
print(newList)
  

Operaciones Internas del Producto Punto
A continuación muestro cómo es el cálculo elemento a elemento de lo que representa el producto punto o producto escalar, que en este caso específico podría también ser llamado como producto interno; ya que se efectúa entre dos matrices de dimensiones n x m. Este es un tema del que se podría escribir una publicación para profundizar en cómo funciona esta operación y de la que personalmente, todavía hay algunos conceptos que no conozco.

Las matrices empleadas para las operaciones fueron:

matriz --> array([[0,1,2,3,4],[5,6,7,8,9]])

matriz2.T--> array([0 , 5],
                   [1 , 6], 
                   [2 , 7],
                   [3 , 8],
                   [4 , 9],

elemento1=matriz[0,0]*matriz2.T[0,0]+matriz[0,1]*matriz2.T[1,0]+matriz[0,2]*matriz2.T[2,0]+matriz[0,3]*matriz2.T[3,0]+matriz[0,4]*matriz2.T[4,0]

elemento1 --> 30 

elemento2=matriz[0,0]*matriz2.T[0,1]+matriz[0,1]*matriz2.T[1,1]+matriz[0,2]*matriz2.T[2,1]+matriz[0,3]*matriz2.T[3,1]+matriz[0,4]*matriz2.T[4,1]

elemento2 --> 80 

elemento3=matriz[1,0]*matriz2.T[0,0]+matriz[1,1]*matriz2.T[1,0]+matriz[1,2]*matriz2.T[2,0]+matriz[1,3]*matriz2.T[3,0]+matriz[1,4]*matriz2.T[4,0]

elemento3 --> 80 

elemento4=matriz[1,0]*matriz2.T[0,1]+matriz[1,1]*matriz2.T[1,1]+matriz[1,2]*matriz2.T[2,1]+matriz[1,3]*matriz2.T[3,1]+matriz[1,4]*matriz2.T[4,1]

elemento4 -->255

Al tener estos elementos podemos crear el vector respuesta de la operación:

pdot=[[elemento1,elemento2],[elemento3,elemento4]]
pdot --> array([[30,80],[80,255]])

Para poner en práctica encontré estos 101 ejercicios con numpy.
https://www.machinelearningplus.com/python/101-numpy-exercises-python/

Numpy está potente!!

Para entender visualmente mejor lo que el profe estaba explicando

Doy crédito a David Osorio que usó esta forma de visualizar la operación entre matrices

Matriz A            Matriz B
	(2 x  5)      (5 x 2) 
		    ^ _______^

El resultado de la operación será los datos de los extremos, es decir una matriz de 2 X 2

Para ver otro ejemplo hice lo siguiente:

matriz_3 = np.random.randint(1,100,(5,4))
Resultado de matriz_3:
array([[22, 58, 32, 92],
[43, 90, 6, 52],
[28, 59, 41, 39],
[85, 54, 55, 69],
[12, 45, 70, 5]])

matriz_4 = np.random.randint(1,100,(5,4)):
array([[68, 11, 70, 15],
[61, 88, 98, 91],
[23, 56, 79, 14],
[50, 43, 71, 66],
[27, 17, 62, 61]])

Para poder operar ambas necesitamos transponer la segunda matriz si vamos a hacer la operación matriz_3 . matriz_4

matriz_3           matriz_4
	(5 x  4)      (4 x 5) 
		    ^ _______^

La matriz resultante será de 5 x 5 (los datos de los extremos).

np.matmul(matriz_3,matriz_4.T)
Resultado de np.matmul(matriz_3,matriz_4.T):

array
([[ 5754, 17954, 7570, 11938, 9176],
[ 5114, 15863, 7231, 9878, 6235],
[ 6008, 14467, 7733, 9422, 6680],
[11259, 21606, 10290, 15031, 10832],
[ 6286, 12007, 8396, 7835, 5734]])

10. Operaciones

import numpy as np

lista=[1,2]
lista

lista*2 # sin implementar numpy

arr=np.arange(0,11)  # implementando numpy
arr

arr2=arr.copy()

Operaciones

arr+2

1/arr

arr*2

arr+arr2

arr*arr2

arr*arr2

matrix = arr.reshape(2,5)
matrix2 = matrix.copy
matrix

matrix + matrix2

matrix2.T # transpuesta

np.matmul(matrix,matrix2.T) # producto punto

matrix @ matrix2.T # otra forma de hacer el prpoducto punto

A parte de usar np.matmul() también podemos usar .dot para calcular el producto interno:

matriz_1.dot(matriz_2)

Lo siguiente quizás es un poco obvio, pero para mi en un principio no lo fue: Es importante no confundir la multiplicación entre matrices y al calcular el producto interno entre ellas.

• En la primera estaríamos operando entre valores ubicados en la misma posición de índice.
  • es decir matriz_1(1,1) * matriz_2(1,1), así:

• En la segunda (producto interno) hacemos la siguiente operación:

• dadas las matrices con shape (2,3) y (2,3).T = (3,2) obtenemos una matriz (2,2).
  • A diferencia del producto interno entre vectores, donde obtenemos un escalar

Para hacer el producto cruz tendriamos:
np.cross(x, y)

Que buena introducción a las operaciones, y muy curioso el producto punto.

Más funciones matemáticas

En Numpy existen un montón de funciones matemáticas. Aquí dejo algunas:

• Álgebra lineal
• Funciones matemáticas
• Más funciones mateméticas
• Estadística
• Matrices
• Polinomios

Y hay muchas más 🤓

A las listas se le pueden hacer operaciones haciendo list comprenhension o lambdas:

list = [i*2 for i in list]
list

matriz2.T

array([[0, 5],
[1, 6],
[2, 7],
[3, 8],
[4, 9]])

¡Qué grande es Python/NumPy: no solo no arroja error al intentar dividir entre cero y detiene la ejecución, sino que da la respuesta correcta (infinito) y sigue adelante! 🤯💪

con el uso de arrays y algo de estadistica llegue a la conclusion que:
Bmco = (x’x)^(-1) x’y* el cual es MELI, y consistente

PROBLEMATICA A RESOLVER

list = [1,2]
print(list)
#multiplicar x2 los elementos de la lista
test = list*2
print(test)#aquí python dupplica la lista pero no los elementos que la forman

arr = np.arange(0,10)
print(arr)
arr2 = arr.copy() #hacemos una copia y la guardamos en otra variable distinta
print(arr2)

OPERACIONES

print(arr2)
print(arr2 * 2) #multiplica x2 cada uno de los valores del array
#vemos la diferencia entre una "lista" y un "array"
print(arr2 + 2)
print(1/arr2) #al dividir el valor del array 0, me da error, pero sigue dandome el resto del resultado
print(arr2 ** 2)```

OPERACIONES CON ARRAYS

#operaciones dentro de los arrays
print(arr)
print(arr2)
print(arr + arr2)
print(arr * arr2)
print(arr / arr2)

OPERACIONES CON MATRICES

#operaciones con matrices
matrix = arr.reshape(2,5)
print(matrix)
matrix2 = matrix.copy()
print(matrix2)
print(matrix + matrix2)#suma cada uno de los elementos que tiene la matriz
print(matrix - matrix2)
print(np.matmul(matrix, matrix2.T)) #los valores ubicados en las filas deben hacer match con los ubicados en las columnas. Por eso utilizamos la matriz transpuesta.
print(matrix)
print(matrix2.T)
#producto punto solo se puede operar si la dimension de las columnas de la matrizA es = a las filas de la matrizB
print(matrix @ matrix2.T) #otra manera de realizar la operacion de prodcuto. 
#la matriz resultante = dimensiones no utilizadas (filas de la primera y columnas de la segunda). En este caso 2x2

Si quieren aplicar una operación a una fracción de un array pueden hacer lo siguiente:

arr = np.arange(0,10)
arr_2 = arr.copy()
#array generado
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
#Ahora, supón que quieres sumar 200 a los valores menores a 5
arr_2[(arr_2 < 5)] += 200
#salida
array([200, 201, 202, 203, 204,   5,   6,   7,   8,   9])

My challenge:

yo pondria mas retos uno que se me ocurrio es hacer la tabla del 8

Para hacer una multiplicación en Python sin numpy puedes usar la función map()

lista = [1,2]
lista_multiplicada = list(map(lambda valor: valor*2, lista))
print(lista_multiplicada) # output: [2, 4]

21 natriz- matriz
1 natriz2 t
1 np matmul (matriz matriz2)
1 matriz@ matriz t

import numpy as np
1 lista= (1,2)

2 lista
1 lista
1arr=np arange ( co, 10)
2 arr 2 arr copy
Operaciones
1 arr *2
(arry(0,2, 4, 6, 8, 12 , 14, 18,)
12 1 arr+ arr2
++ arr *2
1 nstriz= arr reshape(2,5)
2 matrIiz copy

Operaciones entre matrices

Cuando realizamos la suma y la resta entre matrices en Numpy se respeta la forma en la que se tiene que resolver, en cambio cuando hablamos de la multiplicación y la potenciación entre estas, no se cumple el procedimiento adecuado.

#Numpy
#Tenemos dos matrices que vamos a mutiplicar a continuación:
A = np.array( [[1, 2, 3], [4, 5, 6], [7, 8, 9]])
B = np.array([9, 8, 7], [6, 5,4], [3, 2, 1]]

#Producto:
#Lo que en realidad va a hacer Numpy es multiplicar cada fila de la matriz A con cada una de la matriz B.
#Por esto da el siguente resultado:
array([[1*9, 2*8, 3*7],
       [4*6, 5*5, 6*4],
       [7*3, 8*2, 9*1]]
#-->array([[ 9, 16, 21],
      # 	[24, 25, 24],
      # 	[21, 16,  9]])
----------------------------------
#Potencia
#Cuando una matriz está elevada  a la n (any number) , lo que Numpy hace es elevar en este potencia a todos los elementos de la matriz.
#A**2
[[1**2, 2**2, 3**2],				
  [4**2, 5**2, 6**2],				 			
  [7**2, 8**2, 9**2]]	
#-->array([[ 1,  4,  9],
    #   [16, 25, 36],
     #  [49, 64, 81]])

"Según la álgebra lineal"
#Para multiplicar 2 matrices se debe emplear el producto punto y se debe respetar la siguiente regla: las columnas de la matriz A deben ser igual  a las filas de la matris B.

A = [aij]mxq | B=[bij]qxn														

# a or b = elementos de la matriz |  i = eje X (fila) & j = eje Y (columna)	| mxq or qxn (dimensión: filas x columnas)

# Y las dimensiones del resultado final serían las filas de la matriz A (m)  con las columnas de la matriz B (n): mxn

#Producto de A y B
#Para poder realizar esta operación Numpy nos ofrece dos opciones :
#1) np.matmul()
answer = np.matmul(A, B)
answer #array([[ 30,  24,  18],
       					# [ 84,  69,  54],
       					# [138, 114,  90]])

#2) @
A@B 
# array([[ 30,  24,  18],
       # [ 84,  69,  54],
      #  [138, 114,  90]])

Procedimiento:

#Potencias de matrices:
# Para elevar una matriz a una potencia n (any number) se debe hacer de la siguiente manera:

A**2 = A*A  #Debemos aplicar producto punto: np.matmul(A, A) or A@A
#array([[ 30,  36,  42],
      # [ 66,  81,  96],
      # [102, 126, 150]])

A**4 = (A*A)*(A*A) #Aplicamos => np.matmul(A, A) @ np.matmul(A*A)
#array([[ 7560,  9288, 11016],
    #   [17118, 21033, 24948],
     #  [26676, 32778, 38880]])

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