01 - Taller - Ipynb - Colaboratory DMERCHAN

14/2/24, 23:15 Copy of 01_Taller.
ipynb - Colaboratory
keyboard_arrow_down DARWIN MERCHAN DELGADO

TALLER 1
1.- Regresión
2.- Clasificación
3.- Tarea de Regresión

Code Text
Importando bibliotecas
import numpy as np
import matplotlib.pyplot as plt
import torch
import torch.nn as nn
from torch.utils.data import DataLoader
import sklearn.neural_network as snn
from sklearn import datasets
from sklearn import metrics
from sklearn.model_selection import train_test_split
from scipy.stats import zscore
keyboard_arrow_down Regresión traditional

keyboard_arrow_down Scikit-learn
Cargando conjunto de datos
dataset = datasets.fetch_california_housing()
Xtrain, Xtest, Ytrain, Ytest = train_test_split(dataset.data, dataset.target, test_size=0.3, random_state=0)
Xtrain = zscore(Xtrain, axis=0)
Xtest = zscore(Xtest, axis=0)
Creación del modelo y entrenamiento
mdl = snn.MLPRegressor(hidden_layer_sizes=(30), max_iter=500)

mdl.fit(Xtrain, Ytrain)
plt.plot(mdl.loss_curve_)
metrics.mean_squared_error(Ytrain, mdl.predict(Xtrain))
https://colab.research.google.com/drive/1FZCC_9l8Yl3ajAx8Gv14wSkGL3xFLOm4#scrollTo=pNdCI6EQGizz&printMode=true 1/11
14/2/24, 23:15 Copy of 01_Taller.ipynb - Colaboratory
0.2907898898274257
Evaluation del modelo
metrics.mean_squared_error(Ytest, mdl.predict(Xtest))
0.37760063190465504
keyboard_arrow_down Regresión: Analizar los errores cuadráticos medios obtenidos por cada modelo implementado.
¿Existe alguna diferencia en los resultados alcanzados?
El modelo de entrenamiento dependiendo de los valores ingresados nos dan un resultado bastante
acertado en cuanto a los precios de ventas de las viviendas. Al ploteralos al tener mayor dimensión
mejor es el precio.
El valor de x siempre disminuye
keyboard_arrow_down Pytorch
Adaptación de los datos
Xtrain = torch.FloatTensor(Xtrain)
Ytrain = torch.FloatTensor(Ytrain).reshape(-1, 1)
Xtest = torch.FloatTensor(Xtest)
Ytest = torch.FloatTensor(Ytest).reshape(-1, 1)
trainloader = DataLoader(list(zip(Xtrain, Ytrain)), batch_size=20, shuffle=True)
Creación del modelo
model = nn.Sequential(
nn.Linear(8, 30),
nn.ReLU(),
nn.Linear(30, 1)
)
loss_fn = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
Entrenamiento del modelo
lossTest = []
for epoch in range(100):
model.train()
for input, output in trainloader:
y_hat = model(input)
loss = loss_fn(y_hat, output)
optimizer.zero_grad()
loss.backward()
optimizer.step()
model.eval()
y_hat = model(Xtest)
loss = loss_fn(y_hat, Ytest)
lossTest.append(float(loss))
plt.plot(lossTest);
keyboard_arrow_down Clasificación traditional

keyboard_arrow_down Scikit-learn
Cargando conjunto de datos
digits = datasets.load_digits()
for i in range(9):
plt.subplot(330 + 1 + i)
plt.imshow(digits.images[i], cmap='gray')
data = digits.images.reshape((len(digits.images), -1))/255

Xtrain, Xtest, Ytrain, Ytest = train_test_split(data, digits.target, test_size=0.3)
Creación del modelo y entrenamiento
clf = snn.MLPClassifier(hidden_layer_sizes=(50, 20), max_iter=1000)

clf.fit(Xtrain, Ytrain)
p = plt.plot(clf.loss_curve_);
/usr/local/lib/python3.10/dist-packages/sklearn/neural_network/_multilayer_perceptron.py:686: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (1000) reached and the optimization hasn
warnings.warn(
Evaluacion del modelo
Y_hat = clf.predict(Xtest)
print(metrics.classification_report(Ytest, Y_hat))
precision recall f1-score support
0 0.98 0.98 0.98 55

1 0.88 0.95 0.91 61
2 0.92 0.94 0.93 47
3 0.91 0.91 0.91 46
4 1.00 0.91 0.95 55
5 0.96 0.93 0.95 56
6 0.98 1.00 0.99 54
7 0.98 0.96 0.97 51
8 0.96 0.92 0.94 52
9 0.91 0.95 0.93 63
accuracy 0.95 540

macro avg 0.95 0.95 0.95 540
weighted avg 0.95 0.95 0.95 540
Matriz de confusión
cm = metrics.confusion_matrix(Ytest, Y_hat, labels=clf.classes_)

disp = metrics.ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=clf.classes_)
disp.plot();
keyboard_arrow_down Clasificación: analizar las matrices de confusión presentadas. ¿Existe alguna diferencia en los
resultados alcanzados?
La matriz de confusión de acuerdo al aprendizaje realizado, mientras mayor sea el umero de

intentos que se realiza el aprendizaje mayor es el acierto .
Así tenemos que al ingresar los números de aprendizaje un valor mas alto vemos que el porcentaje
de acierto es el 95% y en 10 intentos del número 0 solo tiene 1 equivocación.
keyboard_arrow_down Pytorch
Adaptación de los datos
Xtrain = torch.FloatTensor(Xtrain)
Ytrain = torch.LongTensor(Ytrain)
Xtest = torch.FloatTensor(Xtest)
Ytest = torch.LongTensor(Ytest)
trainloader = DataLoader(list(zip(Xtrain, Ytrain)), batch_size=100, shuffle=True)
Creación del modelo
model = nn.Sequential(
nn.Linear(Xtrain.shape[1], 50),
nn.ReLU(),
nn.Linear(50, 30),
nn.ReLU(),
nn.Linear(30, 10)
)
loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
Entrenamiento del modelo
lossTest = []
for epoch in range(800):
model.train()
for input, output in trainloader:
y_hat = model(input)
loss = loss_fn(y_hat, output)
optimizer.zero_grad()
loss.backward()
optimizer.step()
model.eval()
y_hat = model(Xtest)
loss = loss_fn(y_hat, Ytest)
lossTest.append(float(loss))
plt.plot(lossTest);
Model evaluation
Y_hat = model(Xtest).detach().numpy().argmax(axis=1)
print(metrics.classification_report(Ytest, Y_hat))
cm = metrics.confusion_matrix(Ytest, Y_hat, labels=clf.classes_)
disp = metrics.ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=clf.classes_)
p = disp.plot()
precision recall f1-score support
0 0.98 0.98 0.98 55

1 0.88 0.95 0.91 61
2 0.92 0.98 0.95 47
3 0.93 0.89 0.91 46
4 1.00 0.91 0.95 55
5 0.96 0.95 0.95 56
6 0.98 1.00 0.99 54
7 0.98 0.94 0.96 51
8 0.92 0.90 0.91 52
9 0.91 0.94 0.92 63
accuracy 0.94 540

macro avg 0.95 0.94 0.94 540
weighted avg 0.95 0.94 0.94 540
keyboard_arrow_down Tarea a completar

Generación de conjunto de datos
x = np.linspace(0, 3*np.pi, 500)
y = np.sin(x) + np.random.normal(0, 0.2, len(x))
p = plt.plot(x, y)
x = x.reshape(-1,1)
Xtrain, Xtest, Ytrain, Ytest = train_test_split(x, y, test_size=0.3, random_state=0)
Crear el modelo y entrenar
#TODO
# Instanciar el modelo
# Entrenar (fit)
# Evaluar (predict)
mdl = snn.MLPRegressor(hidden_layer_sizes=(15, 65), max_iter=(1500))

mdl.fit(Xtrain, Ytrain)
plt.plot(mdl.loss_curve_)
metrics.mean_squared_error(Ytrain, mdl.predict(Xtrain))
Y_hat = mdl.predict(Xtest)
metrics.mean_squared_error(Ytest, Y_hat)

01 - Taller - Ipynb - Colaboratory DMERCHAN

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

01 - Taller - Ipynb - Colaboratory DMERCHAN

Cargado por

Copyright:

Formatos disponibles

14/2/24, 23:15 Copy of 01_Taller.

keyboard_arrow_down DARWIN MERCHAN DELGADO

3.- Tarea de Regresión

keyboard_arrow_down Regresión traditional

Creación del modelo y entrenamiento

mdl = snn.MLPRegressor(hidden_layer_sizes=(30), max_iter=500)

Evaluation del modelo

El valor de x siempre disminuye

Adaptación de los datos

Creación del modelo

Entrenamiento del modelo

keyboard_arrow_down Clasificación traditional

data = digits.images.reshape((len(digits.images), -1))/255

Creación del modelo y entrenamiento

clf = snn.MLPClassifier(hidden_layer_sizes=(50, 20), max_iter=1000)

Evaluacion del modelo

precision recall f1-score support

0 0.98 0.98 0.98 55

accuracy 0.95 540

cm = metrics.confusion_matrix(Ytest, Y_hat, labels=clf.classes_)

La matriz de confusión de acuerdo al aprendizaje realizado, mientras mayor sea el umero de

Creación del modelo

Entrenamiento del modelo

precision recall f1-score support

0 0.98 0.98 0.98 55

accuracy 0.94 540

keyboard_arrow_down Tarea a completar

Xtrain, Xtest, Ytrain, Ytest = train_test_split(x, y, test_size=0.3, random_state=0)

Crear el modelo y entrenar

mdl = snn.MLPRegressor(hidden_layer_sizes=(15, 65), max_iter=(1500))

También podría gustarte