Producto interno entre dos matrices

Los valores son:

• 1x2+2x5+3x11= 45
• 1x3+2x7+3x13=56
• 4x2+5x5+6x11=99
• 4x3+5x7+9x11=125
• 7x2+8x5+9x11=153
• 7x3+8x7+9x13=194
• 10x2+11x5+12x11=207
• 10x3+11x7+12x13=263

[[ 45  56]
 [ 99 125]
 [153 194]
 [207 263]]

Producto interno entre dos matrices
Para que dos matrices puedan ser tener un producto interno el número de columnas del primero debe ser igual al número de filas del segundo.
Posteriormente realiza un producto interno entre los vectores fila de la primera matriz con los vectores columna de la segunda matriz generando un nueva matriz que tendrá las dimensiones del número de filas de la primera matriz y el número de columnas de la segunda matriz

Si quieren entender el porqué del producto interno, hay una serie de videos de álgebra lineal de 3Blue1Brown Español que explica muy bien su relacion con las transformaciones lineales. Dejo el link de la playlist y del video de producto de matrices en particular (que es sobre lo que trata esta clase). Espero les sirva 😄
Playlist “Esencia del Álgebra Lineal”: https://www.youtube.com/watch?v=0Ndnzx6AyaA&list=PLIb_io8a5NB2DddFf-PwvZDCOUNT1GZoA
"Transformaciones lineales y matrices": https://www.youtube.com/watch?v=YJfS4_m_0Z8&list=PLIb_io8a5NB2DddFf-PwvZDCOUNT1GZoA&index=4

import numpy as np
a = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
print(a)
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
b = np.array([[1, 2], [3, 4], [5, 6]])
print(b)
[[1 2]
 [3 4]
 [5 6]]
print(a.dot(b))
[[ 22  28]
 [ 49  64]
 [ 76 100]
 [103 136]]
res = np.array([
       [(1 * 1) + (2 * 3) + (3 * 5), (1 * 2) + (2 * 4) + (3 * 6)],
       [(4 * 1) + (5 * 3) + (6 * 5), (4 * 2) + (5 * 4) + (6 * 6)],
       [(7 * 1) + (8 * 3) + (9 * 5), (7 * 2) + (8 * 4) + (9 * 6)],
       [(10 * 1) + (11 * 3) + (12 * 5), (10 * 2) + (11 * 4) + (12 * 6)]
       ])
print(res)
[[ 22  28]
 [ 49  64]
 [ 76 100]
 [103 136]]

Genial, empiezo a recordar mis clases de algebra en la universidad!

¿Se puede mejorar el algoritmo de multiplicación de matrices?

Respuesta Corta: Si
Respuesta Larga: La AI de DeepMind lo logra y es tema de portada Octubre 2022 revista Nature
Dejo enlace del artículo aquí

Razones para usar pycharm:
Visualización de matrices (:

https://www.youtube.com/watch?v=kjBOesZCoqc&index=1&list=PLZHQObOWTQDPD3MizzM2xVFitgF8hE_ab

Este canal es buenísimo para aprender algebra y entender el porque de los cálculos. Tiene la mayoría subtitulado al español, aunque vale la pena verlo en inglés 😉

Solo dire que… aqui el orden los factores si altera el producto. ó da error XD

Para los que no quieren escribir las matrices, les dejo mi aporte.

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

Atentos, las columnas de el primer elemento en este caso A debe ser igual que las filas del segundo elemento en este caso B

El producto interno entre matrices es para quienes ya han visto un curso de álgebra lineal el producto usual entre matrices.

Producto interno entre dos matrices

• Sea A una matriz (mxn)
• y B una matriz (pxq)
• C = A·B está definido si n = p y C es una matriz (mxq)

• Para que el producto interno de dos matrices pueda ser calculado se debe cumplir la siguiente condición: dadas las dimensiones de la matrices 4x3 y 3x2 , la cantidad de columnas de la primer matriz debe ser igual a la cantidad de filas de la segunda matrix. Así el producto interno entre las matrices (4x3 ).dot(3x2) es posible pero el producto interno de las matrices en el siguiente orden: (3x2 ).dot(4x3) no es posible.

Producto interno entre dos matrices

Supongamos que tenemos dos matrices a las cuales les queremos aplicar el producto interno la una con la otra, pero el problema es que estas matrices no tienen las mismas dimensiones.

import numpy as np

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

print(A.shape) # Output = (4, 3)
print(B.shape) # Output = (3, 2)

Ahora vamos a intentar sacar su producto interno respectivamente:

# Esta operación es posible
C = A.dot(B)

# Esta operación NO es posible
D = B.dot(A)

print(C) # Output = [[45  54] [99 120] [153 186] [207 252]]

¿Por qué podemos resolver los problemas de A.dot(B), pero no los de B.dot(A)? ¿Qué causa esta diferencia?

La respuesta se encuentra en las dimensiones de las matrices. En el primer caso, estamos calculando el producto de matrices A y B. Observemos que A tiene dimensiones (4, 3) y B tiene dimensiones (3, 2). Notamos que en este orden, las matrices tienen una dimensión en común, que es 3.

En el caso contrario, cuando intentamos calcular B.dot(A), estamos tratando de realizar el producto en una dimensión más pequeña de la que deseamos calcular, lo cual no es posible.

En resumen, la razón por la que la primera operación es válida es porque estamos calculando el producto en función de una dimensión más grande que la que deseamos obtener. Sin embargo, en el caso contrario, no es posible porque no tenemos suficientes datos para realizar el cálculo.

Ahora, ¿Por que nos da ese resultado? Cuando calculamos A.dot(B), estamos multiplicando cada fila de la matriz A por cada columna de la matriz B, lo que resulta en una nueva matriz C. Cada valor en la matriz C se obtiene sumando los productos de los elementos correspondientes de la fila en A y la columna en B.

Por ejemplo, el valor en la fila 1 de A (4, 5, 6) multiplicado por la columna 1 de B (2, 5, 11) da como resultado 45, y así sucesivamente para los demás valores. Por eso, C tiene la forma (4, 2) y contiene los valores [[45, 54], [99, 120], [153, 186], [207, 252]].

En resumen, A.dot(B) funciona porque la multiplicación de matrices se realiza en dimensiones que tienen una dimensión en común, generando una nueva matriz con resultados calculados.

Unos apuntes que tengo:

Me costo mucho entender el tema.

😵‍💫 Este grafico me ayudo a visualizar mejor:

Suma de las multiplicaciones de los elementos de las Filas de A y las Columnas de B

• El producto interno entre dos matrices es una operación muy común en álgebra lineal, también conocida como producto matriz-matriz. En Python, podemos realizar esta operación utilizando la librería NumPy y la función dot().

import numpy as np

# Creamos una matriz de 2x3
A = np.array([[1, 2, 3], [4, 5, 6]])

# Creamos otra matriz de 3x2
B = np.array([[7, 8], [9, 10], [11, 12]])

# Calculamos el producto interno entre A y B
C = np.dot(A, B)

print(C)
# resultado: [[ 58  64]
#             [139 154]]

A = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16],[17,18,19,20]])
B = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
print(A)
print(B)
print(A.shape)
print(B.shape)
print(C)

Puede hacerse también con un script de python que lo hace visualmente!

Comparto el código a quien le interese

def miPropioDot(A,B):
    suma = 0
    sumaElementos = 0
    nuevaMatriz = np.zeros((A.shape[0],B.shape[1]),dtype=int)
    for i in range(A.shape[0]):
        for k in range(B.shape[1]):
            sumaElementos = 0
            for p in range(B.shape[0]):
                sumaElementos += A[i][p] * B[p][k]
                print(f'[{A[i][p]}]*[{B[p][k]}] = {A[i][p] * B[p][k]}')
            suma+=sumaElementos
            print(f'Suma {sumaElementos} | Total = {suma}\r\n')
            nuevaMatriz[i][k] = sumaElementos
    return nuevaMatriz
print(f'La nueva matriz es\n {miPropioDot(A,B)}')

Se puede hacer a mano, o se puede hacer con ciclo for:

***** Producto Punto Componente a componente*****

i=0
j=0
k=0
m=0

A=np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
B=np.array([[2,3],[5,7],[11,13]])
print(“Matriz A = \n {} \nMatriz B = \n {}”.format(A,B))
print("\n")

print("Producto Punto Componente a componente\n ")

for k in range(0,A.shape[0]):
for m in range(0,B.shape[1]):
aux=0
for j in range(0,A.shape[1]):
aux=A[k][j]*B[j][m]+aux
aux2=A[k][j]*B[j][m]
print(“Resultado: A{}*B{} = {}”.format((k,j),(j,m),aux2))
print(“k={},j={},m={}, Acum = {}\n”.format(k,j,m,aux))
D[k][m]=aux
D

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

c = a * b[:,0]
print(c)
[[ 1  6 15]
 [ 4 15 30]
 [ 7 24 45]
 [10 33 60]]

d = a * b[:,1]
print(d)
[[ 2  8 18]
 [ 8 20 36]
 [14 32 54]
 [20 44 72]]

C = c[:,0] + c[:,1] + c[:,2]
print(C)
[ 22  49  76 103]

D = d[:,0] + d[:,1] + d[:,2]

e = np.array([C, D])
print(e)
[[ 22  49  76 103]
 [ 28  64 100 136]]

e = e.T

> 

Bueno lo interesante de hacerlo con loops fue ver claramente porque la cantidad de filas de la primera matriz debe coincidir con la cantidad de columnas de la segunda matriz

# listas con las filas de la primera matriz
A1, A2, A3, A4 = [1,2,3],[4,5,6],[7,8,9],[10,11,12]

# listas con las columnas de la segunda matriz
B1, B2 = [2,5,11], [3,7,13]

# del shape de las matrices originales sabemos que la matriz resultante sera de (4, 2)
# que son las medidas de los extremos

# calculo del elemento (col 1,fila 1):
C11 = 0
for i in A1:
  C11 += (A1[i-1] * B1[i-1])

print(C11)

# calculo del elemento (col 1,fila 2):
C12 = 0
for i in A1:
  C12 += (A2[i-1] * B1[i-1])

print(C12)

# calculo del elemento (col 1,fila 3):
C13 = 0
for i in A1:
  C13 += (A3[i-1] * B1[i-1])

print(C13)

# calculo del elemento (col 1,fila 4):
C14 = 0
for i in A1:
  C14 += (A4[i-1] * B1[i-1])

print(C14)

Output:
45
99
153
207

# calculo del elemento (col 2,fila 1):
C21 = 0
for i in A1:
  C21 += (A1[i-1] * B2[i-1])

print(C21)

# calculo del elemento (col 2,fila 2):
C22 = 0
for i in A1:
  C22 += (A2[i-1] * B2[i-1])

print(C22)

# calculo del elemento (col 2,fila 3):
C23 = 0
for i in A1:
  C23 += (A3[i-1] * B2[i-1])

print(C23)

# calculo del elemento (col 2,fila 4):
C24 = 0
for i in A1:
  C24 += (A4[i-1] * B2[i-1])

print(C24)

Output:
56
125
194
263

Los valores restantes son

• 1x2 + 2x5 + 3x11 = 45
• 1x3 + 2x7 + 3x13 = 56
• 4x2 + 5x5 + 6x11 = 99
• 4x3 + 5x7 + 6x13 = 125
• 7x2 + 8x5 + 9x11 = 153
• 7x3 + 8x7 + 9x13 = 194
• 10x2 + 11x5 + 12x11 = 207
• 10x3 + 11x7 + 12x13 = 263

Hecho el ejercicio y es una delicia:

A1 = 1 * 2 + 2 * 5 + 3 * 11
B1 = 1 * 3 + 2 * 7 + 3 * 13
A2 = 4 * 2 + 5 * 5 + 6 * 11 
B2 = 4 * 3 + 5 * 7 + 6 * 13
A3 = 7 * 2 + 8 * 5 + 9 * 11
B3 = 7 * 3 + 8 * 7 + 9 * 13
A4 = 10 * 2 + 11 * 5 + 12 * 11
B4 = 10 * 3 + 11 * 7 + 12 * 13
print(A1)
print(B1)
print(A2)
print(B2)
print(A3)
print(B3)
print(A4)
print(B4)

Da los mismos datos que con las fórmulas:

C = A.dot(B)

print(C)

Tarea:

Valores:
1x2+2x5+3x11= 45
1x3+2x7+3x13=56
4x2+5x5+6x11=99
4x3+5x7+9x11=125
7x2+8x5+9x11=153
7x3+8x7+9x13=194
10x2+11x5+12x11=207
10x3+11x7+12x13=263

Se olvidaron de explicar que es el producto interno de dos matrices, un ejemplo no es una explicación, falta, la definición, demostración, otros ejempllos, etc. Al final tenemos que irnos a youtube para entender el tema, punto mas para youtube, punto menos para platzi

Mi resultado 😄

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

B = np.array([
[2,3],
[5,7],
[11,13]
])

print(A)
print("—")
print(B)
print("—")
print([
[12 + 25 + 311, 13 + 27 + 313],
[42 + 55 + 611, 43 + 57 + 613],
[72 + 85 + 911, 73 + 87 + 913],
[102 + 115 + 1211, 103 + 117 + 1213]
])

En lugar de hacer el ejercicio que propone el profesor, les propongo que vean el siguiente video, y entiendan por que el producto interno se lleva a cabo de esa manera.
https://www.youtube.com/watch?v=8f7UUnbLqp0&list=PLIb_io8a5NB2DddFf-PwvZDCOUNT1GZoA&index=5

Ya si quieren profundizar aún más les recomiendo vean la lista de reproducción completa.

Forma en la que se realizan las operaciones para obtener la matriz resultante:

Completando la matriz.
![](

Hasta en este punto me di cuenta que tan necesario y bueno es Python. Me tarde 3 minutos multiplicando las dos matrices…

Calculando todas las entradas como productos punto entre vectores:

C_0_0 = (
    A[0][0] * B[0][0] +
    A[0][1] * B[1][0] +
    A[0][2] * B[2][0]
)

C_0_1 = (
    A[0][0] * B[0][1] +
    A[0][1] * B[1][1] +
    A[0][2] * B[2][1]
)

C_1_0 = (
    A[1][0] * B[0][0] +
    A[1][1] * B[1][0] +
    A[1][2] * B[2][0]
)

C_1_1 = (
    A[1][0] * B[0][1] +
    A[1][1] * B[1][1] +
    A[1][2] * B[2][1]
)

C_2_0 = (
    A[2][0] * B[0][0] +
    A[2][1] * B[1][0] +
    A[2][2] * B[2][0]
)

C_2_1 = (
    A[2][0] * B[0][1] +
    A[2][1] * B[1][1] +
    A[2][2] * B[2][1]
)

C_3_0 = (
    A[3][0] * B[0][0] +
    A[3][1] * B[1][0] +
    A[3][2] * B[2][0]
)

C_3_1 = (
    A[3][0] * B[0][1] +
    A[3][1] * B[1][1] +
    A[3][2] * B[2][1]
)

Construyendo la matriz resultante:

C_construida = np.array([
    [ C_0_0 , C_0_1 ],
    [ C_1_0 , C_1_1 ],
    [ C_2_0 , C_2_1 ],
    [ C_3_0 , C_3_1 ],
])

Para que A x B se pueda multiplicar:
El número de columnas de A tiene que ser igual al número de filas de B.

vector * matriz con los mismos que se usaron en la clase me dio:
array([[ 2, 6],
[ 6, 12],
[10, 18]])

Comparto mi versión en código de producto punto (o escalar):

def myDot(A,B):
# Where A is a matrix with m_A rows and n_A columns
# and B is a matrix with m_B rows and n_B columns

# Then dot product is only defined if m_A == n_B 
# so the shape of our new matrix C will be m_A rows and n_B columns
    C = np.zeros((A.shape[0],B.shape[1]))
    
    for i in range (0,A.shape[0]):
        for j in range (0, B.shape[1]):
            for n in range (0,B.shape[0]):
                C[i][j]= C[i][j] + (A[i][n]*B[n][j])
    
    return C

Markdown para Colab o similar del producto interno visto en clase:

$$ C = 
\begin{bmatrix}
1 & 2 & 3\\
4 & 5 & 6\\
7 & 8 & 9\\
10 & 11 & 12
\end{bmatrix}*
\begin{bmatrix}
2 & 3\\
5 & 7\\
11 & 13
\end{bmatrix}=
\begin{bmatrix}
(1*2)+(2*5)+(3*11) & (1*3)+(2*7)+(3*13)\\
(4*2)+(5*5)+(6*11) & (4*3)+(5*7)+(6*13)\\
(7*2)+(8*5)+(9*11) & (7*3)+(8*7)+(9*13)\\
(10*2)+(11*5)+(12*11) & (10*3)+(11*7)+(12*13)
\end{bmatrix}=
\begin{bmatrix}
45 & 56\\
99 & 125\\
153 & 194\\
207 & 263
\end{bmatrix}
$$

Me costó un poco entender cómo funciona numpy internamente para realizar estas operaciones, así que acá mis apuntes:
Para que se pueda operar, se debe tener en MATRIZ_A las mismas columnas que filas en la MATRIZ_B. Ejemplo matriz de (4,3) @ (3,2). Y las dimensiones que devuelve son las de los extremos, en este caso: (4,3).
.

De la documentación [de dot()]:

Dot product of two arrays. Specifically,

• If both a and b are 1-D arrays, it is inner product of vectors (without complex conjugation).
• If both a and b are 2-D arrays, it is matrix multiplication, but using [matmul](https://numpy.org/doc/stable/reference/generated/numpy.matmul.html#numpy.matmul) or a @ b is preferred.
• If either a or b is 0-D (scalar), it is equivalent to [multiply](https://numpy.org/doc/stable/reference/generated/numpy.multiply.html#numpy.multiply) and using numpy.multiply(a, b) or a * b is preferred.
• If a is an N-D array and b is a 1-D array, it is a sum product over the last axis of a and b.
• If a is an N-D array and b is an M-D array (where M>=2), it is a sum product over the last axis of a and the second-to-last axis of b.

.
numpy.dot - NumPy v1.20 Manual
.
En resumen: para multiplicar entre matrices, se debe tener en el eje de A, las mismas dimensiones que en el penúltimo eje de B.

En python hay 3 formas de indicar el producto interno entre dos matrices:

A = np.array([
    [11,12,13],
    [21,22,23],
    [31,32,33],
    [41,42,43]
])

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


C = A.dot(B) 

D = np.dot(A, B)

E = A @ B

print('\nA\n',A)
print('\nB\n',B)
print('\n A.dot(B) \n',C)
print('\n np.dot(A, B) \n',D)
print('\n A @ B \n',E)

matriz 3x1 por matriz 1x3 da una matriz 3x3:

H = np.array([[1], [2], [3]]) #3x1
K = np.array([[2, 4, 6]]) #1x3
L = H.dot(K) #3x3
print(L)

[ [ 2   4   6]
  [ 4   8 12]
  [ 6 12 18] ]

C = A.dot(B)

for a in A:
    txt = ''
    for b in B.T:
        r = 0
        for ai, bi in zip(a, b):
            txt += f"({ai} X {bi}) + "
            r += (ai * bi)
        txt = txt[:-2] + f"= {r}, "
    print(txt[:-2])
print("\n")
print(C)

(1 X 2) + (2 X 5) + (3 X 11) = 45, (1 X 3) + (2 X 7) + (3 X 13) = 56
(4 X 2) + (5 X 5) + (6 X 11) = 99, (4 X 3) + (5 X 7) + (6 X 13) = 125
(7 X 2) + (8 X 5) + (9 X 11) = 153, (7 X 3) + (8 X 7) + (9 X 13) = 194
(10 X 2) + (11 X 5) + (12 X 11) = 207, (10 X 3) + (11 X 7) + (12 X 13) = 263


[[ 45  56]
 [ 99 125]
 [153 194]
 [207 263]]

m_5 = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]]) 
#np.random.randint(low = 3, high=5, size =(4, 3)) 
v_3 = np.array([[2,3],[5,7],[11,13]]) 
#np.random.randint(low = 1, high=9, size =(3,2))

results = list()
position = 0
for m in m_5:
    i = 0
    p = 0
    r = list()
    for val_m in range(len(m)):
        j = 0
        to_sum = []
        for v in v_3:
            if p == len(v):
                position +=1
                break
            #print(f'{m[j]} + {v_3[j, p]}')
            to_sum.append(m[j] * v_3[j, p])
            j += 1
        
        if p != len(v):
            r.append(sum(to_sum))
        #print(sum(to_sum))
        #print('='*30)
        p += 1
    results.append(r)
      
    i += 1
print (results)
print('='*30)
print(m_5.dot(v_3))

C= AxB
C11= 1x2+2x5+3x11= 45
C12=1x3+2x7+3x13=56
C21=4x2+5x5+6x11=99
C22=4x3+5x7+9x11=125
C31=7x2+8x5+9x11=153
C32=7x3+8x7+9x13=194
C41=10x2+11x5+12x11=207
C42=10x3+11x7+12x13=263

Producto interno entre dos matrices

# Para realizar el producto interno entre matrices es importante recordar que
# coincidir la cantidad de columnas de la matriz A con las cantidad de filas
# de la matriz B.
# Siendo A una matriz (4,3) y B una matriz (3,2) podemos hacer:
C = A.dot(B)
# Pero no podemos hacer:
D = B.dot(A)

[[ 45 56]
[ 99 125]
[153 194]
[207 263]]

print(np.array([
                [(1*2  + 2*5  + 3*11) , (1*3  + 2*7 + 3*13)],
                [(4*2  + 5*5  + 6*11) , (4*2  + 5*5 + 6*11)],
                [(7*2  + 8*5  + 9*11) , (7*2  + 8*5 + 9*11)],
                [(10*2 + 11*5 + 12*11), (10*2 + 11*5 + 12*11)]
                ]))

Por lo que entendiiiiiii

Para poder realizar el producto interno entre dos matrices, requerimos que el numero de columnas de A sea igual al numero de filas de B.

Cada posición IJ de la matriz resultante correspondera a la suma de la multiplicación de cada elemento de la columna de A por el elemento correspondinete a la fila de B.

Que excelente!

array([[ 45,  56],
       [ 99, 125],
       [153, 194],
       [207, 263]])

que buen repaso de álgebra lineal

Alguien mas le sucede que tiene que esperar hasta 2 minutos para que el video cargue 30 segundos?

Producto interno es sinónimo de multiplicación entre matrices.