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

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

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

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

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

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

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

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.

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

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

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.