%matplotlib inline import numpy as np import matplotlib.pyplot as plt

%run './aux.py'

orange_light = '#FF9A13' blue_light = '#1190FF'

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

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

print( vector, vector.flatten(), sep='\n\n' )

print( A, A.flatten(), sep='\n\n' )

graficar_vectores([vector.flatten()], cols=[blue_light]) plt.xlim(-0.5,3) plt.ylim(-0.5,2)

vector_transformado = A.dot(vector) print(vector_transformado)

graficar_vectores([vector.flatten(),vector_transformado.flatten()], cols=[blue_light,orange_light]) plt.xlim(-0.5,3) plt.ylim(-0.5,2.5) plt.title(f"Comparacion vector y vector_transformado")

print(np.linalg.det(A))

print(np.linalg.norm(vector)) print(np.linalg.norm(vector_transformado))

X = np.array([[3,2], [4,1]]) print(X)

v = np.array([[1],[1]]) print(v)

u = X.dot(v) print(u)

graficar_vectores([u.flatten(),v.flatten()],cols=[orange_light,blue_light]) plt.xlim(-1,6) plt.ylim(-1,6)

lambda_1 = 5 lambda_1 * v

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

t = X.dot(s) print(t)

graficar_vectores([t.flatten(), s.flatten()], cols=[orange_light,blue_light]) plt.xlim(-3,3) plt.ylim(-3,3)

%matplotlib inline import numpy as np import matplotlib.pyplot as plt

X = np.array([[3,2],[4,1]]) print(X)

print(np.linalg.eig(X))

autovalores, autovectores = np.linalg.eig(X) print(autovalores,autovectores,sep='\n\n')

# Autovectores de la columna 0 print(autovectores[:,0])

# Autovectores de la columna 1 print(autovectores[:,1])

v = np.array([[-1],[2]])

Xv = X.dot(v)

v_np = autovectores[:,1]

graficar_vectores( [Xv.flatten(),v.flatten(),v_np.flatten()], cols=['blue','orange','green']) plt.xlim(-1.5,1.5) plt.ylim(-2.5,2.5)

import numpy as np

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

autovalores, autovectores = np.linalg.eig(A)

np.linalg.inv(autovectores)

print(autovalores,autovectores,sep='\n\n')

A_calc = autovectores.dot(np.diag(autovalores)).dot(np.linalg.inv(autovectores)) print(A_calc)

A = np.array([[3,2],[2,3]]) print( A, A == A.T, sep='\n\n' )

autovalores, autovectores = np.linalg.eig(A) print( autovalores, autovectores, sep='\n\n')

A_calc = autovectores.dot(np.diag(autovalores)).dot(autovectores.T) A_calc

print(A, A_calc,sep='\n\n')

import numpy as np

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

# U: vectores singulares izquierdo # D: valores singulares # V: vectores singulares derechos # full matrices True U,D,V = np.linalg.svd(Matriz_A, full_matrices=True)

print( U, np.diag(D), V, sep='\n\n')

# full matrices False U,D,V = np.linalg.svd(Matriz_A, full_matrices=False)

print( U, np.diag(D), V, sep='\n\n')

# Comprobamos que la descomposicion de la mat A = U.dot(np.diag(D)).dot(V) print(Matriz_A, A, sep='\n\n')

%matplotlib inline import numpy as np import matplotlib.pyplot as plt

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 (curva del espacio) prod_punto = matriz.dot(vector_x_y) #vectores u1 = [matriz[0, 0], matriz[1, 0]] v1 = [matriz[0, 1], matriz[1, 1]] graficar_vectores([u1, v1], cols=[vectorCol[0], vectorCol[1]]) plt.plot(prod_punto[0], prod_punto[1], 'purple', alpha = 0.7) plt.plot(-prod_punto[0], -prod_punto[1], 'green', alpha = 0.7)

A = np.array([[1,0],[0,1]]) B = np.array([[3,7],[5,2]]) print('Circulo unitario transformado:') graficarMatriz(A) plt.show() print('Circulo unitario transformado:') graficarMatriz(B)

A = np.array([[3,7],[5,2]]) U,D,V = np.linalg.svd(A) print(U)

print('Circulo unitario transformado:') graficarMatriz(np.array([[1,0],[0,1]])) plt.show() print('Primer rotacion V:') graficarMatriz(V) plt.show() print('Escala D:') graficarMatriz(np.diag(D).dot(V)) plt.xlim(-9,9) plt.ylim(-9,9) plt.show() print('Segunda rotacion U:') graficarMatriz(U.dot(np.diag(D).dot(V))) plt.xlim(-8,8) plt.ylim(-8,8) plt.show()

A = np.array([[3,7],[5,2]]) print('Circulo unitario transformado:') graficarMatriz(A)

A = np.array([[3,7],[5,2]]) print(A)

U,D,V = np.linalg.svd(A) print(D[0]) print(D[1])

A

A[:,:1],A[:,1:]

DU = np.diag(D).dot(U) u1 = DU[0] v1 = DU[1] print(f""" Producto interno np.diag(D).dot(U) {DU} Columna 0 de matriz A: {A[:,:1]} Columna 0 del producto interno np.diag(D).dot(U): {u1} Columna 1 de matriz A: {A[:,1:]} Columna 1 del producto interno np.diag(D).dot(U): {v1} """)

graficarMatriz(A) graficar_vectores([u1,v1], cols=['red','blue']) plt.text(3,5, r"$u_1$", size=18) plt.text(7,2, r"$v_1$", size=18) plt.text(-5,-4, r"$D(u_1)$", size=18) plt.text(-4,1, r"$D(v_1)$", size=18)

import numpy as np import matplotlib.pyplot as plt from PIL import Image # Por motivos practicos traeremos una imagen a travez de una url, en tu caso puedes usar una imagen desde tu archivo local import urllib.request

plt.style.use('classic') # Descargamos la imagen por enlace de google url_img="https://images-wixmp-ed30a86b8c4ca887773594c2.wixmp.com/f/074baf09-3775-4a65-b7e6-e4dac413425d/dfi5fhh-b04865c9-7606-4f18-881c-7dc33d0ee7a2.png/v1/fill/w_1280,h_1280,q_80,strp/bochi_the_rock_by_markiesan_dfi5fhh-fullview.jpg?token=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ1cm46YXBwOjdlMGQxODg5ODIyNjQzNzNhNWYwZDQxNWVhMGQyNmUwIiwiaXNzIjoidXJuOmFwcDo3ZTBkMTg4OTgyMjY0MzczYTVmMGQ0MTVlYTBkMjZlMCIsIm9iaiI6W1t7ImhlaWdodCI6Ijw9MTI4MCIsInBhdGgiOiJcL2ZcLzA3NGJhZjA5LTM3NzUtNGE2NS1iN2U2LWU0ZGFjNDEzNDI1ZFwvZGZpNWZoaC1iMDQ4NjVjOS03NjA2LTRmMTgtODgxYy03ZGMzM2QwZWU3YTIucG5nIiwid2lkdGgiOiI8PTEyODAifV1dLCJhdWQiOlsidXJuOnNlcnZpY2U6aW1hZ2Uub3BlcmF0aW9ucyJdfQ.YjwxU2Xi6NhC_-Sn3EiUPJauM3GX26c17WjlcFQIclU" name_img='bocchi.jpg' urllib.request.urlretrieve(url_img,name_img) imagen = Image.open('./bocchi.jpg') plt.imshow(imagen)

# Convertiremos la imagen a una escala de grises imagen_grey = imagen.convert('RGB') print(imagen_grey.getbands())

# Transformaremos la imagen en un vector imagen_mat = np.array(list(imagen_grey.getdata(band=0 )), float) print(imagen_mat)

# Transformamos el vector en una matriz imagen_mat.shape = (imagen_grey.size[1], imagen_grey.size[0]) print(imagen_mat) plt.imshow(imagen_mat)

# Vemos la dimension de la matriz print(imagen_mat.shape)

# Convertimos la imagen en una escala de grises plt.imshow(imagen_mat, cmap='gray');

# Cambiamos la relacion de pixeles de nuestra matrix partiendola por X cantidad imagen_mat_2 = imagen_mat / 5 plt.imshow(imagen_mat_2, cmap='gray',vmin=0, vmax=255) print('Escala de grises / 5\n',imagen_mat_2) plt.show() imagen_mat_2 = imagen_mat / 1 plt.imshow(imagen_mat_2, vmin=0, vmax=255) print('Escala normal / 1\n',imagen_mat_2) plt.show() imagen_mat_2 = imagen_mat / 2 plt.imshow(imagen_mat_2, vmin=0, vmax=255) print('Escala normal / 2\n',imagen_mat_2) plt.show() imagen_mat_2 = imagen_mat / 3 plt.imshow(imagen_mat_2, vmin=0, vmax=255) print('Escala normal / 3\n',imagen_mat_2) plt.show()

# Usamos pandas para ver los minimos y maximos que tienen nuestras matrices import pandas as pd df_img2 = pd.DataFrame(imagen_mat_2.flatten()) df_img = pd.DataFrame(imagen_mat.flatten())

# df_img.describe().round()

# df_img2.describe().round()

# Cargamos la imagen de Rock the Bocchi! a como estaba por defecto. imagen = Image.open('./bocchi.jpg') plt.imshow(imagen)

# Convertimos la imagen a escala de grises imagen_gr = imagen.convert('LA')

# Convertimos la imagen en una vector y luego en una matriz imagen_mat = np.array(list(imagen_gr.getdata(band=(0))),float) print('Vector de la imagen:',imagen_mat,'',sep='\n') imagen_mat.shape = (imagen_gr.size[1], imagen_gr.size[0]) print('Matriz de la imagen:',imagen_mat,'',sep='\n')

# Aplicamos la descomposicion SVD a la matriz de la imagen U,D,V = np.linalg.svd(imagen_mat)

# Comparamos las dimensiones de la matriz original con las matrices dadas por la descomposicion SVD print(f""" Matriz imagen: {imagen_mat.shape} U: {U.shape} D: {D.shape} V: {V.shape}""")

num_cols = [1, 20, 100] fig, ax = plt.subplots(3, 2, figsize=(15,17)) # Dibuja la imagen original en todas las subtramas de la columna 2 for i in range(3): ax[i][1].imshow(imagen_mat, cmap='gray') ax[i][1].set_title('Imagen original') # Genera las tres imágenes reconstruidas y dibujalas en las subtramas de la columna 1 for i in range(3): imagen_recons = np.ma :num_cols[i]]) * np.diag(D[0:num_cols[i]]) * np.matrix(V[:num_cols[i],:]) ax[i][0].imshow(imagen_recons, cmap='gray') ax[i][0].set_title(f'Imagen reconstruida con {num_cols[i]} columnas, filas y valores singulares') # Mostrar el gráfico plt.show()

import numpy as np # Suprimimos los numeros cercanos al 0 np.set_printoptions(suppress=True)

A = np.array([[2,3], [5,7], [11,13]]) print(A)

U,D,V = np.linalg.svd(A) print(f""" U: {U} D: {D} V: {V}""")

D_pse = np.zeros((A.shape[0], A.shape[1])).T print(D_pse)

print("Valores a remplazar en D_pse") print(np.linalg.inv(np.diag(D)))

# Guardamos los valores de la inversa de D en la matriz de ceros que creamos para la pseudoinversa de D; D_pse[:D.shape[0], :D.shape[0]] = np.linalg.inv(np.diag(D)) print(D_pse)

# Calculamos la pseudo inversa de A A_pse = V.T.dot(D_pse).dot(U.T) print(A_pse)

# Validamos si esta pseudoinversa es correcta A_pse_calc = np.linalg.pinv(A) print(A_pse_calc)

# Comprobamos que la pseudoinversa de la matriz A aplicada a la matriz A nos de la matriz Identidad print(A_pse.dot(A))

np.set_printoptions(suppress=False)

print(A_pse.dot(A))

%matplotlib inline import numpy as np import matplotlib.pyplot as plt

# Escribimos nuestro conjunto de ecuaciones x = np.linspace(-5,5,1000) y_1 = -4*x + 3 y_2 = 2*x + 5 y_3 = -3*x + 1

# graficamos los conjuntos de ecuaciones plt.plot(x,y_1) plt.plot(x,y_2) plt.plot(x,y_3) plt.xlim(-2,2.5) plt.ylim(-6,6)

# Valores de los coeficientes de las incognitas X e Y despejadas matriz = np.array([[4,1],[-2,1],[3,1]]) print(matriz)

# Realizamos la pseudoinversa de la matriz matriz_pse = np.linalg.pinv(matriz) print(matriz_pse)

# Definimos nuestro vector solucion del sistema de ecuaciones b = np.array([[3],[5],[1]]) print(b)

# Resolvemos X = A^+B resultado = matriz_pse.dot(b) print(resultado)

# graficamente la solucion del sistema sobredeterminados plt.plot(x,y_1) plt.plot(x,y_2) plt.plot(x,y_3) plt.xlim(-2,2.5) plt.ylim(-6,6) plt.scatter(resultado[0],resultado[1]) plt.show()

%matplotlib inline import numpy as np import matplotlib.pyplot as plt

# Establece una semilla para generar números aleatorios reproducibles np.random.seed(42) # Genera 200 valores aleatorios entre 0 y 3 y los asigna a x x = 3*np.random.rand(200) # Genera 200 valores aleatorios entre 0 y 1 y los asigna a y, y luego agrega un término de ruido y = 20*x + 2*np.random.randn(200) # Da forma a x e y para que sean matrices de columnas de tamaño (200,1) x = x.reshape(200,1) y = y.reshape(200,1)

# Concatena x e y en una matriz bidimensional xy (200,2) xy = np.hstack([x,y])

# Graficamos la dispercion de nuestros puntos plt.plot(xy[:,0],xy[:,1], '.') plt.show()

# Centra los datos restando la media de cada variable xy_centrado = xy - np.mean(xy, axis = 0)

# Graficamos la dispersion de nuestros puntos centrados plt.plot(xy_centrado[:,0],xy_centrado[:,1], '.') plt.show()

# Calcula los autovalores y autovectores de la matriz de covarianza de los datos centrados autovalores, autovectores = np.linalg.eig(xy_centrado.T.dot(xy_centrado))

graficar_vectores(autovectores.T, cols=['blue','red']) plt.plot(xy_centrado[:, 0], xy_centrado[:,1], '.');

graficar_vectores(autovectores.T, cols=['blue','red']) plt.plot(xy_centrado[:, 0], xy_centrado[:,1]/20, '.');

print(autovalores)

# Proyecta los datos centrados en el espacio de los autovectores para obtener los nuevos datos xy_nuevo xy_nuevo = autovectores.T.dot(xy_centrado.T)

graficar_vectores(autovectores.T, cols=['blue','red']) plt.plot(xy_nuevo[0,:], xy_nuevo[1,:]/10, '.')

from sklearn.datasets import fetch_olivetti_faces faces = fetch_olivetti_faces().images print(faces.shape)

import numpy as np # se crea una nueva matriz faces_flat con forma ("número de imágenes", "altura x ancho de la imagen"). faces_flat = np.array([face.flatten() for face in faces]) print(faces_flat.shape)

import matplotlib.pyplot as plt fig, axes = plt.subplots(5, 10, figsize=(15,8), subplot_kw = {'xticks' : [], 'yticks':[]}, gridspec_kw = dict(hspace = 0.05, wspace = 0.01)) for i, ax in enumerate(axes.flat): ax.imshow(faces_flat[i].reshape(64,64), cmap = "gray")

from sklearn.decomposition import PCA

faces_pca = PCA(n_components=0.5) faces_pca.fit(faces_flat)

filas = 1 # columnas representa el número de columnas necesarias para mostrar todos los componentes principales de la PCA en una cuadrícula de subplots columnas = faces_pca.n_components_ // filas fig, axes = plt.subplots(filas, columnas, figsize=(12,6), subplot_kw = {'xticks' : [], 'yticks':[]}, gridspec_kw = dict(hspace = 0.01, wspace = 0.01)) for i, ax in enumerate(axes.flat): ax.imshow(faces_pca.components_[i].reshape(64,64), cmap = "gray") plt.show() print(f"""Componentes principales: {faces_pca.n_components_}""")

componentes = faces_pca.transform(faces_flat) proyeccion = faces_pca.inverse_transform(componentes)

# Especificamos que en 5 filas queremos 10 imagenes de un sujeto dado por las nuevas componentes principales recoinstruido en base a la proyeccion filas = 5 columnas = 10 fig, axes = plt.subplots(filas, columnas, figsize=(15,8), subplot_kw = {'xticks' : [], 'yticks':[]}, gridspec_kw = dict(hspace = 0.01, wspace = 0.01)) for i, ax in enumerate(axes.flat): ax.imshow(proyeccion[i].reshape(64,64), cmap = "gray")

# Ahora queremos capturar el 80% de varianza de nuestros componentes faces_pca = PCA(n_components=0.8) faces_pca.fit(faces_flat)

filas = 3 # columnas representa el número de columnas necesarias para mostrar todos los componentes principales de la PCA en una cuadrícula de subplots columnas = faces_pca.n_components_ // filas fig, axes = plt.subplots(filas, columnas, figsize=(12,6), subplot_kw = {'xticks' : [], 'yticks':[]}, gridspec_kw = dict(hspace = 0.01, wspace = 0.01)) for i, ax in enumerate(axes.flat): ax.imshow(faces_pca.components_[i].reshape(64,64), cmap = "gray") plt.show() print(f"""Componentes principales: {faces_pca.n_components_}""")

componentes = faces_pca.transform(faces_flat) proyeccion = faces_pca.inverse_transform(componentes)

# Ahora imprimimos a los sujetos el el 80% de sus datos filas = 5 columnas = 10 fig, axes = plt.subplots(filas, columnas, figsize=(15,8), subplot_kw = {'xticks' : [], 'yticks':[]}, gridspec_kw = dict(hspace = 0.01, wspace = 0.01)) for i, ax in enumerate(axes.flat): ax.imshow(proyeccion[i].reshape(64,64), cmap = "gray")

faces_pca = PCA(n_components=0.999) faces_pca.fit(faces_flat) print(f""" Cantidad original de fotos que teniamos de cada persona: {faces_flat.shape[0]} Componentes principales para capturar el 99.9% de datos: {faces_pca.n_components_}""")