Conceptos básicos de álgebra lineal y configuración del entorno de trabajo

1

Presentación del curso y la necesidad del Álgebra Lineal

2

Anaconda + Python, Creación de un entorno y actualización de paquetes

3

Uso de Jupyter Notebook

4

Creando las bases, escalares, vectores y matrices. ¿Qué es un tensor? ¿Cómo se representa?

Realiza operaciones básicas

5

Dimensión de un escalar, vector, matriz o tensor

6

Transposición, suma de matrices y escalares

7

Suma de matrices y vectores (broadcasting)

Operaciones con matrices

8

Producto interno entre una matriz y un vector

9

Producto interno entre dos matrices

10

Propiedades de las matrices: la multiplicación de matrices es asociativa y distributiva, no es conmutativa

11

Transposición de un producto de matrices

12

Cómo comprobar la solución de un sistema de ecuaciones lineal

13

Tipos especiales de matrices: Identidad, Inversa, Singulares

14

Aplicación de la inversa de una matriz para resolver un sistema de ecuaciones lineales

Sistema de ecuaciones lineales

15

Ejemplos de sistemas sin solución, con una solución y con infinitas soluciones

16

Graficar vectores

17

¿Qué es una combinación líneal?

18

¿Qué es un espacio y un subespacio?

19

Vectores linealmente independientes

20

Validar que una matriz tenga inversa

Normas

21

Qué es una norma y para qué se usa. Desigualdad Triangular

22

Tipos de normas: norma 0, norma 1, norma 2, norma infinito y norma L2 al cuadrado

23

El producto interno como función de una norma y su visualización

Matrices y vectores especiales

24

La matriz diagonal y la matriz simétrica: sus propiedades

25

Vectores ortogonales, matrices ortogonales y sus propiedades

26

Matrices ortogonales y sus propiedades

Otras funciones de álgebra lineal

27

El determinante y la traza

28

Cierre del curso. Continua con el Curso de Álgebra Lineal Aplicada a Machine Learning.

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Producto interno entre una matriz y un vector

8/28
Recursos

Aportes 76

Preguntas 4

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

muy importante observen que:

  • “producto interno” toma dos vectores y regresa un escalar.
  • “producto externo” toma dos vectores y devuelve una matriz.(este no se menciono pero vale la pena lo revisen)

Existe otra manera de hacer producto punto, con la letra "@"m por ejemplo : Matriz_A @ Matriz_B 😉

Creo que si tratamos de multiplicar una matriz de 3x2 y un vector fila de 2 no lo vamos a poder lograr por que no coinciden las columnas de la matriz con la del vector. No obstante para realizar esta operación debemos hacer la transpuesta del vector (o de la matriz) y recién ahí intentar multiplicar.

Sigo sin entender el funcionamiento interno de python es esta situación, ¿será que hace la transpuesta antes de multiplicar?

Me dio curiosidad y realice un producto interno entre tensores y matrices. Descubrí que se puede hacer producto interno de ambos lados mientras las dimensiones sean correctas. Por lo tanto también se pueden hacer producto interno entre matrices. Este es mi código de mis pruebas:

matriz1 = np.array([[1,2,3],[3,4,5]])
tensor = np.array([
    [[1,2],[3,4],[5,6]],
    [[1,2],[3,4],[5,6]],
    [[1,2],[3,4],[5,6]]
])
D = np.dot(matriz1 , tensor)
E = np.dot(tensor , matriz1)
F = np.dot(matriz1 , matriz1.T)
G = np.dot(matriz1.T, matriz1)
print('D:')
print(D)
print('E:')
print(E)
print('F:')
print(F)
print('G:')
print(G)

Y los resultados que obtuve son:

D:
[[[22 28]
  [22 28]
  [22 28]]

 [[40 52]
  [40 52]
  [40 52]]]
E:
[[[ 7 10 13]
  [15 22 29]
  [23 34 45]]

 [[ 7 10 13]
  [15 22 29]
  [23 34 45]]

 [[ 7 10 13]
  [15 22 29]
  [23 34 45]]]
F:
[[14 26]
 [26 50]]
G:
[[10 14 18]
 [14 20 26]
 [18 26 34]]

Los invito a probar y a averiguar cuales es el orden de las operaciones para obtener estos resultados.

Producto de matrices y vectores
Podemos usar el producto simple * que en python hace una multiplicación elemento a elemento y lo coloca en su posición respectiva (hace un broadcasting al igual que la suma)
Producto punto de matrices y vectores
Usa la definición del producto punto, es decir suma la multiplicación de elementos dos a dos, generando un producto punto por cada vector de la matriz

El profesor está multiplicando una matriz de 3x2, con un vector (matriz de 1x2). Eso no es válido. Python lo que hace es interpretar ese vector de 1x2 como una matriz columna de 2x1 (2 filas y una columna) y luego hace la multiplicación de la manera como lo hace el profesor.

  • Para que la multiplicación de matrices esté definida el número de columnas de la primera debe coincidir con el número de filas de la segunda.

(3x2) * (1x2) no está definida la multiplicación
(3x2) * (2x1) Es posible multiplicar. El resultado es una matriz de 3 filas y 1 columna.

Aclaro como funciona porque la representación gráfica que hace el profesor al multiplicar puede llevar a confusión.

Hola…!! 😃
Este es el código que utilicé para crear el producto interno:

import numpy as np

vector = np.array([2,3,5])
print("\nVector: ",vector)

matriz = np.array([[1,2,3], [4, 5, 6], [7, 8, 9]])
print("\nMatriz: ",matriz)

A = matriz.dot(vector)
print("\nmatrizXvector: ",A)

B = vector.dot(matriz)
print("\nvectorXmatriz: ",B)

Los resultados fueron los siguientes:

Vector:  [2 3 5]

Matriz:  [[1 2 3]
 [4 5 6]
 [7 8 9]]

matrizXvector:  [23 53 83]

vectorXmatriz:  [49 59 69]

Y cómo se puede apreciar… los resultados no son iguales…

En python, Las operaciones A = matriz * vector y A = vector * matriz dan el mismo resultado, pero las operaciones A = matriz.dot(vector) y A = vector.dot(matriz) no. La primera es la forma correcta, la segunda arroja un error, tal como indican las reglas de algebra lineal.

Producto punto (escalar o interno)
En algebra lineal el producto punto es una de las formas de multiplicación de matrices; consiste en que por cada elemento del vector A lo multiplicaremos por el elemento correspondiente en e vector B y su producto será sumado con los siguientes componentes en el mismo orden, mejor vean la imagen >-<

[a,b].[d,e] = ((a.c)+(b.c))

Estaba confundido ya que por lo general el producto punto nos devuelve un escalar, pero buscando informacion eso depende de las dimensiones del array;


Producto punto en una dimensión (vectores)

a = np.array([2, 1, 5, 4])
b = np.array([3, 4, 7, 8])
pp = np.dot(a, b)
>>77

En ese caso obtenemos un escalar, ya que estamos trabajando en una dimensión


Producto punto en dos dimensiones (matrices)
Se resuelve en la siguiente clase jajaja, pero basicamente debemos multiplicar la primer fila por la primer columna, y nos dara el elemento (0,0); despues por la siguiente columna, nos dara el ((0,1). Bajamos a la fila 2 y seguimos sucesivamente

Agradezco a Valentina Hurtado y a Patricio Requena del grupo de DS de telegram que me ayudaron cuando tuve el problema

  • El producto interno entre una matriz y un vector es una operación muy común en álgebra lineal, también conocida como producto matriz-vector.
  • Cabe destacar que para poder realizar el producto interno entre una matriz y un vector, la segunda dimensión de la matriz debe ser igual a la primera dimensión del vector. En este ejemplo, la segunda dimensión de la matriz A es igual a la primera dimensión del vector v, por lo que la operación de multiplicación es posible.
import numpy as np

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

# Creamos un vector de 3 elementos
v = np.array([7, 8, 9])

# Calculamos el producto interno entre A y v
u = np.dot(A, v)

print(u)
# resultado: [ 50 122]

vector por matriz no es igual a matriz por vector

chicos les comparto un PDF donde demostré como encontrar la estructura del producto interno de las matrices de 2x2 que se podría generalizar para nxn.
La demostración se hizo partiendo de las transformaciones lineales … dirigido para los que no solo quieren quedarse con la idea de que el producto de matrices es fila por columna … y quieren saber por que es así.
lo podrán encontrar en este enlace.
https://drive.google.com/file/d/1igHl_z7KHJ35pPpvRQygyDf8l8gSi-7m/view?usp=sharing

Pequeño tip que me ayudó mucho.

Al nombrar las dimensiones de una matriz o vector lo haremos de la forma:

Filas x Columnas :

—> n x m para nuestra matriz
—> m x k para nuestro vector

Para poder realizar el producto de nuestra matriz por vector tendremos que cumplir que:

(n x m)(m x k)

Es decir, las columnas de la matriz coinciden con las filas del vector (Puede ser en el orden contrario para hacer coincidir un vector fila).

Obteniendo como resultado un objeto de dimensiones:

(n x k)

Por lo que entiendo Python hace algunas movidas raras como el broadcasting cuando estas dimensiones no coinciden, como en el caso de tratar de hacer el producto punto con un vector fila.

Para todos aquellos que están estudiando Algebra Lineal o en algún momento la estudiaron, pero no tienen idea de por que los productos entre matrices son así, que significa el determinante, y de donde se sacaron esas formulas que tanto nos memorizamos.

Les recomiendo ampliamente esta lista de reporducción en Youtube que nos muestra gráficamente todas las definiciones de Algebra Lineal, para que por fin entendamos el por qué de todas estas cosas.
Es buenísimo y desde el primer momento que la vi, me enamoré del canal.

https://www.youtube.com/watch?v=0Ndnzx6AyaA&list=PLIb_io8a5NB2DddFf-PwvZDCOUNT1GZoA

import numpy as np

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

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

c = vector + matriz.T
  1. El orden al multiplicar matrices si importa
  2. Es posible multiplicar siempre y cuando el numero de COLMUNAS de la PRIMERA MATRIZ sea igual al numero de FILAS de la SEGUNDA MATRIZ
  3. La MATRIZ RESULTANTE toma el NUMERO DE FILAS DE LA PRIMERA MATRIZ Y EL NUMERO DE COLUMNAS DE LA SEGUNDA MATRIZ , para su forma final .
  4. [
    [ 1, 2 ]
    [ 3 ,4 ]
    ] ** 2 x 2 **
    • Es de forma 2_ ( filas)_ x 2_ (columnas)_

Buenas tardes

En clase se ha relizado el producto interno de la siguiente manera:

B = matriz.dot(vector)
C = np.dot(matriz,vector)

Pero para realizar el producto interno primero vector y luego matriz, hay que transponer la matriz para que den los mismos resultados.

D = vector.dot(matriz.T)
E = np.dot(vector,matriz.T)

Saludos.

  • La multiplicación de una matriz por un vector usa Broadcasting, y el vector multiplica cada fila de la matriz.
Me gustaria que explicaran el porque tenemos que usar la multiplicación o el producto interno. Chat GPT menciono que la multiplicación se usa para transformaciones lineales, modelos de regresión, PCA y redes neuronales. El producto interno se utiliza para medición de similitud, cálculo de activación de redes neuronales y proyecciones. Estaria bien explicar estos conceptos porque podrian ser preguntados en entrevisas de trabajo.
Hola, Les comparto mis resultados: ![](https://static.platzi.com/media/user_upload/imagen-0408d488-87cb-4792-bef0-021b3da835ed.jpg) Se pude ver que cuando se multiplica vector por matriz, multiplica el vector por cada valor de las columnas, si tienen la misma longitud.

Aqui esta mi ejercicio profesor:
![](

Sí multiplicamos matriz * vector y vector * matriz el resultado es el mismo.
Ejemplo y ejercicio de la clase:

vector = np.array([3,4])
matriz = np.array([[1,2],[3,4], [5,6]])
*
A = matriz * vector
C = vector * matriz

Resultados A
print(A) print(A)
print(A)
[[ 3 8]
[ 9 16]
[15 24]]

Resultados C
print ©
[[ 3 8]
[ 9 16]
[15 24]]

Producto interno entre una matriz y un vector

Para entender la diferencia entre producto interno y multiplicar una matriz por un vector vamos a realizar ambas operaciones y luego las explicamos:

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

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

# Multiplicar una matriz por un vetor
A = matriz * vector

# Producto interno entre una matriz y un vector
B = matriz.dot(vector)

print(A) # Output = [[1  4] [3  8] [5 12]]
print(B) # Output = [5 11 17]

Como vemos ambos resultados son muy distintos, por ejemplo en la variable **A**, tenemos que sus dimensiones son de (3, 2), pero cuando hacemos el producto interno de la matriz en la variable **B**, tenemos un vector de dimensión de (3, ). Expliquemos sus diferencias:

  • Matriz por el vector: Cuando multiplicamos la matriz por el vector, tenemos una operación de Broadcasting donde el vector se repite para multiplicar la matriz.
  • Producto interno: En el caso del producto interno, tomamos el primer valor de la fila de la matriz y lo multiplicamos por el primer valor del vector, y el segundo valor de la fila de la matriz con el segundo valor de la fila del vector, y luego, sumamos ambos.
    • En el caso del primer dígito del vector **B** sería $1 * 1 + 2 * 2 = 5$.

Tenemos dos formas calcular el producto interno en Python:

# La que ya vimos
B = matriz.dot(vector)

# Directamente llamando a la librería de Numpy
C = np.dot(matriz, vector)

print(B) # Output = [5 11 17]
print(C) # Output = [5 11 17]

.

me están confundiendo entre broadcasting y multiplicación de matrices según mis clases de álgebra lineal:
si dos matrices A,B de (l,m) y (k,s) respectivamente se multiplican AB solo si m=k esto es si las columnas de A son iguales a las filas de B y resultaría una matriz C con (l,s) filas y columnas
mientras que broadcasting por lo que vi es:
con dos matrices A,B con (l,m) y (k,s) respectivamente se multiplican A
B solo si l = k ó m = s esto es que se ampliaría lo restante resultando en una matriz C con la dimensión de filas y columnas mas grandes entre A y B
pero tambien hay que mencionar que el producto interno devuelve un escalar mientras que aqui como lo definieron devuelve una matriz

Interesantes estos temas.
El producto punto o escalar es un tipo especial de producto interno, definido únicamente para espacios vectoriales reales finitos.
El producto vectorial o cruz está definido únicamente para R^3, y devuelve un vector perpendicular a los dos originales.
El producto externo, también llamado producto tensorial, es diferente al cruz, pues devuelve una matriz construida con los dos vectores originales.
Y el producto exterior es diferente al externo, pues devuelve un objeto matemático llamado una “forma exterior”.
El producto exterior es una generalización del producto cruz a espacios vectoriales de cualquier dimensión.

Tomando las mismas variables de la clase, se obtiene el mismo resultado:

para multiplicar el vector por la matriz tuve que crear un vector de 3 dimensiones en una matriz 3x2, porque si lo hago por un vector de dos dimensiones me muestra error:

![](url)

Para afianzar estos conceptos les recomiendo ver el siguiente video. Es corto, vale la pena.
https://www.youtube.com/watch?v=fhz5jAs4iJY

Tarea:

Ojo: en las matemáticas un vector se considera como una matriz!

En las matemáticas existen producto escalar producto interno y producto vectorial, no recuerdo a ver escuchado producto externo xD. Saludos!

Para los que se puedan confundir con el término “Producto interno”, también lo llaman “Producto punto”

Primera vez que oigo a alguien llamarlos producto interno y externo, en los textos de matematica que yo he leido se mencionan como producto punto y producto cruz.

Pero bueno siempre se aprende algo nuevo


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

#Reto

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

Matriz=np.array([[1,2,3,4,5],[2,3,54,5,3],[1,2,43,2,4],[1,2,3,4,4],[1,2,3,133,43]])

A=Vector*Matriz
B=Matriz*Vector

A_=Matriz.dot(Vector)
B_=Vector.dot(Matriz)

print("Multiplicación ")
print(A)
print("\n ")
print(B)
print("Multiplicación Interna ")
print(A_)
print("\n ")
print(B_)

Multiplicación 
[[  1   4   9  16  25]
 [  2   6 162  20  15]
 [  1   4 129   8  20]
 [  1   4   9  16  20]
 [  1   4   9 532 215]]

 
[[  1   4   9  16  25]
 [  2   6 162  20  15]
 [  1   4 129   8  20]
 [  1   4   9  16  20]
 [  1   4   9 532 215]]

Multiplicación Interna 

[ 55 205 162  50 761]

 
[ 17  32 267 701 254]

Cuando se multiplica en un producto punto la matriz A de (n,m) sólo puede multiplicarse por otra matriz B que sea (m, p), donde n y p pueden ser cualquier otro número. Entonces, en el ejercicio de la clase multiplicamos una matriz (3,2) por un vector (2,), entonces tiene la misma m (2). Pero si tratamos de hacer el producto del vector por la matriz no se puede porque sería multiplicar (2,) por (3,2). Así que al pedirle a Python que haga ese producto, nos devuelve un error por sus dimensiones.

Este producto interno es equivalente a multiplicar matemáticamente dos matrices. Es importante que el número de columnas de la primera matriz sea igual al número de filas de la segunda. Aquí un ejemplo:

M = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 1, 2]])
N = np.array([[3, 4], [5, 6], [7, 8]])

print(M.shape) # (4, 3) 3 columnas
print(N.shape) # (3, 2) 3 filas

P = np.dot(M, N)
print(P.shape) # (4, 2)

Para los vectores podemos tomarlos como matrices de 1 columna.

escalar = 5.679
vector = np.array([2,3])
matriz = np.array([[1,2],[3,4],[5,6]])

Otra forma de multiplicar matrices como producto interno es usando matmul :
Siendo A una matriz de (2,3) y C un vector de (3,)
np.matmul ( A,C) es igual que usar A@C y también A.dot©

y np.dot(A,C)

Este es el código que realice en Jupyter Notebook.

mi_vector = np.random.randint(20, size=5)
mi_matriz = np.random.randint(20, size=(5, 5))
mxv = mi_matriz * mi_vector
vxm = mi_vector * mi_matriz
print('Vector')
print(mi_vector)
print('Matriz')
print(mi_matriz)
print('Matriz por vector')
print(mxv)
print('Vector por matriz')
print(vxm)

Y estos son los resultados que obtuve
Vector
[ 4 10 6 16 2]
Matriz
[[19 16 6 13 5]
[18 13 4 1 18]
[ 1 7 5 10 4]
[12 12 0 4 1]
[18 7 12 16 4]]
Matriz por vector
[[ 76 160 36 208 10]
[ 72 130 24 16 36]
[ 4 70 30 160 8]
[ 48 120 0 64 2]
[ 72 70 72 256 8]]
Vector por matriz
[[ 76 160 36 208 10]
[ 72 130 24 16 36]
[ 4 70 30 160 8]
[ 48 120 0 64 2]
[ 72 70 72 256 8]]
Llegué a la conclusión que este tipo de operaciones en Python son conmutativas. Pero hay que tomar en cuenta que la forma correcta de reañ¿lizar estas operaciones es con el producto interno, lo cual no sería conmutativo y no nos permitiría realizar la operacón si las dimensiones no son las adecuadas.

Comprobé que son lo mismo:

Interesante… Hoy aprendí que la propiedad conmutativa de la multiplicación aplica incluso en la multiplicación de vectores y matrices

import numpy as np 

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

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

print(vector.dot(matriz.T))
print(matriz.dot(vector))

Para hacer la multiplicación, hay que tener en cuenta las dimensiones de la Matriz y del Vector.
Podemos hacer Matriz* Vector si, la matriz es de ‘x,y’ dimensión y el vector es de ‘y,1’ dimensión. Lo que nos dará una resultado de dimensión ‘x,1’.
Y si multiplicamos Vector*Matriz. El Vector es de dimensión ‘x,1’ y la matriz debe ser de ‘1,x’ y la Matriz debe ser de ‘x,y’. El resultado te dará de dimensión ‘1,y’.

Tres formas distintas de obtener el producto interno

matriz_A = np.random.randint(low = 3, high=8, size =(3, 3)) 
vector_A = np.random.randint(low = 3, high=8, size =(3, 1)) 
#Forma numero 1
produc_in = matriz_A.dot(vector_A)
print("Esta es la primera forma x.dot(y): ",produc_in)
print(50*"*")
#foma numero 2
produc_in_two = np.dot(matriz_A, vector_A)
print("Esta es la segunda forma np.dot(x,y): ",produc_in_two)
print(50*"*")
#Forma numero tres
matriz_A@vector_A
print("Esta es la tercera forma x@y: ",matriz_A@vector_A)
import numpy as np
vector= np.array([2,3])
matriz = np.array([[1,2],[3,4],[5,6]])
A = matriz * vector
B = vector * matriz
C = matriz.dot(vector)
D = np.dot(matriz, vector)

print("\n matriz * vector")
print(A)
print("\n vector * matriz")
print(B)
print("\n matriz.dot( vector )")
print(C)
print("\n np.dot(matriz, vector)")
print(D)


 matriz * vector
[[ 2  6]
 [ 6 12]
 [10 18]]

 vector * matriz
[[ 2  6]
 [ 6 12]
 [10 18]]

 matriz.dot( vector )
[ 8 18 28]

 np.dot(matriz, vector)
[ 8 18 28]```

Producto del vector por una matriz es diferente a el producto de una matriz por un vector.

<h1>Para poder realizar el producto interno de las dimensiones(Numero de columnas) debe ser el mismo</h1>

Efectivamente el resultado no es el mismo. La operación ocurre distinto en el otro sentido y si mal no estoy también se debe al broadcasting, ¿no?

cordial saludo,
realizo el producto de una matriz de 3 por 3 con un vector de 3 escalares:

x=np.array([[[2,7,8]],[[3,6,9]],[[4,5,1]]])
y=np.array([3,5,4])
print(x)
print(y)
[[[2 7 8]]

 [[3 6 9]]

 [[4 5 1]]]
[3 5 4]
z=np.dot(x,y)
print(z)
[[73]
 [75]
 [41]]```pero al tratar de hacerlo al reves me saca un error🤔
gracias
import numpy as np

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

D = np.dot(vector_ejercicio , matriz_ejercicio)
E = np.dot(matriz_ejercicio, vector_ejercicio)


print("vector * matriz = ", D)
print("Matriz * Vector = ", E)

<h1>Para realizaar la multiplicación de una matriz con un vector,</h1>

#la longitud del vector debe ser igual al numero de columnas de la matriz

En el caso de A=vectormatriz es igual a A=matrizvector.
Pero en el caso del Producto Interno, C=np.dot(matriz,vector) es diferente a C=np.dot(vector,matriz),
por lo que en esta última nos marca error.

Sale este error ValueError: shapes (2,) and (3,2) not aligned: 2 (dim 0) != 3 (dim 0)

![](

#Ejercicio Matriz vector y vectormatriz
vector=np.array([2,3,4])
matriz=np.array([[1,2,3],[3,4,4],[5,6,6]])
D=matriz.dot(vector)
E=np.dot(matriz,vector)
[20 34 52]
[20 34 52]

#Ejercicio Matriz vector y vectormatriz
vector=np.array([2,3,4])
matriz=np.array([[1,2,3],[3,4,4],[5,6,6]])
D=matriz.dot(vector)
E=np.dot(matriz,vector)
print(D)
print(E)

Se podria determinar que el orden de los factores no altera el producto. si es un escalar por una Matriz.

Cuando tenemos una Multiplicacion de un Vector por una matriz,el vector debe tener la misma dimension de filas que la matriz, la ley conmutativa se vuelve a cumplir

Cuando es Matrices, deben tener el mismo tamaño para que se cumple dicha condicion del “orden de los factores no altera el producto”

Pero la ley conmutativa no se cumple cuando es el producto interno de dos matrices

Para que se puedan multiplicar matrices con el producto interno o producto punto(este es el símbolo del producto punto --> •) (como le decimos en mi país) se debe tener encenta el orden, si primero multiplicamos A • B o B • A, ya que para que se puedan multiplicar matrices, el numero de columnas de la primera matriz debe ser igual al numero de filas de la segunda matriz.

Ejemplo:
Matriz A = 3X2 -> 2 filas y 2 Columnas
Matriz B = 1X2 -> 1 Fila y 2 Columnas (Esto puede ver como un vector o como una matriz de una sola fila)

Matriz A.dot(B) --> Esto no se puede realizar ya que el **numero de columnas **de la primera matriz no es el mismo que el numero de filas de las segunda matriz.

Matriz B.dot(A) --> Aquí si podemos realizar el producto interno (producto punto) porque el numero de columnas de la primera matriz , en este caso la matriz B es igual al numero de filas de la matriz A.

Adicionalmente, podemos saber el tamaño de nuestra matriz resultante, el cual dependerá del numero de filas de la primera matriz y el numero de columnas de la segunda matriz.

Matriz B.dot(A) --> La matriz resultante sera de (1x2)

Lo que aún no entiendo muy bien es, cuando defino un vector, por ejemplo, np.array([1,2]) ¿estoy obteniendo una “matriz” 2x1 o una 1x2? Porque en el ejemplo del video lo toman como un 2x1 para poder multiplicar en dot, lo que indica que la lista en np.array([1,2]) define una COLUMNA, mientras que cada lista en np.array([[1,2],[3,4]]) definen FILAS.

No entiendo porque multiplica columnas por filas, no deberia de ser filas por columnas?
“Para multiplicar dos matrices, el numero de columnas de la primera debe ser igual al numero de filas de la segunda” Porque aca no se cumple esa regla pero aun asi python lo permite y hace un calculo raro?

Estimados.
Adjunto tarea propuesta.
#Datos
vector = np.array ([11,10,20,45,30])
matriz = np.array ([[1,54,95,75,30],[40,65,70,32,74],[41,32,74,65,30],[10,12,13,42,39],[45,74,65,50,40]])

#Producto Interno
B= matriz.dot(vector)
c= vector.dot(matriz)
print (B)
[6726 6150 6076 3550 5985]
print ©
[3031 4644 5760 5835 4625]

Los resultados son diferentes.
Saludos!!

El producto interno también se lo conoce como producto punto np.dot(a, b), dot en inglés significa punto

Resultado del ejercicio.
Al hacer la operación de producto punto en diferente orden encontré que solo se puede llevar a cabo si la matriz es cuadrada, y no se obtiene el mismo resultado en cada operación.

  1. Resultados diferentes con matriz cuadrada

  2. Error en una de las operaciones con matriz no cuadrada

Son iguales cuando se multiplica el vector y matriz en cualquier orden pero diferentes si se obtiene el producto interno.

A = test_vector * test_matrix
print(A, '\n'*2)
B = test_matrix * test_vector
print(B, '\n'*2)

print(A == B)

Output:
[[ 1  4  9]
 [ 4 10 18]
 [ 7 16 27]] 


[[ 1  4  9]
 [ 4 10 18]
 [ 7 16 27]] 


[[ True  True  True]
 [ True  True  True]
 [ True  True  True]]

A = test_vector @ test_matrix
print(A, '\n'*2)
B = test_matrix @ test_vector
print(B, '\n'*2)

print(A == B)

[30 36 42] 


[14 32 50] 


[False False False]

Otra forma de hacer producto interno o producto escalar es de la siguiente manera

D = matriz@vector

El producto externo nos da una matriz, en la cual cada fila es igual a la multiplicación del segundo vector por el escalar de cada columna del primer vector

.

El producto punto del vector por la matriz respecto a la matriz por el vector dan diferentes resultados.

Bajo el capo de las funciones .dot:

Que interesante esta clase.

vector_ejm = np.array([11,99,55,77,33,88,22,44,66])
matriz_ejm = np.array([[1,2,3,4,5,6,7,8,9],
                       [7,5,3,1,5,9,4,6,8]])

A = vector_ejm * matriz_ejm
print(A)
[[ 11 198 165 308 165 528 154 352 594]
 [ 77 495 165  77 165 792  88 264 528]]

B = matriz_ejm * vector_ejm
print(B)
[[ 11 198 165 308 165 528 154 352 594]
 [ 77 495 165  77 165 792  88 264 528]]


¿Qué es un vector de dimensión 2?
Eso que significa?
Se debe precisar que un vector es un caso especial de una matriz. Que existen vectores fila de 1xn y vectores columna de mx1