Explorando el Perceptrón Simple: Un viaje desde la lógica básica hasta la programación en IA


Perceptron Simple.ipynb


Volver

Explorando el Perceptrón Simple: Un viaje desde la lógica básica hasta la programación en IA

1. Contenido (Conocimientos Conceptuales – Marco Teórico)

Introducción al Perceptrón Simple: Explicación breve de qué es un perceptrón, su relevancia histórica en el campo de la inteligencia artificial y su función como un modelo básico de una neurona artificial.

Fundamentos Teóricos:

•   Definición de Perceptrón: Un modelo de aprendizaje automático supervisado.

Esta imagen muestra la estructura básica de un perceptrón en las redes neuronales, con partes etiquetadas como las entradas, los pesos, un nodo de suma, una función de activación y la salida. La ilustración utiliza flechas para indicar el flujo desde las entradas a través de la neurona hasta la salida, encarnando el proceso de suma ponderada y activación, lo cual es perfecto para explicar conceptos fundamentales en inteligencia artificial y aprendizaje automático.

•  Arquitectura y Funcionamiento: Cómo un perceptrón toma entradas, las pondera, las suma y aplica una función de activación para producir una salida.

Ejemplos Clásicos: Uso del perceptrón para modelar operaciones lógicas básicas como NOT, AND y OR.

•   NOT: Un perceptrón con una única entrada.

•   AND y OR: Perceptrones con dos entradas.

2. Script Python (Habilidades – Procedimientos)

Implementación en Python: Crear un script que muestre cómo se puede implementar un perceptrón simple.

•  Estructura del Código: Clase de Perceptrón en Python con métodos para entrenar el modelo y predecir resultados.

•   Ejemplos de Uso: Cómo entrenar el perceptrón para replicar las funciones lógicas NOT, AND, OR.

• Demostración de Resultados: Correr el script para demostrar que el perceptrón aprende correctamente estas operaciones.

import numpy as np

class Perceptron:

    def __init__(self, learning_rate=0.1, n_iterations=100):
        self.lr = learning_rate
        self.n_iterations = n_iterations
        self.activation_func = self._unit_step_func
        self.weights = None
        self.bias = None

    def fit(self, X, y):

        n_samples, n_features = X.shape


        # Inicializar parámetros
        self.weights = np.zeros(n_features)
        self.bias = 0

        y_ = np.array([1 if i > 0 else 0 for i in y])

        for _ in range(self.n_iterations):

            for idx, x_i in enumerate(X):

                linear_output = np.dot(x_i, self.weights) + self.bias

                y_predicted = self.activation_func(linear_output)

                # Actualización de pesos y bias

                update = self.lr * (y_[idx] - y_predicted)
                self.weights += update * x_i
                self.bias += update

    def predict(self, X):

        linear_output = np.dot(X, self.weights) + self.bias
        y_predicted = self.activation_func(linear_output)
        return y_predicted

    def _unit_step_func(self, x):

        return np.where(x >= 0, 1, 0)

def train_perceptron_for_logic_gate(X, y):

    p = Perceptron(learning_rate=0.1, n_iterations=10)
    p.fit(X, y)
    return p

# Datos de entrenamiento para AND, OR y NOT

X_AND = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y_AND = np.array([0, 0, 0, 1])

X_OR = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])

y_OR = np.array([0, 1, 1, 1])

X_NOT = np.array([[0], [1]])

y_NOT = np.array([1, 0])

# Entrenamiento

perceptron_AND = train_perceptron_for_logic_gate(X_AND, y_AND)
perceptron_OR = train_perceptron_for_logic_gate(X_OR, y_OR)
perceptron_NOT = train_perceptron_for_logic_gate(X_NOT, y_NOT)

# Pruebas

print("AND Prediction for [1, 1]:", perceptron_AND.predict(np.array([[1, 1]])))
print("OR Prediction for [0, 1]:", perceptron_OR.predict(np.array([[0, 1]])))
print("NOT Prediction for [1]:", perceptron_NOT.predict(np.array([[1]])))
RESULTADO:

AND Prediction for [1, 1]: [1] OR Prediction for [0, 1]: [1] NOT Prediction for [1]: [0]

3. Conclusiones (Actitudes y Valoraciones)

·        Importancia del Perceptrón en IA: Reflexión sobre cómo el entendimiento de conceptos básicos como el perceptrón es fundamental para comprender sistemas más complejos en IA.

·        Valor del Aprendizaje: Discusión sobre la importancia del aprendizaje continuo y práctico en el campo de la IA, especialmente para docentes y estudiantes.

·        Invitación a la Experimentación: Alentar a los lectores a modificar y experimentar con el código proporcionado para mejorar su comprensión y habilidades prácticas.

Cierre

·        Llamado a la Acción: Invitar a los lectores a comentar sus experiencias, dudas o compartir sus propias implementaciones.

·        Agradecimientos y Próximos Temas: Agradecer a los lectores por su tiempo e interés, y adelantar próximos temas que se tratarán en el blog relacionados con la IA.

Volver





Sin comentarios