Scribd Logo
Cargar

¡Te damos la bienvenida a Scribd!

  • 48 vistas

    Señales

    Cargado por

    Harold De la Zota
    Este documento describe la creación y entrenamiento de una Red Neuronal Perceptrón Multicapa (MLP) utilizando Python. Los autores analizan funciones de activación como ReLU, sigmoidea y tangente hiperbólica. También describen las etapas del algoritmo de retropropagación del error y los resultados obtenidos al clasificar datos de la base MNIST utilizando este tipo de red neuronal.

    Copyright:

    © All Rights Reserved
    Descargue como PDF, TXT o lea en línea desde Scribd

    Señales

    Cargado por

    Harold De la Zota
    48 vistas29 páginas
    Este documento describe la creación y entrenamiento de una Red Neuronal Perceptrón Multicapa (MLP) utilizando Python. Los autores analizan funciones de activación como ReLU, sigmoidea y tangente hiperbólica. También describen las etapas del algoritmo de retropropagación del error y los resultados obtenidos al clasificar datos de la base MNIST utilizando este tipo de red neuronal.

    Derechos de autor

    © © All Rights Reserved

    Formatos disponibles

    PDF, TXT o lea en línea desde Scribd

    ¿Le pareció útil este documento?

    ¿Este contenido es inapropiado?

    Este documento describe la creación y entrenamiento de una Red Neuronal Perceptrón Multicapa (MLP) utilizando Python. Los autores analizan funciones de activación como ReLU, sigmoidea y tangente hiperbólica. También describen las etapas del algoritmo de retropropagación del error y los resultados obtenidos al clasificar datos de la base MNIST utilizando este tipo de red neuronal.

    Copyright:

    © All Rights Reserved
    Descargue como PDF, TXT o lea en línea desde Scribd
    Descargar como pdf o txt
    48 vistas29 páginas

    Señales

    Cargado por

    Harold De la Zota
    Este documento describe la creación y entrenamiento de una Red Neuronal Perceptrón Multicapa (MLP) utilizando Python. Los autores analizan funciones de activación como ReLU, sigmoidea y tangente hiperbólica. También describen las etapas del algoritmo de retropropagación del error y los resultados obtenidos al clasificar datos de la base MNIST utilizando este tipo de red neuronal.

    Copyright:

    © All Rights Reserved
    Descargue como PDF, TXT o lea en línea desde Scribd
    Descargar como pdf o txt
    Está en la página 1de 29

    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 En la segunda etapa, la etapa de


    consiste en la presentación de un funcionamiento, se presenta un nuevo grupo de
    grupo denominado grupo de datos que no han sido presentados
    entrenamiento en el cual, cuyo anteriormente, grupo de validación, la señal se
    principal objetivo es conseguir la transmite hacia las neuronas ocultas en donde
    mínima discrepancia entre el valor de se transforman las señales a partir de la
    salida obtenido y el valor de salida aplicación de una función de activación y
    deseado 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.

    También podría gustarte