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.

Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

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

10/28
Recursos

Aportes 39

Preguntas 4

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Nota.
El producto interno de matrices es:

  • Asociativa: Sí
  • Distributiva: Sí
  • Conmutativa: NO
    El producto interno de vectores es:
  • Asociativa: Sí
  • Distributiva: Sí
  • Conmutativa: Sí

La ley conmutativa solo aplica en la multiplicación de matrices cuando éstas son matrices cuadradas y al mismo tiempo son matrices diagonales. Aquí puedes encontrar la definición de matriz cuadrada y diagonal.
Dejo el código para que lo comprueben.

A = np.array([[7, 0, 0, 0], [0, 5, 0, 0], [0, 0, 2, 0], [0, 0, 0, 20]])
B = np.array([[1, 0, 0, 0], [0, 8, 0, 0], [0, 0, 13, 0], [0, 0, 0, 4]])
print(A.dot(B) == B.dot(A))

Esto da como respuesta:

array([[ True,  True,  True,  True],
       [ True,  True,  True,  True],
       [ True,  True,  True,  True],
       [ True,  True,  True,  True]])

Dejo la matrices para que copien y peguen.

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

Propiedades de multiplicación de matrices

  • Asociativa: podemos asociar las multiplicaciones en el orden que queramos:
    AxBxC = (AxB)xC = Ax(BxC)
  • Distributiva con respecto a la suma: si tenemos la multiplicación de una matriz multiplicada por la suma de otras dos, será equivalente a la suma de las multiplicaciones de la matriz por cada una de las otras dos (en el mismo orden): Ax(B+C) = AxB +AxC
  • Conmutativa: La multiplicación de matrices no es conmutativa, es decir no se puede invertir el orden de multiplicacion: AxB != BxA

Nota:
El producto interno de dos vectores sí es conmutativo: AxB = BxA

para entender mejor los conceptos de algebra lineal recomiendo este video!
https://youtu.be/XkY2DOUCWMU

Acá el reto:

EJERCICIO

Para el ejercicio propuesto, Sean las matrices:

a de dimensión n x m (n filas y m columnas)
b de dimensión m x q (m filas y q columnas)

el producto interno [email protected] es válido ya que se cumple que el número de columnas de la primera sea igual al de las filas de la segunda. Sin embargo [email protected] no es valido ya que no cumple la condición dada para el caso [email protected] Esto es general para matrices a y b que cumplan las condiciones expuestas donde n y q diferente de m.

La multiplicación de matrices puede ser conmutativa en caso de que las matrices sean cuadradas, pequeña acotación

import numpy as np

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

AB =A.dot(B)
BA = B.dot(A)```

Según lo que el profesor nos ha explicado, en la línea 13 el v1 y v2 son matrices de 2filasx1columna.

dejo aquí mi reto

en el segundo caso hay que trasponerla porque de otra forma da un error por lo que no cumplen la misma función si las giramos.

# Mi solución al ejercicio

import numpy as np

matriz_1 = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15]])
matriz_2 = np.array([[16, 17], [18, 19], [20, 21], [22, 23], [24, 25]])

print(np.dot(matriz_1, matriz_2))
print(np.dot(matriz_2, matriz_1)) 

Dejo aquí la tarea solicitada:

Este es el código que realice para el ejercicio de esta clase:

A = np.random.randint(10, size=(7,3))
B = np.random.randint(10, size=(3,4))
C = A.dot(B)
print('Matriz A')
print(A)
print('Matriz B')
print(B)
print('Resultado')
print(C)

Y esto fue lo que me dio como resultado

Matriz A
[[7 0 4]
[4 8 7]
[6 4 7]
[7 8 2]
[7 2 1]
[5 3 9]
[4 0 5]]
Matriz B
[[7 3 6 8]
[9 2 9 6]
[2 9 2 7]]
Resultado
[[ 57 57 50 84]
[114 91 110 129]
[ 92 89 86 121]
[125 55 118 118]
[ 69 34 62 75]
[ 80 102 75 121]
[ 38 57 34 67]]

Aquí una función para comparar matrices de dimensiones iguales, sea cual sea el tamaño:

def comparaMatriz(X, Y):
    iguales = 0
    for i in range(X.shape[0]):
        for j in range(X.shape[1]):
            if X[i][j] == Y[i][j]:
                iguales += 1

    if iguales == X.size:
        print('Las matrices son iguales')
    else:
        print('Las matrces son diferentes')

Para la respuesta del reto:
La matriz a la iizq. de la multiplicacion (producto interno) debe tener la misma dimension en su columna que filas en la matriz de la derecha

Nota.- Las matrices casi nunca son conmutativas, pero sí existen casos.

X = np.array([[5,5],[5,5]])
Y = np.array([[5,5],[5,5]])

M = X.dot(Y)
N = Y.dot(X)

print(M==N)
print('\n')
print(M)
print('\n')
print(N)


[[ True  True]
 [ True  True]]


[[50 50]
 [50 50]]


[[50 50]
 [50 50]]

Puedes usar el operador @ en vez de la funcion .dot():

 A.dot(B)  es igual  A @ B

Tres maneras de escribir una multiplicacion

C = np.dot(A,B)
C = A.dot(B)
C = A @ B

Es importante mencionar que si A es una matriz cuadrada de nxn y A tiene inversa, (Denotamos a la inversa de A como A’) entonces tenemos que A*A’ = I y A’A = I, por lo tanto AA’ conmutan.

P. INTERNO MATRICES
Asociativa: Ax(BxC) = (AxB)xC Verdadero
Distributiva: Ax(B+C) = (AxB) + (AxC) Verdadero
Conmutativa: BxC = CxB Falso

Aquí está el ejercicio resuelto del final:

M1 = np.array([ [1,2], [3,4], [5,6] ])
M2 = np.array([ [1,2,3,4], [5,6,7,8] ])
M3 = M1 @ M2
print(M1, '\n', '-'*30)
print(M2,  '\n', '-'*30)
print(M3)

[[1 2]
 [3 4]
 [5 6]] 
 ------------------------------
[[1 2 3 4]
 [5 6 7 8]] 
 ------------------------------
[[11 14 17 20]
 [23 30 37 44]
 [35 46 57 68]]

Cuando se invierten los lugares de las matrices marca un error.

M4 = M2 @ M1
print(M4)
ValueError: matmul: Input operand 1 has a mismatch in its core dimension 0, with gufunc signature (n?,k),(k,m?)->(n?,m?) (size 3 is different from 4)

Se hace las operaciones con los mismos datos de la clase anterior:

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

Al imprimir D, da el siguiente erro: “ValueError: shapes (3,2) and (4,3) not aligned: 2 (dim 1) != 4 (dim 0)”

Les comparto mi par de matrices. El producto interno de A.dot(B) es posible, mientras que en el caso B.dot(A) no lo es.

import numpy as np

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

print(A.shape)
print(B.shape)
# Resultado: (3, 3)  (3, 2)

AB = A.dot(B)
print(AB)
# Resultado: [[ 76  82] [292 316] [184 199]]

# BA = B.dot(A)
# print(BA)
# Resultado: ValueError: shapes (3,2) and (3,3) not aligned: 2 (dim 1) != 3 (dim 0)```

matrizA = np.array([[1,2,3],[8,5,5],[8,5,6],[4,8,9]])
matrizB = np.array([[2,7],[8,9],[7,4]])
pA = matrizA.dot(matrizB) It´s right
but: pB = matrizB.dot(matrizA)
ValueError Traceback (most recent call last)
<ipython-input-76-fdcfebccb210> in <module>
----> 1 pB = matrizB.dot(matrizA)

ValueError: shapes (3,2) and (4,3) not aligned: 2 (dim 1) != 4 (dim 0)

<h1>Se debe transponer el vector ya que estos dos vectores son (2,1) y (2,1)</h1> <h1>Transponemos un vector para que sea (1,2) y (2,1) y si se pueda hacer el producto interno</h1>
  • Propiedad asociativa: Ax(BxC) = (AxB)xC - Se cumple la igualdad
  • Propiedad Distributiva: Ax(B+C) = (AxB) + (AxC) Se cumple la igualdad
  • Propiedad Conmutativa: BxC = CxB - No se cumple la igualdad
matriz_1 = np.array([[1,2,3],[5,6,11],[7,8,9],[10,11,12]])
matriz_2 = np.array([[1,2,3,9,8],[4,5,6,0,5],[8,5,2,4,10]])
dimensionM1 = matriz_1.shape
dimensionM2 = matriz_2.shape
producto_interno_1 = matriz_1.dot(matriz_2)
print("\nmatriz 1")
print(matriz_1)
print("\nmatriz 2")
print(matriz_2)
print("\nDimensión matriz 1")
print(dimensionM1)
print("\nDimensión matriz 2")
print(dimensionM2)
print("\nproducto interno matriz_1.dot(matriz_2)")
print(producto_interno_1)


matriz 1
[[ 1  2  3]
 [ 5  6 11]
 [ 7  8  9]
 [10 11 12]]

matriz 2
[[ 1  2  3  9  8]
 [ 4  5  6  0  5]
 [ 8  5  2  4 10]]

Dimensión matriz 1
(4, 3)

Dimensión matriz 2
(3, 5)

producto interno matriz_1.dot(matriz_2)
[[ 33  27  21  21  48]
 [117  95  73  89 180]
 [111  99  87  99 186]
 [150 135 120 138 255]]```

Serán dos matrices en cuyo caso el numero de columnas de la primera no tenga el mismo valor que el numero de filas de la segunda.

Una forma más general para resolver esto es la siguiente:
Tienen que darse dos matrices con dimensiones de la siguiente forma: 𝐴𝑛,𝑚×𝐵𝑚,𝑜 para que no pueda invertise el rol en el producto interno, ya que si se dan de la forma 𝐴𝑛,𝑚×𝐵𝑚,𝑛 si pueden invertirse sus roles o dicho de otra forma realizar el producto interno de 𝐴×𝐵 o de 𝐵×𝐴

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

MA1_MA2 = MA1.dot(MA2)
print(MA1_MA2)
MA2_MA1 = MA2.dot(MA1)
print(MA2_MA1)```


[[10  6]
 [18 11]
 [28 15]
 [40 21]
 [47 22]]
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-7-035238f160d1> in <module>
     10 MA1_MA2 = MA1.dot(MA2)
     11 print(MA1_MA2)
---> 12 MA2_MA1 = MA2.dot(MA1)
     13 print(MA2_MA1)

ValueError: shapes (3,2) and (5,3) not aligned: 2 (dim 1) != 5 (dim 0)
A = np.array([[7,8,9,10,11],[5,7,6,5,4]])
B = np.array([[1],[3],[2],[1],[8]])
print(A.shape)
print(B.shape)
(2, 5)
(5, 1)
A.dot(B)
array([[147],
       [ 75]])
B.dot(A)
ValueError: shapes (5,1) and (2,5) not aligned: 1 (dim 1) != 2 (dim 0)
matriz=np.array([[1,3,5],
                [5,6,7],
                [10,11,13]])
vector=np.array([[1,2,4],[3,6,5]])

vector.dot(matriz)
array([[ 51,  59,  71],
       [ 83, 100, 122]])
ValueError                                Traceback (most recent call last)
c:\Users\jvent\Documents\Python Scripts\Miner_Stat\Python\notebook_pruebas.py in 
----> 98 matriz.dot(vector)

ValueError: shapes (3,3) and (2,3) not aligned: 3 (dim 1) != 2 (dim 0)

Podemos usar las matrices usadas para la clase como ejemplo de matrices no cuadradas en las cuales no se cumple la propidad conmutativa ya que no tienen la misma cantidad de columnas y de filas al hacer la operación en diferente orden.



Ejercicio:

A = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
B = np.array([[2,3],[5,7],[11,13]])
A_tB = A.dot(B)
tB_tA = B.T.dot(A.T)
print(A_tB)
print(tB_tA)
------------------------------------
# Output:
[[ 45  56]
 [ 99 125]
 [153 194]
 [207 263]]
[[ 45  99 153 207]
 [ 56 125 194 263]]