Transformaciones Lineales con Matrices: Efectos en el Círculo Unitario

Clase 7 de 18 • Curso de Álgebra Lineal Aplicada para Machine Learning

Resumen

¿Cómo se descomponen las matrices en transformaciones lineales?

Las matrices, cuando se piensan como transformaciones lineales, ofrecen una herramienta poderosa para manipular diferentes vectores en un espacio. Una matriz A puede descomponerse en otras tres matrices, cada una representando su propia transformación lineal. Entender sus efectos es crucial, ya que estas transformaciones repercuten de la misma manera sin importar los vectores a los que se apliquen. Vamos a sumergirnos en el mundo de las matrices y su relación con el círculo unitario.

¿Qué es el círculo unitario y por qué lo utilizamos?

El círculo unitario es una herramienta gráfica que ayuda a visualizar los efectos de estas transformaciones. Dicho de otro modo, se trata de un círculo centrado en el origen (0,0) con radio 1. Su papel es esencial en el estudio de las transformaciones lineales, ya que permite observar de forma clara los cambios que dichas transformaciones generan, tal como la rotación o el escalado de vectores dentro del espacio.

¿Cómo graficar el círculo unitario?

Para graficar el círculo unitario y aplicar transformaciones, necesitamos Python y la biblioteca numpy para cálculos y matplotlib para la visualización. El siguiente código muestra cómo lograr esto:

import numpy as np
import matplotlib.pyplot as plt

def graficar_matriz(matriz, vector_colores=['r', 'b']):
    # Definimos el círculo unitario
    x = np.linspace(-1, 1, 1000)
    y = np.sqrt(1 - x**2)
    
    # Transformación del círculo por la matriz
    x1 = matriz[0, 0] * x + matriz[0, 1] * y
    y1 = matriz[1, 0] * x + matriz[1, 1] * y
    
    x1_neg = matriz[0, 0] * x - matriz[0, 1] * y
    y1_neg = matriz[1, 0] * x - matriz[1, 1] * y
    
    # Graficamos los vectores transformados
    plt.plot(x1, y1, color='g', alpha=0.7)
    plt.plot(x1_neg, y1_neg, color='g', alpha=0.7)
    
    plt.axhline(0, color='black', lw=1)
    plt.axvline(0, color='black', lw=1)
    plt.xlim(-1.5, 1.5)
    plt.ylim(-1.5, 1.5)
    plt.gca().set_aspect('equal', adjustable='box')
    plt.show()

# Ejemplo con una matriz de identidad
matriz_identidad = np.array([[1, 0], [0, 1]])
graficar_matriz(matriz_identidad)

¿Cómo aplicar transformaciones sin modificar el gráfico original?

Al probar el efecto de diferentes matrices, es esencial luego visualizar cómo estas cambian el círculo unitario en tiempo real. Las matrices de diferentes valores cambian la forma del círculo original, visualizando el impacto de la transformación lineal aplicada. A continuación, se muestra cómo se implementa este concepto:

# Definimos una matriz
A = np.array([[3, 7], [5, 2]])

# Graficamos el círculo unitario original
graficar_matriz(np.eye(2))  # Matriz identidad

# Graficamos el círculo unitario transformado
graficar_matriz(A)

¿Qué observamos con las matrices aplicadas?

Al aplicar la matriz A, observamos cómo los vectores base del círculo unitario original (los puntos cardinales) se transforman. Por ejemplo:

El vector (1, 0) se desplaza de su posición original.
El vector (0, 1) también cambia, conforme a los componentes de A, obteniendo un nuevo espacio transformado.

Esta aplicación práctica nos permite ver cómo actúa la matriz sobre los vectores del círculo y nos ofrece una comprensión palpable de las transformaciones lineales.

Recomendaciones prácticas

Para entender y visualizar de manera efectiva las transformaciones lineales mediante matrices:

Practica con diversas matrices: Cambia los valores de las matrices para observar distintos efectos en el círculo unitario.
Documenta tus observaciones: Mantén un registro de cómo cambian los vectores con diferentes matrices, te ayudará a entender patrones.
Explora visualmente y analíticamente: Usa las gráficas para ver el cambio y luego calcula los valores para confirmar lo que ves.
Profundiza en la teoría: Revisa la teoría matemática detrás de estas transformaciones para una comprensión más sólida.

Estas recomendaciones no solo abrillantan tus habilidades matemáticas sino también potencian tu capacidad de programación aplicada a problemas matemáticos.

¡Continúa explorando y ampliando tu conocimiento en transformaciones lineales!

Sergio Rubiano

student•

en vez de hacer

graficarMatriz(np.array([[1,0],[0,1]]))

pueden hacer esto :

graficarMatriz(np.eye(2))

ya que numpy nos permite devolver una matriz identidad con np.eye

Julián Cárdenas

student•

Sii es exactamente lo mismo!

Matias Alexander Ibarra Trujillo

student•

matematicamente un circulo es x^2+y^2=r donde r es el radio, como es el circulo unitario r=1, x^2+y^2=1. al despejar y queda la expresion: sqrt(1-x^2) x va de -1 a 1 ya qiue es el dominio de la funcion, sabemos que la raiz cuadrada sqrt(x) esta definida en lo reales para los valores de x>=0 si fuera un negativo da un numero complejo. Entonces tenemos que hacer 1-x^2>=0 x^2>=1 -1<x< 1 al modificar x e y ya sea diviendolos o restando a sus valor el circulo se puede transformar en parabola, elipse, hiperbola u otra

johan Stever Rodriguez Molina

student•

esta errorena la ecuación del circulo amigo. Es x^2+ y^2=r^2

JOSE MANRIQUE

student•

gracias por el aporte

Erick Herrera

student•

Como dice el profesor una matriz es una transformación lineal. Esta transformación para ser aplicada se usa el producto punto. Si analizan lo que escribió el profesor en #circulo unitario transformado, es el producto punto. Hice la misma función pero aplicando el producto punto directamente, si es que le sirve a alguien. Un abrazo

def graficarMatriz(matriz, vectorCol=['red', 'blue']):
    
    #círculo unitario
    x = np.linspace(-1, 1, 100000)
    y = np.sqrt(1 - (x**2))
    
    #Transformamos x e y en una matriz de vectores x, y
    vector_x_y = np.array([x, y])
    
    # círculo unitario transformado
    prod_punto = matriz.dot(vector_x_y)
    
    #vectores
    u1 = [matriz[0, 0], matriz[1, 0]]
    v1 = [matriz[0, 1], matriz[1, 1]]
    
    graficarVectores([u1, v1], cols=[vectorCol[0], vectorCol[1]])
    
    plt.plot(prod_punto[0], prod_punto[1], 'orange', alpha = 0.7)
    plt.plot(-prod_punto[0], -prod_punto[1], 'green', alpha = 0.7)

Aaron Fabrizio Calderon Guillermo

student•

Genial! Sí funciona

Adrian Alberto Casas Lopez

student•

En clases anteriores se ha explicado que para realizar la transformación se debe de ejecutar el producto normal del vector con la matriz

vector_transformado = A.dot(vector)

durante esta clase no me queda muy claro en que mometo se realiza el producto normal lo que observo es que solo esta graficando dos vectores para el unitario y otros dos vectores para el unitario transformado, ¿en que momento se ejecuto el proucto normal?

alexander garcia castañeda

student•

después de un rato logré entender, me imagino que ya ud sabe pero lo comento para los siguientes, x e y en este caso, no son vectores (a pesar de que para numpy sean array), están representando funciones. una función y=f(x) (en este caso el circulo) está compuesta de infinitos puntos (x,y) en este caso, se está realizando el producto punto (interno, bruto, normal, como lo quiera llamar) de cada uno de los pares ordenados (x,y) pertenecientes a la función del circulo por la matriz de transformación, si sabe como realizar el producto punto manualmente, probablemente se de cuenta de que los renglones que el escribió de x1, y1, x1_neg, y1_neg corresponden al desarrollo del producto punto del punto (x,f(x))

Yonatan Efraín Jara Boza

student•

Como dice Alexander, es en x1 y1 x1_neg y1_neg donde se esta realizando el producto interno de matrices, salvo que no lo hace a traves de la libreria de numpy como estabamos acostumbrados sino por el algoritmo "a mano" de operar filas con columnas; eso lo hace para un punto (x, y). La principal diferencia con este ejercicio es que es la primera vez que estamos dibujando una figura (que pide de input las coordenadas en listas separadas) y por ello tal procedimiento.

Sara Yaneth Contreras Elías

student•

Gabriel Salvador

student•

Adjunto el código para graficar matriz

def graficarMatriz(matriz, vectorCol=['red','blue']):
  #circulo unitario
  x=np.linspace(-1,1,1000000)
  y=np.sqrt(1-x**2)

  #circulo unitario transformado
  x1 = matriz[0,0]*x + matriz[0,1]*y
  y1 = matriz[1,0]*x + matriz[1,1]*y
  x1_neg = matriz[0,0]*x - matriz[0,1]*y
  y1_neg = matriz[1,0]*x - matriz[1,1]*y

  #vectores
  u1 = [matriz[0,0], matriz[1,0]]
  v1 = [matriz[0,1], matriz[1,1]]

  graficarVectores([u1,v1], cols=[vectorCol[0],vectorCol[0]])

  plt.plot(x1,y1, 'green', alpha =0.7)
  plt.plot(x1_neg,y1_neg, 'green', alpha =0.7)

Darwin Osmar Palomino Jove

student•

Estoy usando github copilot y tmr, me escribio todo antes que Sebastian!!!! jajajaajj, genial curso

Julián Cárdenas

student•

Wow super interesante!

Jonathan Fernando Santana Quispillo

student•

NO se cual es el propósito de todo el circulo unitario transformado o los vectores. NO da una explicación mas detallada de que se hace :(

Orlando castellanos

student•

es que no necesita mas explicacion es solo un ejemplo para que puedas apreciar lo que hace la transformación, en este caso como transforma el circulo a un tipo de elipse

Alfonso Andres Zapata Guzman

student•

Mi funcion para graficar lo visto en clase con plotly.

import plotly.figure_factory as ff
import plotly.express as px

def graficarMatrizplotly(matriz, xlimit=[-5, 5], ylimit=[-5, 5]):
    
    #circulo unitario
    x = np.linspace(-1,1, 10000)
    y = np.sqrt(1-(x**2))
    
    #circulo unitario transformado
    x1 = matriz[0,0]*x + matriz[0,1]*y
    y1 = matriz[1,0]*x + matriz[1,1]*y
    x1_neg = matriz[0,0]*x - matriz[0,1]*y
    y1_neg = matriz[1,0]*x - matriz[1,1]*y
    
    #vectores
    u1 = [matriz[0,0], matriz[1,0]]
    v1 = [matriz[0,1], matriz[1,1]]
    
    fig1 = ff.create_quiver([0], [0], [u1[0]], [u1[1]], scale=1, arrow_scale=0.1
    )
    fig2 = ff.create_quiver([0], [0], [v1[0]], [v1[1]], scale=1, arrow_scale=0.1
    )
    fig3 = px.line(x=x1, y=y1)
    
    fig4 = px.line(x=x1_neg, y=y1_neg)
    
    fig1.add_traces(
        data=fig2.data + fig3.data + fig4.data
    )
    fig1.update_layout(showlegend=False)
    fig1.update_xaxes(zeroline=True, zerolinewidth=2, zerolinecolor="red", range=xlimit)
    fig1.update_yaxes(
        zeroline=True,
        zerolinewidth=2,
        zerolinecolor="red",
        range=ylimit,
        scaleanchor="x",
        scaleratio=1,
    )
    
    fig1.show()

graficarMatrizplotly(np.array([[1, 0], [0, 1]]), xlimit=[-1.5, 1.5], ylimit=[-1.5, 1.5])
graficarMatrizplotly(A, xlimit=[-8, 8], ylimit=[-8, 8])

PD: Si no te queda igual, es porque debes correr primero

import plotly.graph_objects as go
import plotly.io as pio

pio.templates['new_template'] = go.layout.Template()
pio.templates['new_template']['layout']['font'] = {'family': 'verdana', 'size': 16, 'color': 'white'}
pio.templates['new_template']['layout']['paper_bgcolor'] = 'black'
pio.templates['new_template']['layout']['plot_bgcolor'] = 'black'
pio.templates['new_template']['layout']['xaxis'] = {'title_standoff': 10, 'linecolor': 'black', 'mirror': True, 'gridcolor': '#EEEEEE'}
pio.templates['new_template']['layout']['yaxis'] = {'title_standoff': 10, 'linecolor': 'black', 'mirror': True, 'gridcolor': '#EEEEEE'}
pio.templates['new_template']['layout']['legend_bgcolor'] = 'rgb(117, 112, 179)'
pio.templates['new_template']['layout']['height'] = 700
pio.templates['new_template']['layout']['width'] = 1000
pio.templates['new_template']['layout']['autosize'] = False

pio.templates.default = 'new_template'

Orlando Villegas Bello

student•

Aquí les dejo un pequeño cambio que hice en la función graficarMatriz

def plot_operator(M, colors=['red', 'blue']):
    
    # Se define el circulo unitario
    theta = np.linspace(0, 2*np.pi, 5000)
    r = 1
    
    x0 = r * np.cos(theta)
    y0 = r * np.sin(theta)
    
    # transformacion
    x1 = M[0, 0] * x0 + M[0, 1] * y0
    y1 = M[1, 0] * x0 + M[1, 1] * y0
    
    # vectors
    # Vectores que generan el espacio
    u1 = M[:, 0]
    v1 = M[:, 1]

    plot_vector([u1, v1], colors)
    plt.plot(x1, y1, 'green', alpha=0.7)

Joseph Humberto Cueva

student•

Tengo este error al ejecutar mi código.

Circulo unitario:
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-5-796d83716487> in <module>()
      1 print('Circulo unitario:')
----> 2 graficarMatriz(np.array([[1, 0],[0, 1]]))
      3 plt.xlim(-1.5, 1,5)
      4 plt.ylim(-1.5, 1,5)
      5 plt.show()

<ipython-input-2-b2a3de1aa38f> in graficarMatriz(matriz, vectorCol)
     14   v1 = [matriz [0,1], matriz[1,1]]
     15 
---> 16   graficarVectores([u1, v1], cols = [vectorCol[0], vectorCol[1]])
     17   plt.plot(x1, y1, 'green', alpha = 0.7)
     18   plt.plot(x1_neg, y1_neg, 'green', alpha = 0.7)

NameError: name 'graficarVectores' is not defined

Alguien me podría explicar que esta mal para poder corregirlo.

def graficarMatriz(matriz, vectorCol = ['red', 'blue']):
  #circulo unitario
  x = np.linspace(-1, 1, 100000)
  y = np.sqrt(1 - (x**2))

  #ciruclo unitario transformado 
  x1 = matriz[0, 0]*x + matriz [0, 1]*y
  y1 = matriz[1, 0]*x + matriz [1, 1]*y
  x1_neg = matriz[0, 0]*x - matriz[0, 1]*y
  y1_neg = matriz[1, 0]*x - matriz[1, 1]*y

  #vectores
  u1 = [matriz[0, 0], matriz[1, 0]]
  v1 = [matriz [0,1], matriz[1,1]]

  graficarVectores([u1, v1], cols = [vectorCol[0], vectorCol[1]])
  plt.plot(x1, y1, 'green', alpha = 0.7)
  plt.plot(x1_neg, y1_neg, 'green', alpha = 0.7)

Alex Camacho

teacher•

Al menos en el código que nos compartiste graficarVectores() no veo la función creada, en caso de estar en otro lado, se esta importando correctamente?

Elias Demian Lazo

student•

Es porque la función "graficarVectores" no esta definida, tenes que crearla o importarla si la tenes en otra parte como tiene el profe en un apartado de funciones auxiliares.

Julián Cárdenas

student•

Para el que le interese la transformación de cizallamiento

Crear un cuadrado como ejemplo (4 puntos)

cuadrado = np.array([[0, 0], [1, 0], [1, 1], [0, 1]])

Definir una matriz de cizallamiento en el eje x

shear_x_matrix = np.array([[1, 0.5], [0, 1]]) # 0.5 es el factor de cizallamiento

Aplicar la transformación de cizallamiento al cuadrado

cuadrado_cizallado_x = np.dot(cuadrado, shear_x_matrix)

Definir una matriz de cizallamiento en el eje y

shear_y_matrix = np.array([[1, 0], [0.5, 1]]) # 0.5 es el factor de cizallamiento

Aplicar la transformación de cizallamiento al cuadrado

cuadrado_cizallado_y = np.dot(cuadrado, shear_y_matrix)

Dibujar los cuadrados original y cizallados

plt.figure(figsize=(12, 4))

plt.subplot(131) plt.plot(cuadrado[:, 0], cuadrado[:, 1], label='Cuadrado Original') plt.title('Cuadrado Original') plt.axis('equal')

plt.subplot(132) plt.plot(cuadrado_cizallado_x[:, 0], cuadrado_cizallado_x[:, 1], label='Cizallamiento en X') plt.title('Cizallamiento en el Eje X') plt.axis('equal')

plt.subplot(133) plt.plot(cuadrado_cizallado_y[:, 0], cuadrado_cizallado_y[:, 1], label='Cizallamiento en Y') plt.title('Cizallamiento en el Eje Y') plt.axis('equal')

plt.tight_layout() plt.show()

Mauricio Escobar

student•

Hola 👋 hice algunos ajustes a ambas funciones, de tal forma que se pueda especificar:

vectorCol (lista de colores)
lims => (xlim / ylim) recibe una lista de números
leyendas => (plt.legend) recibe una lista de strings
loc => (parámetro de legend para indicar posición de las leyendas) recibe los parámetros comunes de loc

Los tres últimos son opcionales. No es la graan cosa pero ayudan a tener una mejor visualización:

def graficarVectores(vectores , colores , alpha = 0.7, lims = None, leyendas = None, loc = None):

    plt.axhline(y= 0 , color = 'grey' , linestyle = '--', zorder= 0, alpha = 0.3) #horizontal
    plt.axvline(x= 0 , color = 'grey' , linestyle = '--', zorder= 0, alpha = 0.3) #vertical

    for i in  range(len(vectores)):
        x = np.concatenate([[0,0], vectores[i]])
        plt.quiver([x[0]],
                   [x[1]],
                   [x[2]],
                   [x[3]],
                   angles= 'xy' , scale_units= 'xy', scale= 1,
                   color = colores[i],
                   alpha = alpha,
                   label = leyendas[i] if leyendas != None and i < len(leyendas) else None
                   )
    if lims != None:
         plt.xlim(lims[0], lims[1])
         plt.ylim(lims[0], lims[1])
         
    if leyendas != None:
         plt.legend(loc = loc)
         
    plt.grid(alpha= 0.4)
     
def graficarMatriz(matriz , vectorCol=['blue', 'red'],lims = None, leyendas = None, loc = "best" ):

  #círculo unitario
  x = np.linspace(-1, 1 , 100000)
  y = np.sqrt(1-(x**2))

  # círculo unitario transformado
  
       
  x1 = matriz[0,0] * x + matriz[0,1] * y #positivas
  y1 = matriz[1,0] * x + matriz[1,1] * y

      
  x1_neg = matriz[0,0] * x - matriz[0,1] * y #negativas
  y1_neg = matriz[1,0] * x - matriz[1,1] * y

  #vectores
       # coordenadas x
  u1 = [matriz[0,0], matriz[1,0]]
       # coordenadas y
  v1 = [matriz[0,1], matriz[1,1]]
  
  if lims != None:
         plt.xlim(lims[0], lims[1])
         plt.ylim(lims[0], lims[1])

  

  graficarVectores(vectores = [u1 , v1], colores = [vectorCol[0], vectorCol[1]], leyendas= leyendas, lims = lims, loc = loc)

  plt.plot(x1,y1, 'green', alpha = 0.7)
  plt.plot(x1_neg, y1_neg, 'green', alpha = 0.7)

Jhon Freddy Tavera Blandon

student•

-La función np.linalg.svd()devuelve tres valores: U, Sy V. La matriz U contiene los autovectores izquierdos, la matriz S es una matriz diagonal con los valores singulares en el orden descendente y la matriz V contiene los autovectores derechos.

Es importante tener en cuenta que en el caso de una matriz no cuadrada, la matriz S no será una matriz cuadrada, sino que tendrá dimensiones mxn, donde m es el número de filas de M yn es el número de columnas de M.

Recuerda que para utilizar NumPy, debes tener instalada la biblioteca en tu entorno de Python. Puedes instalarla usando el comando pip install numpysi aún no lo has hecho.

import numpy as np

# Definir una matriz no cuadrada
M = np.array([[1, 2, 3],
              [4, 5, 6]])

# Calcular la descomposición SVD
U, S, V = np.linalg.svd(M)

# Imprimir las matrices U, S y V
print("Matriz U:")
print(U)
print("Matriz S:")
print(np.diag(S))
print("Matriz V:")
print(V)

rusbel bermúdez rivera

student•

Aqui un interesante articulo para profundizar sobre el circulo unitario https://www.lifeder.com/circulo-unitario/

Sebastián Andrade

student•

Cual es el proposito de x1_neg y y1_neg en la funcion de graficar matriz?

Orlando castellanos

student•

como que grafica el circulo por partes primero los positivos luego los negativos

Ricardo Ruiz

student•

Mi gráfica

Ricardo Ruiz

student•

Mi gráfica

Antonio Demarco Bonino

student•

Cambie el código para que los círculos queden uno al lado del otro y se vea que tanto han cambiado:

# Definir las dos matrices que proporcionaste
unit_matrix = np.array([[1, 0], [0, 1]])  # Círculo unitario
new_matrix = np.array([[3, 7], [5, 2]])   # Nueva matriz para la transformación

# Crear una figura con dos subplots (1 fila, 2 columnas)
fig, axs = plt.subplots(1, 2, figsize=(12, 6))  # 1 fila, 2 columnas

# Primer subplot: Círculo unitario
axs[0].set_title("Círculo unitario")
axs[0].set_xlim(-8, 8)
axs[0].set_ylim(-8, 8)
plt.sca(axs[0])  # Configurar el primer subplot como el actual
graficarMatriz(unit_matrix, vectorCol=['red', 'blue'])  # Llamar a la función con el círculo unitario

# Segundo subplot: Círculo unitario transformado
axs[1].set_title("Círculo unitario transformado")
axs[1].set_xlim(-8, 8)
axs[1].set_ylim(-8, 8)
plt.sca(axs[1])  # Configurar el segundo subplot como el actual
graficarMatriz(new_matrix, vectorCol=['red', 'blue'])  # Llamar a la función con el círculo transformado

# Ajustar la disposición de los subplots para que se vean bien
plt.tight_layout()

# Mostrar los gráficos
plt.show()

Thomas Gonzalez Rodrigues

student•

hola aquí les dejo el codigo para graficar la matrix con algunas modificaciones

def plot_matrix(matrix, vectorCol=['red', 'blue']):
    #unitary circle
    x = np.linspace(-1,1,100000)
    y = (1-(x**2))**0.5

    #transform circle
    x1 = matrix[0,0]*x+matrix[0,1]*y
    y1 = matrix[1,0]*x+matrix[1,1]*y

    x1_neg = matrix[0,0]*x-matrix[0,1]*y
    y1_neg = matrix[1,0]*x-matrix[1,1]*y

    #vectors
    u1 = [matrix[0,0],matrix[1,0]] #base vector
    v1 = [matrix[0,1],matrix[1,1]]

    plt.figure(figsize=(8,8))
    plt.axis('equal') #make the numberline equal
    plot_vectors([u1,v1],cols=vectorCol)

    u1_len=np.linalg.norm(u1)
    v1_len=np.linalg.norm(u1)

    base_v_x = [1*u1_len,0]
    base_v_y = [0,1*v1_len]

    plot_vectors([base_v_x,base_v_y],cols=vectorCol,alpha=0.5) #plot basis vectors

    plt.plot(x1,y1,'green',alpha=0.7)
    plt.plot(x1_neg,y1_neg,'green',alpha=0.7)