Podemos y debemos pensar a las matrices como transformaciones lineales

Por si no entendieron . Lo que el profe quiso transmitir es que las matrices aplicadas a vectores se les puede ver como una transformacion lineal a ese vector . En este caso la transformacion es una rotacion en el sentido antihorario .

Explicación para los que se inclinan más por el fundamento matemático:
Sea AxB=C
El producto interno entre Anxm y Boxp dónde n,o son las filas y m,p son las columnas, para que AxB pueda existir cómo producto, se debe cumplir que n=o, y las dimensiones de la matriz resultante © será siempre nxp, entonces, si vas probando a lápiz y papel con dimensiones que a ti se te ocurran (pares dimensionales que cumplan con la condicion de producto interno) te vas a dar cuenta que todas las operaciones tranforman, o bien a la primera matriz o a la segunda, la única excepción a esta regla, es que ambas matrices sean cuadradas, lo cuál nos deja la siguiente conclusión
Las matrices son intrínsecamente transformaciones lineales en dónde el espacio es transformado con ciertas excepciones

Básicamente lo que hace el profe Sebastian es mostrarnos el resultado de la ecuación de un sistema de ecuaciones lineal con dos incógnitas A*x = b como se ve en la imagen. Donde A es la matriz [[-1,3], [2,-2]], x es el vector columna [[2],[1]] (graficado en azul) y b es el vector columna [[1], [2]] obtenido como respuesta (graficado en naranja).

El tiene que aplicar la función flatten() porque la función que él creó graficarVectores() no acepta vectores columna o matrices “normales”.

Sería genial ver a este profe en todos los cursos de machine learning.

Para los que están trabajando con Google Colab, el método que uso para trabajar con archivos en carpetas internas es el siguiente:

Importar drive en el espacio de trabajo y vincular con su cuenta de google:

from google.colab import drive
drive.mount('/content/drive')

Aquí para vincular les pedirá un código de acceso que obtendrán del link que se les mostrará al momento de ejecutar el código. Con esto ya están listos para importar el archivo:

%run 'ubicacion archivo drive'

En mi caso para la función graficarVectores, lo encuentro así:

%run '/content/drive/My Drive/Mau/cursos/Álgebra Lineal Aplicada para Machine Learning/funciones_auxiliares/graficarVectores.ipynb'

Y listo, ya pueden trabajar con su función.

Notebook de la función para graficar:

# Recibirá los vectores, los colores y el nivel de trasparencia con el cual trabajaremos 

def graficarVectores(vecs, cols, alpha = 1):
    
    # Agregamos el eje vertical. Este se cruzará en x = 0, el color será gris y el orden de z será 0 
    plt.axvline(x = 0, color = "grey", zorder = 0)
    # Agregamos el eje horizontal. Este se cruzará en y = 0, el color será gris y el orden de z será 0 
    plt.axhline(y = 0, color = "grey", zorder = 0)
    
    # Ahora ara cada uno de los vectores en el parámetro 
    for i in range(len(vecs)):
        # Tomaremos que la x es la concatenación de esos valores como 0 0 que es lo que estamos tomando como punto de origen 
        # Después de agregar el 0 0 le concatenamos el vector i 
        x = np.concatenate([[0,0], vecs[i]])
        # Vamos a graficar y agregamos todas las coordenadas
        plt.quiver([x[0]],
                   [x[1]],
                   [x[2]],
                   [x[3]],
                   # Los ángulos estarán expresados en xy y la escuela de unidad será xy 
                   angles = 'xy', scale_units = 'xy',
                   # La escala con la que graficaremos será 1 
                   scale = 1,
                   color = cols[i],
                   alpha = alpha
                  )

Para los que estan haciendo la prectica en Windows debe ir %run “funciones_auxiliares\graficarVectores.ipynb”

para entender mejor todas las implicaciones de esto les recomiendo este video

también este en español solo hay que buscarlo

Matrices

• Podemos ver a las matrices como transformaciones lineales del espacio sobre el que se aplican, es decir deforman los puntos del espacio sobre el que se aplican, trasladándolos, alargándolos o rotándolos.

Nota:
.flatten() → convierte el vector o matriz en un vector fila

Todo bien salvo que el espacio no esta girando para nada, se esta deformando de forma muy agresiva, imaginen que el vector unitario ‘i’ esta rotando en sentido antihorario como 120 grados duplicando su tamaño (aprox) para transformarse en ‘u’, y el ‘j’ también pero en sentido contrario casi triplicando su tamaño para transformarse en ‘v’. Al final que [2 1] y [1 2] -medidos desde el plano cartesiano original- se parezcan (como que tengan misma norma) y parezca que uno rotó es pura coincidencia.
.

Una **transformación lineal ** es básicamente una función, solo que toma como parámetro de entrada a un vector y devuelve como salida a otro vector.

Se dice que una matriz representa una transformación lineal, porque si multiplicas a una matriz por un vector, obtienes como resultado otro vector.

Introducción:

A las matrices las podemos pensar como transformaciones lineales que cuando las aplicamos a un espacio o a un vector generan una transformación. La transformación en el caso de un vector podría ser cuando se estira, se achica o incluso cuando generamos una rotación.

La función graficarVectores que sale en el video, le falta una parte: color = cols[i]
def graficarVectores(vecs, cols, alpha = 1):

plt.axvline(x = 0, color = "grey", zorder = 0)
plt.axhline(y = 0, color = "grey", zorder = 0)

for i in range(len(vecs)):
    x = np.concatenate([[0,0], vecs[i]])
    plt.quiver([x[0]],
               [x[1]],
               [x[2]],
               [x[3]],
               angles = 'xy', scale_units = 'xy',
               scale = 1,
               color = cols[i],
               alpha = alpha
              )

Así es como quedaría al final para que se ejecute correctamente.

Por si no entendieron . Lo quiso transmitir es que las matrices aplicadas a vectores se les puede ver como una transformación lineal a ese vector.
En este caso la transformación es una rotación en el sentido antihorario .

Este conjunto de videos me ayudo a tomar ritmo de lo que el profesor explica!
https://www.youtube.com/watch?v=kjBOesZCoqc&ab_channel=3Blue1Brown

Recomiendo el canal de youtube 3blue1brown. Tiene videos muy buenos como este para el cambio de base (parte de lo que vimos en esta clase).

Hola, si quieren correr el código desde Google colaboratory…

Para ubicarse en la carpeta donde esta el archivo ‘01 - Matrices y transformaciones lineales.ipynb’ qu en mi caso esta en ‘My Drive/Platzi/Algebra Lineal aplicada para ML’, deben usar:

from google.colab import drive
drive.mount('/content/drive/')
%cd '/content/drive/My Drive/Platzi/Algebra Lineal aplicada para ML'

Y posteriormente suponiendo que la carpeta ‘funciones_auxiliares’ este en la misma ubicación, utilizan:

%run "./funciones_auxiliares/graficarVectores.ipynb"

Código visto en clase:

# Importamos las bibliotecas

%matplotlib inline

import numpy as np
import matplotlib.pyplot as plt

# Definimos una matriz 

A = np.array([[-1,3], [2,-2]])
print(A)

# Generamos un vector

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

# Miramos la ruta en donde estamos
import os

os.getcwd()

# # Importamos nuestra función para graficar. 
%run ".\\Funciones auxiliares\graficarVectores.ipynb"

# Mostramos que es lo que tenemos como vector 
print(vector)

# Esta función nos devolverá como una fila nuestro vector que estaba definido como una columna   
print(vector.flatten())

# Imprimimos la matriz normal 
print(A)

# Ahora vemos como la función flatten nos muestra toda la matriz como una sola fila
print(A.flatten())

# Graficamos vectores con nuestra función y le daremos como parámetro el vector flatten.  
graficarVectores([vector.flatten()], cols = 'blue')

plt.xlim(-0.5, 3)
plt.ylim(-0.5, 2)


# Definimos nuestro vector transformado
vector_transformado = A.dot(vector)
print(vector_transformado)

# Graficamos vectores con nuestra función, de daremos como parámetro el vector flatten y el vector transformado 

graficarVectores([vector.flatten(), vector_transformado.flatten()],
                cols = ['blue', 'orange'])
plt.xlim(-0.5, 2.5)
plt.ylim(-0.5, 2.5)

# Obtenemos el determínate de una nuestra trasformación 
print(np.linalg.det(A))

# Obtenemos las normas de los vectores. 
print(np.linalg.norm(vector))
print(np.linalg.norm(vector_transformado))

un gran video que ayuda a complementar este tema es este.
https://www.youtube.com/watch?v=YJfS4_m_0Z8&list=PLIb_io8a5NB2DddFf-PwvZDCOUNT1GZoA&index=4

Hola, estoy usando Google Colab, tengo el mismo código del vídeo, pero no puedo graficar nada, alguien me puede ayudar? Este es el archivo:

https://colab.research.google.com/drive/1WYz5wln5xVu7vxrvE6DO9C_q5wXTuAEi

La operación de “flatten” se utiliza en el contexto de machine learning y procesamiento de imágenes principalmente para transformar matrices o tensores multidimensionales en un vector unidimensional. Esto se hace por varias razones:

1. Reducción de dimensionalidad: En el aprendizaje automático, a menudo se trabaja con datos en forma de matrices o tensores multidimensionales. Sin embargo, muchos algoritmos y modelos de machine learning, como las redes neuronales, requieren que los datos de entrada se presenten en forma de vectores unidimensionales. Flatten es una manera de hacer que los datos sean compatibles con estos modelos.

2. Capa de entrada de una red neuronal: En las redes neuronales convolucionales (CNN), que son ampliamente utilizadas en el procesamiento de imágenes, la capa de entrada se espera que sea un vector unidimensional. Flattening convierte la matriz de píxeles de una imagen en un vector, de modo que pueda ser procesada por las capas posteriores de la red neuronal.

3. Simplicidad en el procesamiento: Trabajar con datos en forma de vectores suele ser más sencillo y eficiente computacionalmente que trabajar con matrices o tensores. La operación de flatten simplifica el preprocesamiento de datos y el cálculo en muchas ocasiones.

Por ejemplo, considera una imagen en blanco y negro de 28x28 píxeles. Si se aplica flatten a esta imagen, se obtiene un vector de 784 elementos (28x28 = 784). Esto permite alimentar fácilmente esta imagen a una red neuronal que espera una entrada de 784 dimensiones.

En resumen, se utiliza la operación de flatten para convertir datos en formatos multidimensionales, como imágenes o matrices, en vectores unidimensionales, con el fin de que puedan ser procesados por algoritmos y modelos de machine learning que requieren entradas en forma de vectores.

%run funciones_auxiliares\graficarVectores.ipynb

definicion para windows

para los que tiene linux el comando para llamar a la funcion es:
%run "…//funciones_auxiliares//graficarVectores.ipynb"
es con doble slash (//) y no backslash (\).

Otra forma de graficar

# Vector original
v = np.array([1, 2])

# Matriz de traslación
T = np.array([[1, 0, 3], [0, 1, 2]])

# Aplicar la transformación
v_transformed = T.dot(np.append(v, 1))

# Graficar los vectores
plt.plot([0, v[0]], [0, v[1]], label='Original')
plt.plot([0, v_transformed[0]], [0, v_transformed[1]], label='Transformado')
plt.legend()
plt.grid(True)
plt.axis('equal')
plt.show()

El mejor contenido en algébra lineal y matemática en sí:
https://www.3blue1brown.com/topics/linear-algebra

El determinante sirve para tener un indicio de cual va a ser el efecto de la transformación. Si es negativo, el vector se rota y el coeficiente nos dice la magnitud en que cambiará.

Cree mi propia funcion para graficar vectores, con plotly, le coloque solo para 4 vectores, pero se puede modificar facilmente, para que reciba mas vectores.

import plotly.figure_factory as ff

def graficarVectoresplotly(vector1=[0, 0], vector2=[0, 0], vector3=[0, 0], vector4=[0, 0]):
    fig1 = ff.create_quiver([0], [0], [vector1[0]], [vector1[1]], scale=1, arrow_scale=0.1)
    fig2 = ff.create_quiver([0], [0], [vector2[0]], [vector2[1]], scale=1, arrow_scale=0.1)
    fig3 = ff.create_quiver([0], [0], [vector3[0]], [vector3[1]], scale=1, arrow_scale=0.1)
    fig4 = ff.create_quiver([0], [0], [vector4[0]], [vector4[1]], scale=1, arrow_scale=0.1)
    fig1.add_traces(data = fig2.data + fig3.data + fig4.data)
    fig1.update_layout(showlegend=False)
    fig1.show()

graficarVectoresplotly(vector, vector_transformado)

No se si sea porque yo trabajo en Ubuntu, pero me marcaba error al tratar de importar la función ‘graficarVector’ como lo hace el profe, así que yo lo pude hacer con la línea:

%run ‘./Funciones_auxiliares/my_functions.ipynb’

Suponeiendo que ‘my_functions.ipynb’ esta en la carpeta ‘Funciones_auxiliares’

Yo utilice este código en mac para que tomara la carpeta de funciones, espero y le sirva.
%run “…//funciones_auxiliares/graficarVectores.ipynb”