%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)
[[-1 3]
[ 2 -2]]
# Vector
vector = np.array([[2],[1]])
print(vector)
[[2]
[1]]
print(
vector,
vector.flatten(),
sep='\n\n'
)
[[2]
[1]]
[2 1]
print(
A,
A.flatten(),
sep='\n\n'
)
[[-1 3]
[ 2 -2]]
[-1 3 2 -2]
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)
[[1]
[2]]
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))
-4.0
print(np.linalg.norm(vector))
print(np.linalg.norm(vector_transformado))
2.23606797749979
2.23606797749979
X = np.array([[3,2], [4,1]])
print(X)
[[3 2]
[4 1]]
v = np.array([[1],[1]])
print(v)
[[1]
[1]]
u = X.dot(v)
print(u)
[[5]
[5]]
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)
[[-1]
[ 2]]
t = X.dot(s)
print(t)
[[ 1]
[-2]]
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)
[[3 2]
[4 1]]
print(np.linalg.eig(X))
(array([ 5., -1.]), array([[ 0.70710678, -0.4472136 ],
[ 0.70710678, 0.89442719]]))
autovalores, autovectores = np.linalg.eig(X)
print(autovalores,autovectores,sep='\n\n')
[ 5. -1.]
[[ 0.70710678 -0.4472136 ]
[ 0.70710678 0.89442719]]
# Autovectores de la columna 0
print(autovectores[:,0])
[0.70710678 0.70710678]
# Autovectores de la columna 1
print(autovectores[:,1])
[-0.4472136 0.89442719]
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)
[[3 2]
[4 1]]
autovalores, autovectores = np.linalg.eig(A)
np.linalg.inv(autovectores)
print(autovalores,autovectores,sep='\n\n')
[ 5. -1.]
[[ 0.70710678 -0.4472136 ]
[ 0.70710678 0.89442719]]
A_calc = autovectores.dot(np.diag(autovalores)).dot(np.linalg.inv(autovectores))
print(A_calc)
[[3. 2.]
[4. 1.]]
A = np.array([[3,2],[2,3]])
print(
A,
A == A.T,
sep='\n\n'
)
[[3 2]
[2 3]]
[[ True True]
[ True True]]
autovalores, autovectores = np.linalg.eig(A)
print(
autovalores,
autovectores,
sep='\n\n')
[5. 1.]
[[ 0.70710678 -0.70710678]
[ 0.70710678 0.70710678]]
A_calc = autovectores.dot(np.diag(autovalores)).dot(autovectores.T)
A_calc
print(A, A_calc,sep='\n\n')
[[3 2]
[2 3]]
[[3. 2.]
[2. 3.]]
import numpy as np
Matriz_A = np.array([[1,2,3],[3,4,5]])
print(Matriz_A)
[[1 2 3]
[3 4 5]]
# 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')
[[-0.46410668 -0.88577931]
[-0.88577931 0.46410668]]
[[7.97638869 0. ]
[0. 0.61418515]]
[[-0.39133557 -0.5605708 -0.72980603]
[ 0.8247362 0.13817999 -0.54837623]
[ 0.40824829 -0.81649658 0.40824829]]
# full matrices False
U,D,V = np.linalg.svd(Matriz_A, full_matrices=False)
print(
U,
np.diag(D),
V,
sep='\n\n')
[[-0.46410668 -0.88577931]
[-0.88577931 0.46410668]]
[[7.97638869 0. ]
[0. 0.61418515]]
[[-0.39133557 -0.5605708 -0.72980603]
[ 0.8247362 0.13817999 -0.54837623]]
# Comprobamos que la descomposicion de la mat
A = U.dot(np.diag(D)).dot(V)
print(Matriz_A, A, sep='\n\n')
[[1 2 3]
[3 4 5]]
[[1. 2. 3.]
[3. 4. 5.]]
%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)
Circulo unitario transformado:
Circulo unitario transformado:
A = np.array([[3,7],[5,2]])
U,D,V = np.linalg.svd(A)
print(U)
[[-0.85065081 -0.52573111]
[-0.52573111 0.85065081]]
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()
Circulo unitario transformado:
Primer rotacion V:
Escala D:
Segunda rotacion U:
A = np.array([[3,7],[5,2]])
print('Circulo unitario transformado:')
graficarMatriz(A)
Circulo unitario transformado:
A = np.array([[3,7],[5,2]])
print(A)
[[3 7]
[5 2]]
U,D,V = np.linalg.svd(A)
print(D[0])
print(D[1])
8.7133796929634
3.3282148858288965
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}
""")
Producto interno np.diag(D).dot(U)
[[-7.41204348 -4.5808948 ]
[-1.74974611 2.83114868]]
Columna 0 de matriz A:
[[3]
[5]]
Columna 0 del producto interno np.diag(D).dot(U):
[-7.41204348 -4.5808948 ]
Columna 1 de matriz A:
[[7]
[2]]
Columna 1 del producto interno np.diag(D).dot(U):
[-1.74974611 2.83114868]
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())
('R', 'G', 'B')
# Transformaremos la imagen en un vector
imagen_mat = np.array(list(imagen_grey.getdata(band=0 )), float)
print(imagen_mat)
[255. 255. 255. ... 216. 235. 211.]
# Transformamos el vector en una matriz
imagen_mat.shape = (imagen_grey.size[1], imagen_grey.size[0])
print(imagen_mat)
plt.imshow(imagen_mat)
[[255. 255. 255. ... 255. 255. 255.]
[255. 255. 255. ... 255. 255. 255.]
[255. 255. 255. ... 255. 255. 255.]
...
[ 33. 204. 255. ... 109. 23. 3.]
[215. 255. 237. ... 221. 187. 78.]
[255. 255. 255. ... 216. 235. 211.]]
# Vemos la dimension de la matriz
print(imagen_mat.shape)
(1280, 1280)
# 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()
Escala de grises / 5
[[51. 51. 51. ... 51. 51. 51. ]
[51. 51. 51. ... 51. 51. 51. ]
[51. 51. 51. ... 51. 51. 51. ]
...
[ 6.6 40.8 51. ... 21.8 4.6 0.6]
[43. 51. 47.4 ... 44.2 37.4 15.6]
[51. 51. 51. ... 43.2 47. 42.2]]
Escala normal / 1
[[255. 255. 255. ... 255. 255. 255.]
[255. 255. 255. ... 255. 255. 255.]
[255. 255. 255. ... 255. 255. 255.]
...
[ 33. 204. 255. ... 109. 23. 3.]
[215. 255. 237. ... 221. 187. 78.]
[255. 255. 255. ... 216. 235. 211.]]
Escala normal / 2
[[127.5 127.5 127.5 ... 127.5 127.5 127.5]
[127.5 127.5 127.5 ... 127.5 127.5 127.5]
[127.5 127.5 127.5 ... 127.5 127.5 127.5]
...
[ 16.5 102. 127.5 ... 54.5 11.5 1.5]
[107.5 127.5 118.5 ... 110.5 93.5 39. ]
[127.5 127.5 127.5 ... 108. 117.5 105.5]]
Escala normal / 3
[[85. 85. 85. ... 85. 85.
85. ]
[85. 85. 85. ... 85. 85.
85. ]
[85. 85. 85. ... 85. 85.
85. ]
...
[11. 68. 85. ... 36.33333333 7.66666667
1. ]
[71.66666667 85. 79. ... 73.66666667 62.33333333
26. ]
[85. 85. 85. ... 72. 78.33333333
70.33333333]]
# 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')
Vector de la imagen:
[255. 255. 255. ... 213. 232. 208.]
Matriz de la imagen:
[[255. 255. 255. ... 255. 255. 255.]
[255. 255. 255. ... 255. 255. 255.]
[255. 255. 255. ... 255. 255. 255.]
...
[ 33. 204. 255. ... 106. 20. 1.]
[215. 255. 237. ... 218. 184. 75.]
[255. 255. 255. ... 213. 232. 208.]]
# 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}""")
Matriz imagen:
(1280, 1280)
U:
(1280, 1280)
D:
(1280,)
V:
(1280, 1280)
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)
[[ 2 3]
[ 5 7]
[11 13]]
U,D,V = np.linalg.svd(A)
print(f"""
U:
{U}
D:
{D}
V:
{V}""")
U:
[[-0.18499741 -0.47276624 -0.86154979]
[-0.44249308 -0.74271297 0.50257071]
[-0.87748267 0.4742041 -0.07179582]]
D:
[19.40321383 0.71783924]
V:
[[-0.63055377 -0.77614557]
[ 0.77614557 -0.63055377]]
D_pse = np.zeros((A.shape[0], A.shape[1])).T
print(D_pse)
[[0. 0. 0.]
[0. 0. 0.]]
print("Valores a remplazar en D_pse")
print(np.linalg.inv(np.diag(D)))
Valores a remplazar en D_pse
[[0.05153785 0. ]
[0. 1.39306957]]
# 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)
[[0.05153785 0. 0. ]
[0. 1.39306957 0. ]]
# Calculamos la pseudo inversa de A
A_pse = V.T.dot(D_pse).dot(U.T)
print(A_pse)
[[-0.50515464 -0.78865979 0.54123711]
[ 0.42268041 0.67010309 -0.3814433 ]]
# Validamos si esta pseudoinversa es correcta
A_pse_calc = np.linalg.pinv(A)
print(A_pse_calc)
[[-0.50515464 -0.78865979 0.54123711]
[ 0.42268041 0.67010309 -0.3814433 ]]
# Comprobamos que la pseudoinversa de la matriz A aplicada a la matriz A nos de la matriz Identidad
print(A_pse.dot(A))
[[ 1. -0.]
[ 0. 1.]]
np.set_printoptions(suppress=False)
print(A_pse.dot(A))
[[ 1.00000000e+00 -1.77635684e-15]
[ 4.44089210e-16 1.00000000e+00]]
%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)
[[ 4 1]
[-2 1]
[ 3 1]]
# Realizamos la pseudoinversa de la matriz
matriz_pse = np.linalg.pinv(matriz)
print(matriz_pse)
[[ 0.11290323 -0.17741935 0.06451613]
[ 0.14516129 0.62903226 0.22580645]]
# Definimos nuestro vector solucion del sistema de ecuaciones
b = np.array([[3],[5],[1]])
print(b)
[[3]
[5]
[1]]
# Resolvemos X = A^+B
resultado = matriz_pse.dot(b)
print(resultado)
[[-0.48387097]
[ 3.80645161]]
# 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)
[1.85050946e+00 6.28759594e+04]
# 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)
(400, 64, 64)
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)
(400, 4096)
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 principales: 4
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 principales: 27
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_}""")
Cantidad original de fotos que teniamos de cada persona: 400
Componentes principales para capturar el 99.9% de datos: 368