Inteligencia

Artificial

>

_

II

Dr. Alfredo de Jesús Gutiérrez Gómez

Aprendizaje mecánico basado en símbolos

Jean Piaget

"El aprendizaje es un proceso mediante el cual se construye activamente el conocimiento a través de la interacción del individuo con su entorno físico y social."

Lev Vygotsky

"El aprendizaje es un proceso social en el que los individuos adquieren conocimientos y habilidades a través de la interacción con otros miembros de su entorno cultural."

¿Qué es el aprendizaje?

B.F. Skinner

"El aprendizaje es el proceso de adquirir nuevas conductas o modificar conductas existentes a través de la asociación entre estímulos y respuestas, reforzadas por consecuencias."

Actividad de aprendizaje

¿Que es el aprendizaje? ¿Cómo aprendo?



 

Responde lo siguiente

Aprendizaje en símbolos

Actividad de aprendizaje

¿Qué es el aprendizaje de símbolos?

"El aprendizaje de símbolos es el proceso mediante el cual un sistema cognitivo adquiere y utiliza representaciones simbólicas para representar el conocimiento y realizar tareas cognitivas complejas."

Aprendizaje de símbolos

Allen Newell y Herbert A. Simon

"El aprendizaje de símbolos es el proceso de adquirir, manipular y utilizar representaciones simbólicas para resolver problemas y realizar tareas cognitivas complejas."

John R. Anderson

"El aprendizaje de símbolos es el proceso de adquirir el conocimiento y la capacidad para manipular y combinar símbolos de manera significativa, lo cual permite el razonamiento y la comprensión de conceptos abstractos."

Douglas Hofstadter

Actividad de aprendizaje

Construyendo tu definición de concepto.

De acuerdo a tus definiciones anteriores y de expertos, ahora ¿qué sería el aprendizaje mecánico?

Aprendizaje Mecánico

"Un programa de computadora se dice que aprende de una experiencia E con respecto a alguna tarea T y alguna medida de rendimiento P, si su rendimiento en T, medido por P, mejora con la experiencia E."

Tom M. Mitchell

Arthur Samuel

"El campo del aprendizaje mecánico se ocupa de desarrollar algoritmos que permiten a las computadoras aprender a partir de los datos, sin ser explícitamente programadas."

Tom Dietterich

"El aprendizaje mecánico se refiere al diseño y desarrollo de algoritmos que permiten a las computadoras aprender automáticamente a partir de los datos."

Actividad de aprendizaje

¿Qué es para tí un aprendizaje mecánico basado en símbolos?

Construyendo nuestra definción

Aprendizaje mecánico conectivista.

  • El perceptrón
  • Propagación hacia atras.
  • Aprendizaje competitivo.
  • Coincidencia de hebbian.
  • Redes atractoras.

¿Qué es el aprendizaje conectivista?

Es un enfoque educativo y de aprendizaje que se basa en la idea de que el conocimiento se distribuye a través de conexiones y redes de información.

Sus caracteristicas

conectivista

El conocimiento se ve como una red interconectada de información y experiencias. Los aprendices se conectan con diversas fuentes de información, como libros, videos, sitios web, expertos, compañeros de clase, entre otros, para obtener conocimientos y resolver problemas.

Redes de Conocimiento

El aprendizaje no se limita a un entorno formal de aula, sino que se produce en múltiples contextos y situaciones, tanto dentro como fuera del aula. Los aprendices pueden acceder al conocimiento y aprender de diversas fuentes y plataformas, como redes sociales, comunidades en línea, blogs y más.

Aprendizaje Distribuido

Sus caracteristicas

conectivista

Los aprendices tienen un papel activo en su propio proceso de aprendizaje. Tienen la capacidad de definir sus objetivos, seleccionar las fuentes de información y elegir las actividades que mejor se adapten a sus necesidades y preferencias de aprendizaje.

Aprendizaje Autodirigido

El aprendizaje conectivista promueve la colaboración y el intercambio de conocimientos entre los aprendices. Los estudiantes pueden trabajar juntos, discutir temas, compartir recursos y ayudarse mutuamente a construir una comprensión más profunda del contenido.

Colaboración y Compartir

Sus caracteristicas

conectivista

El aprendizaje no se limita a un momento específico en el tiempo o a un conjunto de temas. Los aprendices están en constante proceso de aprendizaje y adquisición de nuevos conocimientos a lo largo de su vida, adaptándose a las demandas y cambios en su entorno.

Aprendizaje Permanente

El aprendizaje conectivista se centra en la capacidad de los estudiantes para resolver problemas de la vida real y aplicar el conocimiento de manera efectiva en situaciones prácticas.

Enfoque en la Resolución de Problemas

Sus caracteristicas

conectivista

Dado que los aprendices tienen un mayor control sobre su proceso de aprendizaje, el aprendizaje conectivista permite una mayor personalización para adaptarse a estilos de aprendizaje individuales y preferencias.

Aprendizaje Personalizado

Se basa en la idea de que la información está en constante cambio y que el aprendizaje se realiza de manera colaborativa y continua a través de conexiones y redes de conocimiento. Es un enfoque que abarca la era digital y las oportunidades que ofrece la tecnología para acceder a una gran cantidad de información y conectar con personas de todo el mundo.

Importante

Actividad de aprendizaje

Responde a lo siguiente:

¿Cuál sería tu definición de un aprendizaje mecánico conectivista?

Se recomienda revisar tus notas anteriores para llegar a una excelente definición

El perceptron

Perceptron

Algoritmo de aprendizaje automático y una arq. de red neuronal artificial

Resuelve problemas de clasificación binaria

Frank Rosenblatt en 1957

Fundamentales en el  aprendizaje profundo y las redes

neuronales.

Inspirado en el funcionamiento del sistema nervioso humano

Diseñado para simular una sola neurona artificial

Objetivo es aprender a realizar una tarea de clasificación binaria

Características perceptrón

Recibe múltiples entradas numéricas, cada una multiplicada por un peso asociado. Los pesos representan la importancia relativa de cada entrada para el proceso de clasificación.

Entradas y pesos

Después de ponderar las entradas con los pesos, la suma ponderada se pasa a través de una función de activación que determina si la neurona se activa o no. La función de activación más comúnmente utilizada en el perceptrón es la función escalón o función de Heaviside, que devuelve 1 si la suma ponderada es mayor o igual que un umbral, y 0 en caso contrario.

Función de activación

Características perceptrón

Se entrena mediante el aprendizaje supervisado. Durante el entrenamiento, se proporcionan ejemplos etiquetados (conocidos) al perceptrón, y el algoritmo ajusta los pesos para minimizar el error entre las predicciones del perceptrón y las etiquetas correctas.

Aprendizaje supervisado

El algoritmo de entrenamiento del perceptrón ajusta los pesos de manera iterativa en función del error cometido en las predicciones. En cada iteración, el perceptrón realiza predicciones, compara con las etiquetas reales y actualiza los pesos para reducir el error.

Entrenamiento

Características perceptrón

incapacidad para resolver problemas no lineales. Solo puede separar clases que sean linealmente separables, lo que significa que los ejemplos de cada clase pueden ser divididos por una línea recta o un hiperplano en el espacio de características.

Limitaciones

En el desarrollo histórico de las redes neuronales y ha allanado el camino para modelos más complejos y poderosos, como las redes neuronales multicapa y los algoritmos de aprendizaje profundo, que han demostrado ser altamente eficaces en una amplia gama de tareas de aprendizaje automático y procesamiento de datos.

Importante

Supongamos

Que tenemos un conjunto de datos de entrenamiento con dos características (x1, x2) y dos clases (0 y 1). El objetivo es aprender un modelo de perceptrón que pueda separar las dos clases.

Supongamos

import numpy as np

class Perceptron:
    def __init__(self, learning_rate=0.1, epochs=100):
        self.learning_rate = learning_rate
        self.epochs = epochs
        self.weights = None
        self.bias = None

    def fit(self, X, y):
        num_features = X.shape[1]
        self.weights = np.zeros(num_features)
        self.bias = 0

        for _ in range(self.epochs):
            for i in range(X.shape[0]):
                prediction = self.predict(X[i])
                error = y[i] - prediction
                self.weights += self.learning_rate * error * X[i]
                self.bias += self.learning_rate * error

    def predict(self, x):
        linear_output = np.dot(x, self.weights) + self.bias
        return 1 if linear_output >= 0 else 0

Supongamos

# Datos de entrenamiento
X_train = np.array([[2, 3], [1, 5], [3, 2], [5, 1]])
y_train = np.array([0, 0, 1, 1])

# Crear el modelo del perceptrón
perceptron = Perceptron(learning_rate=0.1, epochs=100)

# Entrenar el modelo
perceptron.fit(X_train, y_train)

# Datos de prueba
X_test = np.array([[4, 4], [1, 1]])

# Realizar predicciones
predictions = [perceptron.predict(x) for x in X_test]
print(predictions)  # Salida: [1, 0] (Clase 1, Clase 0)

Actividad de aprendizaje

  • Una los dos fragmentos anteriores en un solo archivo.
  • Guardarlo con el nombre "perceptron.py" (sin las comillas)
  • Ejecute en su terminal. (python perceptron.py)
  • Responda lo siguiente:
  • ¿perceptron logro clasificar los datos?
  • ¿Cuantas clases encontro perceptron?
  • ¿qué resultado arrojo el código?
  • ¿qué pasa si agrega cambia un dato de entrenamiento por 1,1?

Registro

https://www.academiajournals.com/tlahuac-registro

Actividad

De tu proyecto: 

  • Genera un resumen de lo que se pretende hacer no más de 250 palabras.
  • Revisa que el objetivo general responda a las preguntas ¿Qué se va hacer?, ¿Cómo se va hacer?, ¿Dónde se va hacer?, ¿Para que se va hacer?
  • Revisa que los objetivos específicos del proyecto ayuden a que se cumpla el objetivo general.
  • Revisa que tus actividades a describir coincida con cada una de los objetivos específicos planteados.

Propagación hacia atras

Es un algoritmo ampliamente utilizado en el entrenamiento de redes neuronales artificiales, especialmente en redes neuronales multicapa.

Es un proceso iterativo de ajuste de los pesos y sesgos de las neuronas en la red para minimizar el error entre las salidas predichas por la red y los valores reales de entrenamiento.

Es fundamental en el aprendizaje supervisado en redes neuronales

Permite que la red "aprenda" a partir de los datos de entrenamiento y ajuste sus parámetros para realizar predicciones más precisas en el futuro.

Backpropagation fue desarrollado en la década de 1970.

Formalizado en un artículo en 1986 por David E. Rumelhart, Geoffrey E. Hinton y Ronald J. Williams titulado "Learning representations by back-propagating errors" (Aprendiendo representaciones mediante la retropropagación de errores)

import numpy as np

# Función de activación sigmoide y su derivada
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
    return x * (1 - x)

# Datos de entrenamiento
X = np.array([[0, 0],
              [0, 1],
              [1, 0],
              [1, 1]])

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

# Inicialización de pesos y sesgos aleatorios
np.random.seed(1)
input_layer_size = X.shape[1]
hidden_layer_size = 4
output_layer_size = 1

weights_input_hidden = np.random.uniform(size=(input_layer_size, hidden_layer_size))
bias_hidden = np.random.uniform(size=(1, hidden_layer_size))

weights_hidden_output = np.random.uniform(size=(hidden_layer_size, output_layer_size))
bias_output = np.random.uniform(size=(1, output_layer_size))

# Parámetro de aprendizaje
learning_rate = 0.1
# Entrenamiento del modelo
epochs = 10000
for epoch in range(epochs):
    # Fase de propagación hacia adelante
    hidden_layer_input = np.dot(X, weights_input_hidden) + bias_hidden
    hidden_layer_output = sigmoid(hidden_layer_input)

    output_layer_input = np.dot(hidden_layer_output, weights_hidden_output) + bias_output
    output_layer_output = sigmoid(output_layer_input)

    # Cálculo del error
    error = y - output_layer_output

    # Fase de retropropagación del error
    output_error = error * sigmoid_derivative(output_layer_output)
    hidden_error = np.dot(output_error, weights_hidden_output.T) * sigmoid_derivative(hidden_layer_output)

    # Actualización de pesos y sesgos
    weights_hidden_output += np.dot(hidden_layer_output.T, output_error) * learning_rate
    bias_output += np.sum(output_error, axis=0, keepdims=True) * learning_rate

    weights_input_hidden += np.dot(X.T, hidden_error) * learning_rate
    bias_hidden += np.sum(hidden_error, axis=0, keepdims=True) * learning_rate

# Predicción con el modelo entrenado
predictions = np.round(output_layer_output)
print("Predicciones finales:")
print(predictions)

¿Donde se aplica?

  • Detección de fraudes.

Supongamos lo siguiente:

Tienes un conjunto de datos que contiene información sobre transacciones, como el monto de la transacción, la ubicación, el tipo de tarjeta utilizada, entre otros atributos.

El objetivo del proyecto es clasificar las transacciones como "fraudulentas" o "no fraudulentas" con base en estos atributos

La red neuronal aprenderá a asignar una probabilidad a cada transacción, (un valor entre 0 y 1) que representa la probabilidad de que la transacción sea fraudulenta.

Una transacción con una probabilidad de 0.8 podría interpretarse como una alta probabilidad de que sea fraudulenta, mientras que una transacción con una probabilidad de 0.2 podría interpretarse como una baja probabilidad de que sea fraudulenta.

¿Donde se aplica?

  • Detección de fraudes.

Supongamos lo siguiente:

Tienes un conjunto de datos que contiene información sobre transacciones, como el monto de la transacción, la ubicación, el tipo de tarjeta utilizada, entre otros atributos.

El objetivo del proyecto es clasificar las transacciones como "fraudulentas" o "no fraudulentas" con base en estos atributos

Se establece un umbral (por ej, 0.5)  clasificar las transacciones con una probabilidad mayor o igual al umbral como "fraudulentas" y en caso contrario "no fraudulentas".

Una transacción con una probabilidad de 0.8 podría interpretarse como una alta probabilidad de que sea fraudulenta, mientras que una transacción con una probabilidad de 0.2 podría interpretarse como una baja probabilidad de que sea fraudulenta.

import numpy as np
import tensorflow as tf
from sklearn.model_selection import train_test_split

# Datos de ejemplo: atributos de transacciones y etiquetas (0 para no fraudulenta, 1 para fraudulenta)
X = np.array([[2.3, 4.5], [3.1, 5.2], [1.8, 3.9], [4.2, 6.5]])
y = np.array([0, 0, 1, 1])

# Dividir el conjunto de datos en entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Definir la arquitectura de la red neuronal
model = tf.keras.Sequential([
    tf.keras.layers.Dense(8, activation='relu', input_shape=(2,)),
    tf.keras.layers.Dense(1, activation='sigmoid')
])

# Compilar el modelo
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Entrenar la red neuronal
model.fit(X_train, y_train, epochs=100, batch_size=1)

# Evaluar el modelo en el conjunto de prueba
loss, accuracy = model.evaluate(X_test, y_test)
print("Precisión en el conjunto de prueba:", accuracy)

# Realizar predicciones en nuevas transacciones
new_data = np.array([[2.0, 4.3], [3.5, 6.0]])
predictions = model.predict(new_data)
print("Predicciones:", predictions)

Aprendizaje competitivo

Técnica de entrenamiento utilizada en redes neuronales y modelos de I.A. para inducir la competencia entre unidades o neuronas en el proceso de aprendizaje.

Implica ajustar los pesos de las conexiones de la red para minimizar una función de pérdida global,

Se basa en la competencia entre unidades para activarse y aprender.

La unidad que se activa más fuertemente frente a una entrada particular "gana" la competencia y se activa

unidades se inhiben o reducen su activación

Representación dispersa de la información, donde solo algunas unidades específicas responden a estímulos particulares.

Aplicaciones, como la clasificación y agrupación de datos, la selección de características y la búsqueda de patrones.

Mapas auto-organizados (Self-Organizing Maps - SOM)

Redes neuronales competitivas

Redes de winner-take-all

Son redes neuronales que utilizan el aprendizaje competitivo para clasificar entradas en diferentes categorías.

Son una clase de redes neuronales competitivas utilizadas para el agrupamiento y visualización de datos multidimensionales.

Son modelos en los que solo la unidad más activa o "ganadora" se activa, mientras que las demás unidades se inhiben.

Ejemplo

Supongamos que tienes un conjunto de datos con características numéricas que representan diferentes propiedades de ciertas flores, como longitud del sépalo, longitud del pétalo, ancho del sépalo y ancho del pétalo. Queremos agrupar estas flores en diferentes categorías (por ejemplo, diferentes especies) utilizando un SOM.

consiste en una red bidimensional de nodos o neuronas, donde cada neurona tiene un vector de pesos que es inicializado de manera aleatoria. Cada neurona representa una ubicación en el mapa y está asociada con un vector de características del mismo tamaño que los datos de entrada.

El proceso de aprendizaje competitivo se realiza iterativamente para cada ejemplo de entrenamiento

  1. La neurona "ganadora" se conoce como la "unidad ganadora."
  2. Luego, se actualizan los pesos de las neuronas vecinas en el mapa para que se asemejen más al ejemplo ganador.
  3. Esto permite que las neuronas cercanas a la unidad ganadora se adapten a las mismas características, lo que resulta en la agrupación de ejemplos similares en regiones cercanas del mapa.

A medida que se presentan más ejemplos de entrenamiento, las neuronas aprenden a representar diferentes regiones o grupos de datos en el mapa. Finalmente, el SOM organiza los datos en un mapa bidimensional donde los ejemplos similares se agrupan juntos.

El proceso de aprendizaje competitivo se realiza iterativamente para cada ejemplo de entrenamiento

Este proceso de aprendizaje competitivo y organización topológica permite visualizar y comprender la estructura subyacente de los datos de entrada de manera eficiente. Los SOM son especialmente útiles para la visualización de grandes conjuntos de datos en espacios de alta dimensión y para la exploración de patrones y relaciones entre los datos.

A medida que se presentan más ejemplos de entrenamiento, las neuronas aprenden a representar diferentes regiones o grupos de datos en el mapa. Finalmente, el SOM organiza los datos en un mapa bidimensional donde los ejemplos similares se agrupan juntos.

import numpy as np
import random

class SelfOrganizingMap:
    def __init__(self, input_dim, map_shape, learning_rate=0.1, epochs=100):
        self.input_dim = input_dim
        self.map_shape = map_shape
        self.learning_rate = learning_rate
        self.epochs = epochs

        # Inicializar los pesos de las neuronas aleatoriamente
        self.weights = np.random.rand(map_shape[0], map_shape[1], input_dim)

    def find_best_matching_unit(self, example):
        # Calcular las distancias euclidianas entre el ejemplo y los pesos de todas las neuronas
        distances = np.linalg.norm(self.weights - example, axis=2)

        # Obtener las coordenadas de la neurona ganadora
        winner_coords = np.unravel_index(np.argmin(distances), distances.shape)

        return winner_coords

    def update_weights(self, example, winner_coords, iteration):
        # Calcular la tasa de aprendizaje para esta iteración
        learning_rate = self.learning_rate * (1 - iteration / self.epochs)

        # Actualizar los pesos de las neuronas cercanas a la ganadora
        for i in range(self.map_shape[0]):
            for j in range(self.map_shape[1]):
                distance_to_winner = np.linalg.norm(np.array([i, j]) - np.array(winner_coords))
                influence = np.exp(-distance_to_winner / (2 * learning_rate**2))
                self.weights[i, j, :] += learning_rate * influence * (example - self.weights[i, j, :])

    def train(self, data):
        for epoch in range(self.epochs):
            for example in data:
                winner_coords = self.find_best_matching_unit(example)
                self.update_weights(example, winner_coords, epoch)

    def get_map(self):
        return self.weights.reshape(self.map_shape[0] * self.map_shape[1], self.input_dim)

# Ejemplo de datos de flores (longitud del sépalo, longitud del pétalo, ancho del sépalo, ancho del pétalo)
data = np.array([
    [5.1, 3.5, 1.4, 0.2],
    [4.9, 3.0, 1.4, 0.2],
    [5.8, 2.6, 4.0, 1.2],
    [6.7, 3.0, 5.2, 2.3],
    # Agrega más ejemplos aquí
])

# Normalizar los datos para que estén en el rango [0, 1]
data = (data - data.min(axis=0)) / (data.max(axis=0) - data.min(axis=0))

# Definir las dimensiones de entrada y el tamaño del mapa SOM (por ejemplo, 3x3)
input_dim = data.shape[1]
map_shape = (3, 3)

# Crear e entrenar el SOM
som = SelfOrganizingMap(input_dim, map_shape)
som.train(data)
# Obtener el mapa resultante
map_result = som.get_map()
print(map_result)

Actividad de aprendizaje

  • Entra a la pagina www.frexus.dev
  • Selecciona la opción slide
  • Selecciona la opción Inteligencia artificial.
  • En la sección de recursos busca la presentación con temas. Navega en ella hasta que llegues a las dos diapositivas anteriores.
  • Abre un bloc de notas.
  • Copia el código  en el bloc de notas.
  • Guarda el fichero con el nombre de: aprendizaje_competitivo.py
  • Abre una terminal y ejecuta: python aprendizaje_competitivo.py
  • Ejecuta tres veces el script. y responde lo siguiente:
  • En cada ejecución ¿se obtiene la misma matriz?
  • ¿Qué diferencia encuentras en cada matriz que se generó?

Coincidencia de hebbian

Regla de Hebb o aprendizaje hebbiano

propuesta por el psicólogo Donald Hebb en 1949

Es importante en neurociencia y se ha utilizado para explicar cómo las sinapsis (conexiones entre neuronas) se fortalecen o debilitan en función de la actividad neuronal repetida.

"Las células que se disparan juntas, se conectan juntas"

Si una neurona A dispara una señal y, a continuación, otra neurona B también dispara una señal, entonces la conexión sináptica entre A y B se fortalece.

ΔW_ij = η * output_i * output_j

  • ΔW_ij es el cambio en el peso sináptico entre la neurona i y la neurona j.
  • η es la tasa de aprendizaje, un hiperparámetro que controla la magnitud del cambio en el peso.
  • output_i es la salida de la neurona i.
  • output_j es la salida de la neurona j.

Supongamos que queremos crear una red neuronal simple que pueda asociar una serie de patrones de entrada con patrones específicos de salida. Asumiremos que tanto los patrones de entrada como los de salida son matrices binarias.

import numpy as np

# Función para aplicar la regla de Hebb y aprender la asociación entre patrones
def hebbian_learning(input_patterns, output_patterns):
    num_patterns = len(input_patterns)
    input_size = len(input_patterns[0])
    output_size = len(output_patterns[0])

    # Inicializar una matriz de pesos sinápticos con ceros
    weights = np.zeros((input_size, output_size))

    # Aplicar la regla de Hebb para cada par de patrones de entrada y salida
    for i in range(num_patterns):
        input_pattern = input_patterns[i]
        output_pattern = output_patterns[i]

        weights += np.outer(input_pattern, output_pattern)

    # Normalizar los pesos para evitar saturación
    weights = weights / num_patterns

    return weights
# Ejemplo de patrones de entrada y salida
input_patterns = np.array([[1, 0, 1],
                           [0, 1, 0],
                           [1, 1, 1]])

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

# Aplicar la regla de Hebb para aprender la asociación entre los patrones
learned_weights = hebbian_learning(input_patterns, output_patterns)

# Ejemplo de entrada para recuperar el patrón de salida asociado
input_example = np.array([1, 0, 1])
output_associated = np.dot(input_example, learned_weights)

print("Pesos sinápticos aprendidos:")
print(learned_weights)
print("\nPatrón de salida asociado al patrón de entrada:")
print(output_associated)

Actividad de aprendizaje

  • Entra a la pagina www.frexus.dev
  • Selecciona la opción slide
  • Selecciona la opción Inteligencia artificial.
  • En la sección de recursos busca la presentación con temas. Navega en ella hasta que llegues a las dos diapositivas anteriores.
  • Abre un bloc de notas.
  • Copia el código  en el bloc de notas.
  • Guarda el fichero con el nombre de: hebbian.py
  • Abre una terminal y ejecuta: python hebbian.py
  • Ejecuta tres veces el script. y responde lo siguiente:
  • Si el parametro input_patterns representa los parametros de entrada y output_patterns representa la matriz de parametros asociados acada patron
  • ¿Qué pasa si se cambia los valores de los patrones de entrada?

Redes atractoras.

Redes neuronales atractoras o redes dinámicas atractoras

Campo de la neurociencia computacional modelado Sys dinámicos

Propiedad de converger hacia estados estables llamados "atractores" en respuesta a diferentes patrones de entrada o condiciones iniciales.

Las neuronas interactúan entre sí y se influencian mutuamente a lo largo del tiempo mediante conexiones recurrentes.

A medida que la red procesa la información en el tiempo, tiende a converger hacia uno o varios estados estables.

Los estados estables son los atractores y representan patrones específicos o configuraciones de activación que la red puede mantener indefinidamente una vez que ha convergido hacia ellos.

Redes neuronales recurrentes, modela sistemas de comportamientos dinámicos complejos, (reconocimiento de patrones, memoria asociativa y procesamiento secuencial)

Atractores Punto

Atractores Ciclo:

Representan estados estables donde solo una combinación específica de activación neuronal es estable y cualquier pequeña perturbación en el sistema llevará a la red hacia ese estado particular. Son análogos a los puntos fijos en sistemas dinámicos.

Representan estados estables donde la red entra en un ciclo recurrente de activaciones neuronales que se repite de manera periódica. Estos ciclos pueden ser de diferentes longitudes, lo que significa que la red puede estabilizarse en diferentes secuencias de activación recurrente. Son análogos a los ciclos límite en sistemas dinámicos.

Utilizando una red atractora basada en las redes de Hopfield. Crearemos una red que puede recordar y recuperar patrones de entrada

import numpy as np

class HopfieldNetwork:
    def __init__(self, num_neurons):
        self.num_neurons = num_neurons
        self.weights = np.zeros((num_neurons, num_neurons))

    def train(self, patterns):
        for pattern in patterns:
            pattern_matrix = np.array(pattern).reshape(-1, 1)
            self.weights += np.dot(pattern_matrix, pattern_matrix.T)

        np.fill_diagonal(self.weights, 0)

    def recall(self, input_pattern, max_iterations=10):
        output_pattern = np.copy(input_pattern)

        for _ in range(max_iterations):
            new_output = np.dot(self.weights, output_pattern)
            new_output[new_output >= 0] = 1
            new_output[new_output < 0] = -1

            if np.array_equal(new_output, output_pattern):
                break

            output_pattern = new_output

        return output_pattern
# Ejemplo de patrones que la red aprenderá a recordar y recuperar
patterns = [
    [1, -1, 1],
    [-1, 1, -1],
    [1, 1, 1],
]

# Creamos y entrenamos la red de Hopfield
hopfield_net = HopfieldNetwork(len(patterns[0]))
hopfield_net.train(patterns)

# Patrón de entrada para recuperar
input_pattern = np.array([1, -1, 1])

# Recuperamos el patrón y lo mostramos
recovered_pattern = hopfield_net.recall(input_pattern)
print("Patrón de entrada original: ", input_pattern)
print("Patrón recuperado: ", recovered_pattern)

Actividad de aprendizaje

  • Entra a la pagina www.frexus.dev
  • Selecciona la opción slide
  • Selecciona la opción Inteligencia artificial.
  • En la sección de recursos busca la presentación con temas. Navega en ella hasta que llegues a las dos diapositivas anteriores.
  • Abre un bloc de notas.
  • Copia el código  en el bloc de notas.
  • Guarda el fichero con el nombre de: red_atractora.py
  • Abre una terminal y ejecuta: python red_atractora.py
  • Ejecuta tres veces el script. y responde lo siguiente:
  • Los patrones de entrada que queremos que la red recuerde se almacenan en la lista patterns.
  • ¿Qué pasa si se cambia los valores de los patrones de entrada?

En el ejemplo anterior, se ha entrenado la red con tres patrones. si pruebas diferentes patrones de entrada se notará cómo la red recupera los patrones aprendidos.

Recuerda que la capacidad de almacenamiento y recuperación de patrones de una red de Hopfield puede depender de la cantidad y complejidad de los patrones utilizados durante el entrenamiento.

Aprendizaje mecánico social y emergente

  • Algoritmos genéticos.

  • Vida artificial y aprendizaje social.

Aprendizaje mecánico social y emergente

Relacionados con el aprendizaje en sistemas distribuidos o poblaciones de agentes que interactúan entre sí para resolver problemas de manera colectiva y adaptativa.

Inspirada en observaciones de comportamientos sociales y de enjambres en la naturaleza.

Aprendizaje mecánico social y emergente

proceso de aprendizaje en el que los agentes individuales en un sistema distribuido observan y aprenden de las acciones o comportamientos de otros agentes en su entorno social.

Aprendizaje Mecánico Social

Los agentes pueden aprender directamente de la información que reciben de otros, imitando sus acciones o tomando decisiones basadas en la retroalimentación social.

Mejorar la eficiencia y la adaptabilidad del sistema.  Usado aplicaciones donde la colaboración y la comunicación entre agentes son esenciales para alcanzar objetivos complejos.

Aprendizaje mecánico social y emergente

Proceso en el que un comportamiento o conocimiento más complejo y sofisticado emerge en un sistema colectivo sin que exista una instrucción explícita o una autoridad central que lo dicte.

Aprendizaje Emergente

En lugar de ser programados o diseñados específicamente para realizar una tarea, los agentes individuales aprenden y adaptan su comportamiento a través de interacciones con el entorno y otros agentes.

Surge de la interacción y la autoorganización de los agentes individuales (patrones, estructuras y estrategias complejas que no eran previsibles inicialmente)

Aprendizaje mecánico social y emergente

Útil en sistemas complejos donde no es posible anticipar todos los escenarios posibles o diseñar algoritmos precisos para cada situación.

Aprendizaje Emergente

Los agentes individuales aprenden y adaptan su comportamiento a medida que interactúan con su entorno y otros agentes, lo que lleva a un comportamiento emergente del sistema en su conjunto.

Aprendizaje mecánico social y emergente

Se enfoca en cómo los agentes aprenden de otros en su entorno social

Aprendizaje Mecánico social

Se enfoca en cómo el comportamiento colectivo más complejo y sofisticado surge de la interacción y adaptación individual.

Aprendizaje Emergente

Algoritmos Genéticos

Son una técnica de optimización y búsqueda basada en la teoría de la evolución y la selección natural.

Inspirados en el proceso de selección natural que ocurre en la evolución biológica.

Algoritmo Genético (AG)

se utilizan para encontrar soluciones aproximadas a problemas de optimización y búsqueda en diversos campos.

Utilizado con éxito para resolver problemas de optimización, como la búsqueda de la mejor solución en un espacio de posibles soluciones muy grande y complejo

aplican en diversas áreas, como la ingeniería, la informática, la economía, la ciencia, entre otros.

útiles cuando no es posible encontrar una solución óptima en un tiempo razonable, y se busca una solución aproximada que sea suficientemente buena.

Representación del individuo

Selección

Etapas(AG)

Evaluación de la aptitud (fitness)

Operadores genéticos:

Reemplazo

Convergencia

Representación del individuo

Etapas(AG)

Cada solución potencial a un problema se representa como un "individuo" en una población. La representación puede ser una cadena de bits, una cadena de números, un vector, etc., dependiendo del problema en cuestión.

Evaluación de la aptitud (fitness)

Etapas(AG)

Cada individuo en la población se evalúa mediante una función de aptitud (también conocida como función de fitness). Esta función mide qué tan buena es cada solución para resolver el problema en cuestión. Los individuos con una mayor aptitud (valores más altos de la función de aptitud) se consideran más "aptos"

Selección

Etapas(AG)

Los individuos con una mayor aptitud tienen más probabilidades de ser seleccionados para formar parte de la próxima generación. La idea es que los individuos más aptos sean más propensos a transmitir sus características favorables a la siguiente generación, al igual que en la selección natural.

Operadores genéticos

Etapas(AG)

Se aplican operadores genéticos a los individuos seleccionados para simular procesos biológicos como la recombinación genética (crossover) y la mutación. La recombinación implica combinar características de dos individuos para crear nuevos descendientes, y la mutación implica cambiar aleatoriamente alguna característica en un individuo.

Reemplazo

Etapas(AG)

Después de aplicar los operadores genéticos, se forma una nueva población de individuos para la siguiente generación. Los individuos menos aptos pueden ser reemplazados por los nuevos descendientes más aptos, manteniendo el tamaño de la población constante.

Convergencia

Etapas(AG)

El proceso de selección, reproducción y reemplazo se repite durante varias generaciones. Con el tiempo, se espera que la población evolucione hacia soluciones cada vez mejores para el problema.

Usando Ag

Solucionar el problema 

El agente viajero (TSP por sus siglas en inglés, Traveling Salesman Problem) es uno de los problemas clásicos que se pueden resolver utilizando algoritmos genéticos. El TSP es un problema de optimización combinatoria que busca encontrar la ruta más corta que visite todas las ciudades una vez y regrese a la ciudad de origen, pasando por cada ciudad exactamente una vez.

Los algoritmos genéticos son especialmente útiles para abordar problemas de optimización como el TSP, donde se necesita encontrar una solución entre un gran número de posibilidades y no hay un algoritmo determinístico y eficiente que pueda encontrar una solución óptima en tiempo polinómico.

Representación del individuo

Etapas(AG)

Cada individuo en la población se representa como una secuencia de ciudades, que representa el orden en el que el agente visitará las ciudades.

Preparando el AG

Función de aptitud:

Etapas(AG)

La función de aptitud evalúa qué tan corta es la distancia total de la ruta del agente viajero. En el TSP, la aptitud de un individuo está inversamente relacionada con la distancia total recorrida. Es decir, cuanto más corta sea la ruta, mayor será la aptitud del individuo.

Preparando el AG

Inicialización de la población

Etapas(AG)

Se crea una población inicial de individuos, donde cada individuo representa una ruta potencial del agente viajero.

Preparando el AG

Selección

Etapas(AG)

Los individuos se seleccionan para la reproducción en función de su aptitud. Los individuos más aptos tienen más probabilidades de ser seleccionados.

Preparando el AG

Operadores genéticos

Etapas(AG)

Se aplican operadores genéticos como el cruce (crossover) y la mutación para crear una nueva generación de individuos. En el cruce, se combinan partes de dos individuos para crear nuevos descendientes. La mutación introduce pequeños cambios aleatorios en los individuos para aumentar la diversidad de la población.

Preparando el AG

Reemplazo

Etapas(AG)

La nueva generación reemplaza a la generación anterior, y el proceso de selección, cruce y mutación se repite durante varias generaciones hasta que se alcance una condición de parada, como un número máximo de generaciones o un criterio de convergencia.

Preparando el AG

aunque los algoritmos genéticos pueden encontrar soluciones aproximadas al TSP,

no garantizan encontrar la solución óptima en todos los casos debido a su naturaleza estocástica.

Con el tiempo, los individuos más aptos en la población evolucionarán hacia rutas más cortas y cercanas a la solución óptima del TSP.

Notas sobre los AG

Sin embargo, son capaces de encontrar buenas soluciones en tiempos razonables, especialmente para instancias de tamaño mediano a grande del problema del agente viajero.

import numpy as np
import matplotlib.pyplot as plt

# Función para calcular la distancia entre dos ciudades
def distance(city1, city2):
    return np.sqrt((city1[0] - city2[0])**2 + (city1[1] - city2[1])**2)

# Función de aptitud para el TSP (menor distancia total)
def fitness_function(route, cities):
    total_distance = 0
    for i in range(len(route) - 1):
        total_distance += distance(cities[route[i]], cities[route[i+1]])
    total_distance += distance(cities[route[-1]], cities[route[0]])
    return 1 / total_distance

# Función para inicializar una población aleatoria de rutas
def initialize_population(population_size, num_cities):
    population = []
    for _ in range(population_size):
        route = np.random.permutation(num_cities)
        population.append(route)
    return population

# Función para seleccionar individuos para el cruce mediante el método de ruleta
def selection(population, fitness_values):
    probabilities = fitness_values / np.sum(fitness_values)
    selected_indices = np.random.choice(len(population), size=len(population), p=probabilities)
    return [population[index] for index in selected_indices]

# Función de cruce utilizando el operador de orden
def crossover(parent1, parent2):
    start = np.random.randint(0, len(parent1))
    end = np.random.randint(start + 1, len(parent1) + 1)
    child = [-1] * len(parent1)

    child[start:end] = parent1[start:end]
    remaining_cities = [city for city in parent2 if city not in child]
    child[:start] = remaining_cities[:start]
    child[end:] = remaining_cities[start:]

    return child

# Función de mutación utilizando el intercambio de dos ciudades
def mutation(route):
    idx1, idx2 = np.random.choice(len(route), size=2, replace=False)
    route[idx1], route[idx2] = route[idx2], route[idx1]

# Función principal del algoritmo genético
def genetic_algorithm(num_cities, population_size, generations):
    # Generar ciudades aleatorias (coordenadas x, y)
    cities = np.random.rand(num_cities, 2)
    # Inicializar población aleatoria
    population = initialize_population(population_size, num_cities)
    best_fitness = -1
    best_route = []
    for generation in range(generations):
        fitness_values = [fitness_function(route, cities) for route in population]
        # Mantener el mejor individuo en cada generación
        best_index = np.argmax(fitness_values)
        if fitness_values[best_index] > best_fitness:
            best_fitness = fitness_values[best_index]
            best_route = population[best_index]
        # Selección y cruce
        parents = selection(population, fitness_values)
        children = []
        for i in range(0, len(parents), 2):
            parent1 = parents[i]
            parent2 = parents[i + 1]
            child1 = crossover(parent1, parent2)
            child2 = crossover(parent2, parent1)
            children.extend([child1, child2])
        # Mutación
        for route in children:
            if np.random.rand() < 0.2:
                mutation(route)

        population = children
    # Agregar la ciudad inicial al final de la mejor ruta encontrada para formar un ciclo
    best_route.append(best_route[0])
    return cities, best_route
# Parámetros del algoritmo genético
num_cities = 15
population_size = 100
generations = 1000

# Ejecutar el algoritmo genético
cities, best_route = genetic_algorithm(num_cities, population_size, generations)

# Visualizar la mejor ruta encontrada
plt.figure(figsize=(8, 6))
plt.scatter(cities[:, 0], cities[:, 1], c='blue', marker='o', label='Ciudades')
plt.plot(cities[best_route, 0], cities[best_route, 1], c='red', marker='o', linestyle='-', label='Mejor Ruta')
plt.plot(cities[best_route[0], 0], cities[best_route[0], 1], c='green', marker='o', linestyle='-', label='Inicio')
plt.xlabel('Coordenada X')
plt.ylabel('Coordenada Y')
plt.title('Problema del Agente Viajero Resuelto por Algoritmo Genético')
plt.legend()
plt.grid(True)
plt.show()

Actividad de aprendizaje

  • Entra a la pagina www.frexus.dev
  • Selecciona la opción slide
  • Selecciona la opción Inteligencia artificial.
  • En la sección de recursos busca la presentación con temas. Navega en ella hasta que llegues a las dos diapositivas anteriores.
  • Abre un bloc de notas.
  • Copia el código  en el bloc de notas.
  • Guarda el fichero con el nombre de: algoritmo_genetico.py
  • Abre una terminal y ejecuta: pip install matplotlib
  • Después ejecuta la siguiente linea python algoritmo_genetico.py
  • Ejecuta tres veces el script. y responde lo siguiente:
  • ¿Qué pasa en cada ejecución?
  • ¿Por qué los gráficos no son los mismos?

Vida artificial y aprendizaje social

Vida artificial

Campo interdisciplinario que estudia la vida y sistemas biológicos a través de modelos computacionales, simulaciones y experimentos en laboratorios.

Objetivo: comprender mejor la vida, evolución y los principios fundamentales de los sistemas vivos mediante la creación y estudio de sistemas que exhiban propiedades similares a las de estos

Busca crear entidades artificiales con comportamientos autónomos, evolutivos y emergentes, como los seres vivos.

Agentes inteligentes, autómatas celulares, algoritmos genéticos, redes neuronales artificiales, inspirados en la biología

Modelos informáticos para simular sistemas biológicos, creación de robots imitando comportamientos biológicos.

Investigación de algoritmos y técnicas que se inspiran en la naturaleza para resolver problemas complejos.

Aprendizaje Social

Aprendizaje que ocurre a través de la observación y la interacción con otros individuos en un entorno social.

Implica el proceso de adquirir conocimientos, habilidades y comportamientos a través de la observación de los demás, ya sean miembros de la misma especie o de diferentes especies.

Se busca desarrollar algoritmos y modelos que permitan a las máquinas aprender de forma social, ya sea mediante la observación de humanos o de otros agentes robóticos.

desarrollo de sistemas robóticos que puedan interactuar de manera más natural y colaborativa con los seres humanos y otros robots en entornos sociales y cooperativos.

Vida Artificial

Autómatas Celulares:

  • Modelos matemáticos que consisten en una malla o cuadrícula de celdas, donde cada una puede tomar diferentes estados.
  • A través de reglas de transición, las celdas cambian de estado en función de los estados de sus celdas vecinas.
  • Se utilizan en diversos campos, como modelar la propagación de enfermedades, la simulación de sistemas biológicos y ecológicos, y la generación de patrones complejos.

Vida Artificial

Algoritmos Genéticos:

  • Técnicas de optimización inspiradas en la teoría de la evolución biológica.
  • Conceptos como selección natural, cruzamiento y mutación para encontrar soluciones óptimas o aproximadas a problemas complejos.
  • Se aplican en campos como el diseño de circuitos, el diseño de sistemas de control, la planificación de rutas y la optimización de parámetros en modelos matemáticos.

Vida Artificial

Redes Neuronales Artificiales:

  • Inspiradas en el funcionamiento del cerebro y se utilizan para el aprendizaje automático y el reconocimiento de patrones.
  • Consisten en capas de neuronas interconectadas, donde las conexiones se refuerzan o debilitan en función de la información recibida.
  • Se aplican en tareas como clasificación de imágenes, procesamiento de lenguaje natural y predicción de series temporales.

Aprendizaje social

Aprendizaje por Imitación en Robótica

  • Los robots pueden aprender comportamientos observando y copiando las acciones de los humanos o de otros robots. Por ejemplo, un robot puede aprender a agarrar objetos correctamente al observar cómo lo hacen los humanos.

Aprendizaje social

Aprendizaje por Imitación en Robótica

  • Los robots pueden aprender comportamientos observando y copiando las acciones de los humanos o de otros robots. Por ejemplo, un robot puede aprender a agarrar objetos correctamente al observar cómo lo hacen los humanos.

Actividad de aprendizaje

Lista tres diferencias entre la vida artificial y el aprendizaje social.

Fin

Inteligencia Artificial II - temas

By Alfredo de Jesús Gutiérrez Gómez

Inteligencia Artificial II - temas

Slides is a presentation platform for developers built on top of the reveal.js open source HTML presentation framework. We offer a wide range of developer-focused features like step-by-step code highlighting, a CSS editor, LaTeX typesetting and more.

  • 52

More from Alfredo de Jesús Gutiérrez Gómez