El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Perceptrón y Perceptrón Multicapa

Siguiente ►
►

Introducción

En este tema, exploraremos los conceptos fundamentales del perceptrón y el perceptrón multicapa (MLP, por sus siglas en inglés). Estos son los bloques de construcción básicos de las redes neuronales y son esenciales para entender cómo funcionan las redes neuronales profundas.

Perceptrón

¿Qué es un Perceptrón?

Un perceptrón es el modelo más simple de una red neuronal. Fue introducido por Frank Rosenblatt en 1958 y es una unidad de procesamiento que toma una o más entradas, las combina linealmente y pasa el resultado a través de una función de activación para producir una salida.

Estructura del Perceptrón

Un perceptrón consta de:

  • Entradas (x1, x2, ..., xn): Los datos de entrada.
  • Pesos (w1, w2, ..., wn): Coeficientes que ponderan la importancia de cada entrada.
  • Bias (b): Un término adicional que permite ajustar la salida independientemente de las entradas.
  • Función de activación (φ): Una función que introduce no linealidad en el modelo.

Fórmula del Perceptrón

La salida del perceptrón se calcula de la siguiente manera:

\[ y = \phi \left( \sum_{i=1}^{n} w_i x_i + b \right) \]

Donde:

  • \( y \) es la salida.
  • \( \phi \) es la función de activación (comúnmente una función escalón o sigmoide).

Ejemplo de Perceptrón

Supongamos que tenemos un perceptrón con dos entradas \( x1 \) y \( x2 \), pesos \( w1 = 0.5 \) y \( w2 = -0.6 \), y un bias \( b = 0.1 \). La función de activación es una función escalón que devuelve 1 si la entrada es mayor o igual a 0, y 0 en caso contrario.

\[ y = \phi (0.5 \cdot x1 - 0.6 \cdot x2 + 0.1) \]

Si \( x1 = 1 \) y \( x2 = 2 \):

\[ y = \phi (0.5 \cdot 1 - 0.6 \cdot 2 + 0.1) \] \[ y = \phi (0.5 - 1.2 + 0.1) \] \[ y = \phi (-0.6) \] \[ y = 0 \]

Ejercicio Práctico

Ejercicio 1: Implementa un perceptrón en Python que tome dos entradas y calcule la salida usando una función escalón.

def perceptron(x1, x2, w1, w2, b):
    # Función de activación escalón
    def step_function(x):
        return 1 if x >= 0 else 0
    
    # Cálculo de la salida del perceptrón
    output = step_function(w1 * x1 + w2 * x2 + b)
    return output

# Prueba del perceptrón
x1, x2 = 1, 2
w1, w2 = 0.5, -0.6
b = 0.1
print(perceptron(x1, x2, w1, w2, b))  # Salida esperada: 0

Solución:

El código anterior define una función perceptron que calcula la salida de un perceptrón dado dos entradas, sus pesos y el bias. La función de activación utilizada es una función escalón.

Perceptrón Multicapa (MLP)

¿Qué es un Perceptrón Multicapa?

Un perceptrón multicapa (MLP) es una red neuronal que consiste en múltiples capas de perceptrones. Cada capa está compuesta por varias unidades de perceptrón, y las capas están conectadas de manera que la salida de una capa se convierte en la entrada de la siguiente.

Estructura del MLP

Un MLP típicamente consta de:

  • Capa de entrada: Recibe los datos de entrada.
  • Capas ocultas: Una o más capas que procesan las entradas de manera no lineal.
  • Capa de salida: Produce la salida final de la red.

Propagación hacia Adelante en MLP

La propagación hacia adelante en un MLP implica calcular las salidas de cada capa secuencialmente desde la capa de entrada hasta la capa de salida.

Ejemplo de MLP

Consideremos un MLP con una capa oculta que tiene dos neuronas y una capa de salida con una neurona. Los pesos y bias se definen para cada conexión entre las capas.

Ejercicio Práctico

Ejercicio 2: Implementa un MLP en Python con una capa oculta que tenga dos neuronas y una capa de salida con una neurona. Usa la función sigmoide como función de activación.

import numpy as np

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def mlp(x, weights, biases):
    # Capa oculta
    hidden_layer_input = np.dot(weights['hidden'], x) + biases['hidden']
    hidden_layer_output = sigmoid(hidden_layer_input)
    
    # Capa de salida
    output_layer_input = np.dot(weights['output'], hidden_layer_output) + biases['output']
    output = sigmoid(output_layer_input)
    
    return output

# Definición de pesos y bias
weights = {
    'hidden': np.array([[0.5, -0.6], [0.8, -0.1]]),
    'output': np.array([0.2, -0.3])
}

biases = {
    'hidden': np.array([0.1, 0.2]),
    'output': np.array([0.3])
}

# Prueba del MLP
x = np.array([1, 2])
print(mlp(x, weights, biases))  # Salida esperada: un valor entre 0 y 1

Solución:

El código anterior define una función mlp que calcula la salida de un MLP dado un vector de entrada, pesos y bias. La función de activación utilizada es la función sigmoide.

Conclusión

En esta sección, hemos cubierto los conceptos básicos del perceptrón y el perceptrón multicapa. Hemos aprendido cómo funcionan estos modelos, cómo se estructuran y cómo se implementan en Python. Estos conceptos son fundamentales para entender redes neuronales más complejas y avanzadas que exploraremos en los siguientes módulos.

Resumen

  • Perceptrón: Unidad básica de una red neuronal que combina entradas linealmente y aplica una función de activación.
  • Perceptrón Multicapa (MLP): Red neuronal con múltiples capas de perceptrones que permite modelar relaciones no lineales complejas.
  • Propagación hacia Adelante: Proceso de calcular las salidas de cada capa secuencialmente desde la capa de entrada hasta la capa de salida.

En el próximo tema, exploraremos las funciones de activación en mayor detalle, que son cruciales para introducir no linealidad en las redes neuronales.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados