UNIVERSIDAD NACIONAL TECNOLÓGICA DE LIMA SUR

Creación y entrenamiento de una Red Neuronal Perceptrón

Multicapa ( MLP )
Integrantes

- Tello Mestanza, Edward Andre 1911110194

- Diaz Yalle, Ronal Steve 1911110018

- Romero Meza, Rodrigo Vicente 1911100120

- Lifoncio Zuñiga Ismael 1911050377

 Resumen
Lo novedoso de la Red Neuronal Perceptrón
Multicapa simulado en google colab es que es un
tipo de red neuronal que es utilizado
fundamentalmente en procesos de clasificación y
predicción

¿De qué trata el trabajo?

El trabajo consiste en el análisis matemático a través

de funciones de activación , mediante el cual el
algoritmo pueda aprender y tomar decisiones por su
propia cuenta
 Introducción
EL perceptrón multicapa MLP es una red neuronal artificial formada por
múltiples capas ,de tal mantenimiento que tiene capacidad para resolver
problemas que no son linealmente separables, lo cual es la principal
limitación del perceptrón simple (DalpMaths, 2019)

¿Cuál es el problema estudiado y por qué se estudia?

Las redes neuronales multicapa son utilizadas para predecir el riesgo de
enfermedad cardíaca, diabetes y cáncer de mama. (Abellaneda,J , Ochoa , C ,
2010)

El propósito y la importancia
La importancia del perceptrón multicapa radica en su capacidad para
realizar tareas complejas de clasificación y predicción de manera precisa y
eficiente. (Garcia et al., 2021)
Objetivos

● Comprender el uso, creación, entrenamiento de una Red Neuronal Multicapa.

● Analizar los tipos de función de activación: ReLu, Sigmoidea y Tangente
Hiperbólica ; y determinar cual es más eficiente.
 ¿ Qué son las redes neuronales artificiales ?

De acuerdo con Trujillano, J., March, J., & Sorribas, A.

(2004 , pág 2).

“Una RN es un algoritmo de cálculo que se basa en

una analogía del sistema nervioso. La idea general
consiste en emular la capacidad de aprendizaje del
sistema nervioso, de manera que la RN aprenda a
identificar un patrón de asociación entre los valores
de un conjunto de variables predictoras (entradas) y
los estados que se consideran dependientes de https://sites.google.com/site/mayint
dichos valores (salidas).” eligenciartificial/unidad-4-redes-neu
ronales
 Perceptrón Multicapa

Según Blasco, J. (2018 , pág 20 ).

“Se denomina Perceptrón Multicapa o MLP2 a

una red neuronal artificial formada por
múltiples capas con un número de neuronas
en cada capa en función de su aplicación
final. Esto le permite resolver problemas no
linealmente separables, superando en este
caso las prestaciones del perceptrón simple” https://www.atriainnovation.com/qu
e-son-las-redes-neuronales-y-sus-f
unciones/
Etapas del algoritmo “ error de retro programación“
La primera etapa de entrenamiento
consiste en la presentación de un
grupo denominado grupo de
entrenamiento en el cual, cuyo
principal objetivo es conseguir la
mínima discrepancia entre el valor de
salida obtenido y el valor de salida
deseado
En la segunda etapa, la etapa de
funcionamiento, se presenta un nuevo grupo de
datos que no han sido presentados
anteriormente, grupo de validación, la señal se
transmite hacia las neuronas ocultas en donde
se transforman las señales a partir de la
aplicación de una función de activación y
proporcionan un valor de salida que se
transmite a la siguiente capa, en donde, a partir
de la misma operación se obtiene una salida de
la red.
Materiales
Para el modelado matemático se utiliza el
software google colab .
Dentro del cual se usaron las librerias Torch
y IPhyton
Creación y entrenamiento de una red neuronal
multicapa
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

X, y = make_classification(n_samples=1000, n_features=20, n_informative=10,

n_redundant=10, n_classes=2, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
random_state=42)
 Creación y entrenamiento de una red neuronal
multicapa
model = Sequential()
plt.plot(history.history['accuracy'])
model.add(Dense(units=64, activation='relu',
plt.plot(history.history['val_accuracy'])
input_shape=(20,)))
plt.title('Precisión del modelo')
model.add(Dense(units=32, activation='relu'))
model.add(Dense(units=1, activation='sigmoid')) plt.ylabel('Precisión')
plt.xlabel('Época')
model.compile(optimizer='adam', plt.legend(['Entrenamiento', 'Prueba'],
loss='binary_crossentropy', loc='upper left')
metrics=['accuracy']) plt.show()

Para mayor información acerca del

history = model.fit(X_train, y_train,
Metodo Adam: "Adam: A method for
epochs=10, batch_size=32,
stochastic optimization" de D. P. Kingma
validation_data=(X_test, y_test)) y J. L. Ba
ieeexplore.org/abstract/document/7015999
Creación y entrenamiento de una red neuronal
multicapa
 METODOLOGÍA
Capa de entrada
En esta capa se guardan los valores
en forma de matrices

"Output layer design for

classification neural networks" de J.
L. Rojas y F. L. López

Capa oculta

Para esta capa los valores

guardados en matrices son
multiplicados por el vector Hj
METODOLOGÍA
Análisis de la capa de salida

Esta capa es resulta con funciones de activación,

la más común es la función sigmoidea

"Output layer design for classification neural

networks" de J. L. Rojas y F. L. López
(https://ieeexplore.org/abstract/document/7016
125)
 Análisis mediante gradientes
Para calcular las correcciones de la
capa oculta no se tiene valores
objetivos.

En el gráfico de 2 dimensiones se
utiliza la derivada para hallar su
mínimo (descenso mediante
gradiente)

Ejemplo de aplicación:
“Adaptive gradient methods with
dynamic bound of learning rate" de
C. You, W. Hu, Y. Tian, Y. Liu, y L.
Lin
 Funciones de activación
ReLU(x)=max(0,x)

es una función máximo con respecto a 0

Comando para la gráfica de ReLU

x = torch.arange(-8.0, 8.0, 0.1, requires_grad=True)

y = torch.relu(x)

plt.plot(x.detach(), y.detach())

derivada de ReLU

y.backward(torch.ones_like(x), retain_graph=True)

plt.plot(x.detach(), x.grad)

pReLU

La variante pRelu halla los gradientes positivos y negativos

 Función Sigmoidea

Esta función de activación trata de emular era la respuesta real de las

neuronas de los mamíferos es decir que cuando una neurona está en
estado neutro y luego se descarga es decir cuando cambia de una
polaridad a otra de repente cambia de tensión algo similar a una
sigmoidea
comando para la gráfica sigmoidea
y = torch.sigmoid(x)
plt.plot(x.detach(), y.detach())
comando para la derivada de la función sigmoidea
x.grad.data.zero_()
y.backward(torch.ones_like(x),retain_graph=True)
plt.plot(x.detach(), x.grad)
 Función Tangente Hiperbólica

comando para la función tangente hiperbólica

y = torch.tanh(x)
plt.plot(x.detach(), y.detach())
se obtiene una función muy similar a la función sigmoidea mientras que la derivada
sigue teniendo el valor de 0
comando para la derivada funcion tangente hiperbólica
# Clear out previous gradients.
x.grad.data.zero_()
y.backward(torch.ones_like(x),retain_graph=True)
plt.plot(x.detach(), x.grad)
 batch_size, lr, num_epochs = 256, 0.1, 10

RESULTADOS
loss = nn.CrossEntropyLoss(reduction='none')
trainer = torch.optim.SGD(net.parameters(), lr=lr)
#Ejemplo de dataloader para FAshin MNIST
librerías
import torch
def load_data_fashion_mnist(batch_size, resize=None):
from torch import nn
trans = [transforms.ToTensor()]
import torchvision
if resize:
from IPython import display
trans.insert(0, transforms.Resize(resize))
from torchvision import transforms
trans = transforms.Compose(trans)
from torch.utils import data
mnist_train = torchvision.datasets.FashionMNIST(
root="../data", train=True, transform=trans,
modelo
download=True)
net = nn.Sequential(nn.Flatten(),
mnist_test = torchvision.datasets.FashionMNIST(
nn.Linear(784, 256),
root="../data", train=False, transform=trans,
nn.ReLU(),
download=True)
nn.Linear(256, 10))
return (data.DataLoader(mnist_train, batch_size,
def init_weights(m):
shuffle=True,
if type(m) == nn.Linear:
num_workers=1),
nn.init.normal_(m.weight, std=0.01)
data.DataLoader(mnist_test, batch_size,
net.apply(init_weights);
shuffle=False,
num_workers=1))
def accuracy(y_hat, y):
for epoch in range(num_epochs):
"""Compute the number of correct predictions."""
L = 0.0
if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
N = 0
y_hat = y_hat.argmax(axis=1)
Acc = 0.0
cmp = y_hat.type(y.dtype) == y
TestAcc = 0.0
return float(cmp.type(y.dtype).sum()) TestN = 0
for X, y in train_iter:
train_iter, test_iter = l = loss(net(X) ,y)
load_data_fashion_mnist(batch_size) trainer.zero_grad()
l.mean().backward()
trainer.step()
L += l.sum()
N += l.numel()
Acc += accuracy(net(X), y)
for X, y in test_iter:
TestN += y.numel()
TestAcc += accuracy(net(X), y)
print(f'epoch {epoch + 1}, loss {(L/N):f}\
, train accuracy {(Acc/N):f}, test
accuracy {(TestAcc/TestN):f}')
Resultados
porcentaje de aprendizaje
ejemplo:En caso donde la Red neuronal aprendiendo
un juego
Resultados
DISCUSIÓN

● Luego de analizar 3 tipos de funciones de activación nos dimos cuenta que la más
eficiente es la tangente hiperbólica en comparación de la función sigmoidea y función
Relu ya que conserva mejor los valores tanto cuando están cerca a 0 y cuando es 0.
● También se concluye que las redes neuronales presentan múltiples ventajas en la
detección de anomalías pero estas están ligadas a la configuración y su aprendizaje .
● El trabajo de las redes ocultas es analizar los valores extraídos de la capa inicial solo
extrae la esencia de los patrones para luego multiplicarlo o combinarlo con la capa de
salida
Conclusiones
● Las redes Perceptrón multicapa son un tipo de modelo de aprendizaje automático que se
utilizan en el campo de la inteligencia artificial para clasificar y predecir resultados.
● Las redes perceptrón multicapa son capaces de procesar información compleja y de
aprender de ella a través de la retroalimentación y la ajuste de sus pesos sinápticos.
● Las redes perceptrón multicapa pueden ser aplicadas en una amplia variedad de problemas
de clasificación y predicción, como la identificación de spam, la detección de sentimiento en
reseñas de productos en línea y la predicción del resultado de eventos deportivos.
● Como se pudo observar en el código implementado es posible utilizar PyTorch para entrenar
una red neuronal para clasificar imágenes en varias clases.
Gracias.