UNIVERSIDAD PERUANA DE CIENCIAS APLICADAS
FACULTAD DE INGENIERÍA
ESCUELA PROFESIONAL DE INGENIERÍA MECATRÓNICA
INTELIGENCIA ARTIFICIAL
EVALUACIÓN DE DESEMPEÑO
INTEGRANTES:
Raul Gonzalo Alarcon Mamani - U201722336
Kevin Oziel Marquina Rojas - U202013654
Luis Felipe Temoche Dedios - U20181C826
PROFESOR:
Dante Anael Vargas Machuca Acevedo
Ciclo 2025
1
Análisis de Redes Neuronales
ARQUITECTURAS DE REDES NEURONALES
Este informe examina cinco arquitecturas neuronales y computacionales avanzadas: Redes de
Función de Base Radial (RBF), Redes Residuales Profundas (DRN), Cadenas de Markov (MC),
Redes de Hopfield (HN) y Máquinas de Turing Neuronales (NTM). Se analizan a fondo las
funciones, algoritmos subyacentes y aplicaciones de cada modelo. Además, se exploran
algoritmos de procesamiento de imágenes, con un enfoque en su papel en tareas de
clasificación y segmentación, incluyendo ejemplos de implementación y validación del
rendimiento mediante pruebas. Este estudio exhaustivo destaca las fortalezas y la relevancia
práctica de estas tecnologías en los sistemas modernos de aprendizaje automático.
1. Redes de Función de Base Radial (RBF)
Son FFNN con funciones de base radial como funciones de activación. A diferencia de las
redes feedforward, las redes RBF trabajan con un enfoque de aprendizaje localizado,
centrándose en puntos de datos cercanos a centros específicos. Son un tipo con una sola capa
oculta, donde las neuronas utilizan funciones de activación basadas en la distancia,
usualmente gaussianas. Se usan principalmente para problemas de clasificación, regresión y
aproximación de funciones. Son particularmente útiles para resolver problemas no lineales al
aproximar las relaciones complejas en los datos.
a. Arquitectura
La RBF tiene tres capas:
Capa de entrada: recibe las características de los datos de entrada y los pasa a la capa oculta.
Cada nodo en la capa de entrada corresponde a una sola función de entrada. La capa no
realiza ningún cálculo; simplemente reenvía los datos de entrada. (Por ejemplo, para un
conjunto de datos con 3 características: altura, peso y edad, la capa de entrada tendrá 3
nodos.)
2
Capa oculta (RBF): Cada neurona calcula una función gaussiana (o radial) entre el input y un
centro (centroid), lo cual mide la similitud entre el input y ese centro. La función de activación
de las neuronas de la capa oculta es de base radial, de ahí el nombre de esta red, y una
función comúnmente usada para activar estas neuronas es la función Gaussiana; y las
neuronas de la capa de salida presentan un comportamiento similar a un perceptrón simple. La
activación es más alta cuando la entrada está cerca del centro y disminuye a medida que
aumenta la distancia. Para un input x, la capa oculta calcula la activación de cada neurona RBF
en función de su distancia al centro de la neurona.
Donde:
x: punto de entrada
C: centro de la neurona.
σ: parámetro de dispersión que define hasta qué punto se extiende la influencia de la neurona.
Capa de salida: Esta capa combina las salidas de la capa oculta utilizando una combinación
lineal de pesos para producir la predicción final.
Donde:
Wkj: peso para cada neurona RBF
ϕj(x): es la función de activación gaussiana
bkes el bias (opcional)
b. Algoritmo
● Selección de centros RBF: Los centros de las funciones de base radial en la capa oculta
son cruciales porque determinan la capacidad de la red para aproximar las funciones o
clasificar los datos de manera efectiva.
- Selección aleatoria: elige puntos directamente del conjunto de entrenamiento, aunque
puede ser subóptimo.
- Clustering con k-means: se aplica el algoritmo k-means para encontrar k centros
representativos en el espacio de entrada. Estos centros se usan como los centros Cj de
las funciones gaussianas en la capa oculta.
Ejm: En un conjunto de datos con 500 puntos, la agrupación de K-means puede
seleccionar 10 centros que mejor representen el conjunto de datos completo.
● Determinación del Parámetro de Dispersión (σ)
3
La dispersión (spread) controla el “ancho” de la función gaussiana y define el alcance de
influencia de cada neurona. Si σ es muy pequeño, las neuronas reaccionan sólo a
puntos muy cercanos y hay riesgo de sobreajuste. Si σ es muy grande, las neuronas se
activan por puntos muy lejanos y hay subajuste.
- Distancia promedio entre centros: La propagación se puede establecer en función de la
distancia promedio entre los centros seleccionados.
- Validación cruzada: Se prueban múltiples spreads y el que proporciona el mejor
rendimiento en los datos de validación es elegido.
● Entrenamiento de Pesos de Salida: Una vez definidos los centros y spreads, se calcula
la salida de cada neurona para cada muestra del dataset. Luego, se entrena la capa de
salida mediante una combinación lineal de esas activaciones.
● Entrada de datos: Se reciben las características del conjunto de entrada.
● Cálculo de distancias: Cada neurona oculta mide la distancia entre la entrada y su
centro.
● Activación: Se aplica una función de base radial (típicamente gaussiana) sobre esa
distancia.
● Combinación lineal: Las activaciones se combinan linealmente en la capa de salida,
usando pesos.
● Generación de salida: Se produce la salida final (clasificación o valor continuo).
c. Aplicaciones de las RBF
Las redes RBF se utilizan en múltiples campos por su rapidez en entrenamiento y su capacidad
para aproximar funciones no lineales:
● Reconocimiento de patrones: Reconocimiento de letras, firmas manuscritas, caracteres
OCR.
● Sistemas de control: Controladores adaptativos en sistemas no lineales.
● Predicción de series temporales: Predicción del clima, precios de acciones, consumo
energético.
● Interpolación de funciones: Aproximación de funciones desconocidas a partir de
muestras.
● Clasificación médica: Diagnóstico asistido por computadora, detección de
enfermedades.
La red RBF es un modelo simple pero potente, especialmente útil cuando se dispone de
pocos datos y se requiere una respuesta rápida. Su estructura modular, la separación entre
entrenamiento no supervisado (centros) y supervisado (pesos), la hace intuitiva y eficiente.
2. Redes Residuales Profundas (DRN)
Las Redes Residuales Profundas, conocidas como ResNets, fueron introducidas por Kaiming
He en 2015, como una solución al problema de degradación del rendimiento en redes
neuronales muy profundas. A medida que las redes aumentaban su profundidad, se esperaba
que el rendimiento mejore, pero ocurría lo contrario: el error de entrenamiento y validación
comenzaban a aumentar. Esto no se debía al sobreajuste, sino a dificultades en el
entrenamiento derivadas de la propagación del gradiente.
4
Las ResNets se centran en el uso de conexiones residuales o "skip connections". En lugar de
forzar a cada capa a aprender una transformación completamente nueva, se permite que la red
aprenda una función residual con respecto a la entrada. Es decir, en vez de aprender
directamente H(x), la red aprende F(x)=H(x)−x, y luego suma la entrada: H(x)=F(x)+x. Esta
estructura facilita el flujo de información y gradientes a través de la red, permitiendo entrenar
modelos con cientos o incluso miles de capas sin sufrir degradación significativa.
a. Arquitectura
Se basa en el uso de bloques residuales, compuestas por varias capas ocultas (convoluciones,
normalización, activación) más una conexión directa que suma la entrada original del bloque
con su salida procesada.
Un bloque residual se compone de:
● Entrada: x
● Transformación no lineal: F(x,Wi), donde Wi son los pesos del bloque
● Salida del bloque: y=F(x)+x
Una ResNet se compone de:
● Una capa convolucional inicial
● Varios grupos de bloques residuales (3, 4 o más, según la profundidad)
● Una capa de pooling global (como Average Pooling)
● Una capa totalmente conectada (fully connected) final para la clasificación
b. Algoritmo
El algoritmo de una ResNet es el siguiente:
1. Entrada de datos: ingreso de una imagen o señal.
5
2. Capa convolucional inicial: aplica una convolución estándar para extraer
características básicas.
3. Bloque Residuales: arquitectura mencionada previamente
4. Pooling global: agrupa las características de las salidas de los bloques residuales.
5. Capa fully connected: capa para producir la salida/clasificación.
6. Cálculo del error (función de pérdida): compara la salida con etiqueta real.
7. Cálculo del gradiente (backpropagation): calcula el gradiente del error.
8. Actualización de pesos (descenso del gradiente): ajusta pesos.
c. Aplicaciones
i. Clasificación de imágenes
ii. Detección y segmentación de objetos
iii. Reconocimiento facial
iv. Medicina
v. Visión en vehículos autónomos
vi. Transfer learning
3. Cadenas de Markov (MC)
a. Arquitectura
La arquitectura de una Cadena de Markov se basa en la definición de un conjunto
finito de posibles estados, denotado como 𝑆 = {𝑠1, 𝑠2,..., 𝑠𝑁}}, donde 𝑁 representa
el número total de estados en el sistema. Las transiciones entre estos estados
están gobernadas por una matriz de probabilidad de transición PP de tamaño
𝑁 × 𝑁, donde cada elemento 𝑃𝑖𝑗 define la probabilidad de pasar del estado 𝑠𝑖 al
estado 𝑠𝑗en un solo paso, expresado como:
𝑃𝑖𝑗 = 𝑃(𝑋𝑡+1 = 𝑠𝑗 ∣ 𝑋𝑡 = 𝑠𝑖
Donde 𝑋𝑡 denota el estado del sistema en el tiempo 𝑡. La propiedad de la Cadena de
Markov establece que el siguiente estado depende únicamente del estado actual.
Además, la suma de las probabilidades de transición desde cualquier estado debe ser igual
a 1:
𝑁
∑ 𝑃𝑖𝑗 = 1
𝑗=1
Esto garantiza que el sistema debe transitar a algún estado en cada paso.
b. Algoritmo
El algoritmo de la Cadena de Markov describe la evolución estocástica de un
sistema a través de una secuencia de estados discretos en el tiempo.
● Definición del Espacio de Estados:
6
Definir el conjunto finito de posibles estados que el sistema puede ocupar.
Cada estado representa una condición distinta del sistema que se está
modelando.
● Construcción de la Matriz de Probabilidades de Transición:
𝑁×𝑁
Construir la matriz de probabilidades de transición 𝑃 ∈ 𝑅
● Selección del Estado Inicial:
Elegir un estado inicial basado en conocimientos previos o en condiciones
iniciales asumidas.
● Proceso de Evolución de Estados:
Para cada paso de tiempo:
● Extraer el vector de distribución de probabilidad correspondiente al
estado actual.
● Generar un número aleatorio con distribución uniforme.
● Calcular la suma acumulada de las probabilidades de transición
para determinar a qué estado transitará el sistema.
● Iteración:
Repetir el proceso de evolución de estados durante el número de pasos
deseado.
c. Aplicaciones de MC
● Procesamiento de Lenguaje Natural:
Las Cadenas de Markov se utilizan para la generación de texto, predicción
de palabras y modelado del lenguaje. Predicen la probabilidad de una
palabra dado el término anterior, lo que permite construir oraciones
sintácticamente coherentes en chatbots, sistemas de autocompletado y
traducción automática.
● Bioinformática:
En genómica y proteómica, las Cadenas de Markov modelan secuencias
de ADN y proteínas para predecir la probabilidad de ciertas combinaciones
de nucleótidos o aminoácidos. Los Modelos Ocultos de Markov (HMM, por
sus siglas en inglés), una extensión de las Cadenas de Markov, se
emplean comúnmente en la identificación de genes y la predicción de
estructuras proteicas.
7
● Sistemas de Recomendación:
Se aplican en plataformas en línea para predecir las preferencias de los
usuarios y sugerir productos o contenidos relevantes. El sistema modela la
secuencia de interacciones del usuario (por ejemplo, productos vistos)
como estados de un proceso de Markov para anticipar la siguiente acción
probable.
Las Cadenas de Markov se utilizan ampliamente en diversos campos
debido a su simplicidad y efectividad para modelar procesos estocásticos.
4. Redes de Hopfield (HN)
La red de Hopfield es una red neuronal recurrente totalmente conectada, diseñada para
funcionar como una memoria asociativa. Fue propuesta por John Hopfield en 1982 y se
caracteriza por ser capaz de almacenar patrones binarios y recordarlos incluso cuando
se presentan de forma incompleta o con ruido. Las neuronas en esta red tienen
conexiones simétricas entre sí y no se conectan a sí mismas. Esta arquitectura garantiza
la convergencia hacia un estado estable, minimizando una función de energía.
A. Arquitectura
Cada neurona está conectada a todas las demás mediante pesos sinápticos w_ij,
cumpliendo la condición w_ij = w_ji y w_ii = 0. Las actualizaciones pueden realizarse
de forma asincrónica o sincrónica.
La figura muestra la arquitectura de una red de Hopfield. Cada nodo representa una
neurona, y cada línea representa una conexión sináptica entre neuronas. Todas las
neuronas están interconectadas con pesos simétricos (w_ij = w_ji), y no existen
auto-conexiones (w_ii = 0). Esta organización permite que la red funcione como una
memoria asociativa capaz de recuperar patrones previamente almacenados.
B. Función de activación
La función de activación utilizada es determinística y no probabilística. Se basa en
el signo de la entrada neta:
8
C. Ecuaciones fundamentales
• Matriz de pesos (regla de Hebb):
• Energía del sistema:
D. Ejecución paso a paso
Se definen los patrones P1 = [1, -1, 1, -1] y P2 = [-1, -1, 1, 1]. Se calcula la matriz
de pesos usando la regla de Hebb. Se presenta un patrón ruidoso como entrada:
S0 = [1, -1, -1, -1]. En cada iteración, se selecciona una neurona y se actualiza su
estado aplicando la función signo sobre la suma ponderada de los estados
actuales de las demás neuronas.
E. Resultados
9
La gráfica superior muestra cómo evolucionan los estados de las neuronas a lo
largo de las iteraciones. Cada línea representa una neurona. La gráfica inferior
muestra cómo disminuye la energía del sistema con cada actualización, hasta
alcanzar un mínimo estable.
F. Aplicaciones
• Corrección de patrones con ruido
• Reconocimiento de caracteres o dígitos
• Implementación de memoria asociativa
• Recuperación de información incompleta
5. Máquinas de Turing Neuronales (NTM).
a. Arquitectura
Una Máquina de Turing Neural (Neural Turing Machine, NTM) combina un módulo de control
con una memoria externa diferenciable para realizar operaciones complejas y secuenciales
sobre datos. El controlador, generalmente una red neuronal recurrente, procesa la entrada
actual, los estados anteriores de la memoria y los vectores leídos para generar los parámetros
necesarios para las operaciones de lectura y escritura en la memoria. Esta arquitectura permite
que el modelo aprenda de manera flexible cómo almacenar, recuperar y manipular información
de forma integral mediante retropropagación.
10
Architecture NTM
Mecanismo de direccionamiento
Addressing Mechanism NTM
Direccionamiento basado en contenido:
● Vector clave (Kt): Un vector de consulta producido por el controlador, que se usa para
comparar con cada fila en la memoria.
● Fuerza (t): Un escalar positivo que ajusta cuán estrechamente el modelo se enfoca en
las entradas de memoria más similares; valores más altos hacen que la búsqueda sea
más precisa, mientras que valores más bajos amplían el enfoque.
La selección de memoria basada en contenido aprovecha una métrica de similitud,
generalmente la similitud del coseno, escalada por un parámetro de fuerza para generar una
distribución de atención enfocada y normalizada sobre las ranuras de memoria.
𝑤𝑡𝑐𝑖 = 𝑠𝑜𝑓𝑡𝑚𝑎𝑥(𝑡𝐾𝑡, 𝑀𝑡(𝑖))
donde δ𝑎,𝑏 = (∣𝑎∣∣𝑏∣)/𝑎⋅𝑏
11
Direccionamiento basado en ubicación:
● Interpolación (gt): Fusiona de manera fluida el enfoque basado en contenido con la
atención del paso de tiempo anterior, asegurando continuidad en el acceso a la
memoria.
● Desplazamiento (st): Rota u offseta la distribución de atención a través de las ranuras
de memoria, permitiendo que el modelo recorra las secuencias en orden.
● Agudización (t): Intensifica el pico de atención comprimiendo el enfoque en las
ubicaciones de memoria más relevantes, produciendo una búsqueda más nítida y
decisiva.
Interpolación entre los pesos de direccionamiento basado en contenido y los pesos de
direccionamiento previos:
𝑤𝑡𝑔 = 𝑔𝑡𝑤𝑡𝑐 + (1 − 𝑔𝑡)𝑤𝑡 − 1
Operaciones posteriores a los desplazamientos y agudización:
𝑤𝑡𝑠 = 𝑗𝑤𝑡𝑔 + 𝑗𝑠𝑡𝑖−𝑗
𝑤𝑡𝑖 = 𝑤𝑡𝑠𝑖𝑡𝑗𝑤𝑡𝑠𝑗𝑡
Lectura: Los pesos derivados de los mecanismos de direccionamiento recuperan los datos de
la memoria:
𝑟𝑡 = 𝑖𝑤𝑡𝑖𝑀𝑡(𝑖)
Escritura: Involucra borrar y agregar. El vector de borrado elimina la memoria que ya no es
relevante:
𝑀𝑡𝑖 = 𝑀𝑡−1(𝑖)(1 − 𝑤𝑡𝑖𝑒𝑡)
Los nuevos datos se colocan en la memoria mediante la adición:
𝑀𝑡𝑖 = 𝑀𝑡(𝑖)(1 − 𝑤𝑡𝑖𝑎𝑡)
b. Algoritmo
Flujo paso a paso que realiza una NTM en cada paso de tiempo 𝑡:
Este proceso se puede ejecutar para cada cabezal de lectura/escritura si tu diseño utiliza
múltiples cabezales.
● Actualización del controlador
1. Recibir el vector de entrada actual 𝑥𝑡.
12
2. Concatenarlo con el(s) vector(es) leído(s) previamente 𝑟 𝑡−1.
3. Alimentar este vector combinado al controlador (por ejemplo, un LSTM) para producir el
nuevo estado oculto (ℎ𝑡,𝑐𝑡).
● Generación de parámetros
Desde el nuevo estado oculto ℎ𝑡, se emiten los siguientes parámetros de control para cada
cabezal:
● Vector clave 𝑘𝑡 y fuerza β𝑡 (para direccionamiento basado en contenido).
● Puerta de interpolación 𝑔𝑡, vector de desplazamiento 𝑠𝑡, y escalar de agudización γ𝑡
(para direccionamiento basado en ubicación).
● Vector de borrado 𝑒𝑡 y vector de adición 𝑎𝑡(para escritura en memoria).
● Cálculo de pesos de atención
● Direccionamiento basado en contenido:
○ Comparar 𝑘𝑡 con cada fila de la memoria anterior 𝑀𝑡−1(por ejemplo, mediante
similitud de coseno).
𝑐
○ Escalar por β𝑡y normalizar (softmax) para obtener los pesos de contenido 𝑤𝑡 .
𝑤𝑡𝑐 = 𝑠𝑜𝑓𝑡𝑚𝑎𝑥(β𝑡𝑘𝑡, 𝑀𝑡−1(𝑖))
● Direccionamiento basado en ubicación:
𝑐
○ Interpolar entre 𝑤𝑡 y los pesos del paso anterior 𝑤𝑡−1 utilizando 𝑔𝑡.
○ Aplicar un desplazamiento circular según 𝑠𝑡.
○ Agudizar el resultado utilizando γ𝑡 y renormalizar para producir los pesos finales
𝑤𝑡.
𝑤𝑡𝑔 = 𝑔𝑡𝑤𝑡𝑐 + (1 − 𝑔𝑡)𝑤𝑡−1
𝑤𝑡 = 𝑐𝑖𝑟𝑐𝑢𝑙𝑎𝑟𝑠ℎ𝑖𝑓𝑡(𝑤𝑡𝑔, 𝑠𝑡)
𝑤𝑡 = 𝑠𝑜𝑓𝑡𝑚𝑎𝑥(γ𝑡 𝑤𝑡)
● Lectura de memoria
● Calcular el nuevo vector de lectura 𝑟𝑡 como la suma ponderada de las filas de 𝑀𝑡−1
usando 𝑤𝑡.
13
𝑟𝑡 = ∑ 𝑤𝑡(𝑖)𝑀𝑡−1(𝑖)
𝑖
● Escritura en memoria
● Paso de borrado: atenuar la memoria existente en cada celda según 𝑤𝑡y 𝑒𝑡.
𝑀𝑡𝑖 = 𝑀𝑡−1(𝑖)(1 − 𝑤𝑡𝑒𝑡)
● Paso de adición: incorporar la nueva información 𝑎𝑡 ponderada por 𝑤𝑡, produciendo la
memoria actualizada 𝑀𝑡.
𝑀𝑡1 = 𝑀𝑡(𝑖)(1 − 𝑤𝑡𝑎𝑡)
● Salida externa (Opcional)
● Si tu arquitectura lo requiere, combinar ℎ𝑡 y 𝑟𝑡 para producir una salida externa 𝑦𝑡.
𝑦𝑡 = 𝑓(ℎ𝑡, 𝑟𝑡)
● Preparación para el siguiente paso
● Almacenar 𝑤𝑡, 𝑟𝑡 (ℎ𝑡,𝑐𝑡) y 𝑀𝑡, y proceder al paso 𝑡 + 1.
c. Aplicaciones de las NTM
● Razonamiento Algorítmico
Copia de secuencias, ordenamiento, adición de vectores, cálculo de suma acumulada
(prefix-sum).
● Procesamiento de Lenguaje Natural
Preguntas y respuestas con memoria de trabajo, gestión de diálogos de largo contexto,
recuperación de información a largo plazo.
● Manipulación de Estructuras de Datos
Inserción, eliminación, concatenación en listas/arreglos y búsquedas dinámicas de claves-valor.
● Aprendizaje por Refuerzo Aumentado con Memoria
Agentes que recuerdan eventos pasados para planificar rutas o tomar decisiones en entornos
secuenciales.
14
● Meta-Aprendizaje e Inducción de Programas
Inferir rutinas pequeñas o fragmentos de código a partir de pocos ejemplos y generalizar la
lógica subyacente.
Algoritmo de procesamiento de imagenes:
Los algoritmos de procesamiento de imágenes son técnicas y métodos aplicados para analizar,
modificar y mejorar imágenes digitales. Estos algoritmos permiten desde la detección de
bordes hasta la clasificación de objetos en una fotografía.
Se destacan varios algoritmos para su desarrollo entre los cuales se encuentra:
● Redes Neuronales Convolucionales (CNNs):
○
PAPERS
Desarrollo de estrategias de control difuso para un manipulador robótico de 3
DOF en seguimiento de trayectoria
Compara controladores difusos tipo Mamdani y ANFIS en un robot de 3 DOF, demostrando que
ambos permiten un seguimiento preciso de trayectorias suaves con alta robustez frente a
perturbaciones externas.
Control deslizante difuso adaptativo con supervisión difusa para manipuladores
planos de 3 DOF
Proponen un sistema híbrido que combina lógica difusa con control por modo deslizante,
aumentando la estabilidad del robot ante incertidumbre dinámica y errores de modelado.
Control adaptativo difuso en tiempo real basado en referencia modelo para un
brazo robótico de 3 DOF
Implementa un controlador adaptativo difuso tipo Takagi–Sugeno en tiempo real para un brazo
robótico físico, validando su desempeño con bajo sobreimpulso y tiempos de asentamiento
rápidos.
Lógica difusa adaptativa en control backstepping para robot paralelo tipo delta de
3 DOF
Integra control backstepping con lógica difusa en un robot paralelo delta de 3 DOF, logrando
ejecutar trayectorias complejas como una figura en "8" con buena estabilidad.
Control de movimiento en robot delta de 3 DOF usando sistemas neurodifusos
con entrada visual
15
Aplica un sistema neurodifuso con entrada visual a un robot delta, demostrando cómo la visión
por computadora puede ser utilizada como señal de referencia efectiva para el control difuso.
Diseño, simulación y comparación de estrategias avanzadas de control para un
robot de 3 DOF
Compara estrategias avanzadas (PD, PI, MPC y fuzzy) en un robot de 3 DOF con sensores
visuales, destacando la buena relación entre simplicidad y rendimiento del controlador difuso
frente a otras alternativas.
ANEXOS
%%[Link]
clear all
close all
% Load data
load MNIST_dataset.mat;
% Select the classes '8' and '1' for training set
train_idx_81 = find(train_classlabel == 8 | train_classlabel == 1);
train_classlabel = train_classlabel(train_idx_81);
train_data = train_data(:,train_idx_81);
% Select the classes '8' and '1' for test set
test_idx_81 = find(test_classlabel == 8 | test_classlabel == 1);
test_classlabel = test_classlabel(test_idx_81);
test_data = test_data(:,test_idx_81);
% Convert the ground-truth label information into {0,1} (useful to assess
% the recognition performance)
train_classlabel_logical = (train_classlabel == 8);
test_classlabel_logical = (test_classlabel == 8);
%% Question 2.a : exact interpolation method
% Compute the interpolation matrix
sigma_exact = 100;
N = length(train_data(1,:));
phi_exact_train = interpolation_matrix(train_data, N, train_data, sigma_exact *
ones(N,1), false);
% Compute the weights
weights_exact = inv(phi_exact_train) * train_classlabel';
y_train_exact = phi_exact_train * weights_exact;
% Output of the test set
phi_exact_test = interpolation_matrix(test_data, N, train_data, sigma_exact *
ones(N,1), false);
y_test_exact = phi_exact_test * weights_exact;
% Evaluation of the recognition performance of the exact interpolation
% method
[thres_exact, train_accuracy_exact, test_accuracy_exact] =
recognition_performance(y_train_exact, train_classlabel_logical, y_test_exact,
test_classlabel_logical, 1000);
%% Question 2.b : Fixed Centers Selected at Random
M = 100;
[mu_random, sigma_random] = get_fixed_centers(train_data, M);
phi_random_train = interpolation_matrix(train_data, M, mu_random, sigma_random, true);
% Compute the weights
weights_random = inv(phi_random_train' * phi_random_train) * (phi_random_train' *
train_classlabel');
y_train_random = phi_random_train * weights_random;
% Output of the test set
phi_random_test = interpolation_matrix(test_data, M, mu_random, sigma_random, true);
y_test_random = phi_random_test * weights_random;
% Evaluation of the recognition performance of the exact interpolation
% method
16
[thres_random, train_accuracy_random, test_accuracy_random] =
recognition_performance(y_train_random, train_classlabel_logical, y_test_random,
test_classlabel_logical, 1000);
%% Plot the accuracy
figure
subplot(2,1,1)
plot(thres_exact, train_accuracy_exact,'.-',thres_exact, test_accuracy_exact,'^-');
axis([1,8,0.5,1])
xlabel('threshold value')
ylabel('accuracy')
title('Recognition performance with exact interpolation')
legend('train','test')
subplot(2,1,2)
axis([1,8,0.5,1])
plot(thres_exact, train_accuracy_random,'.-',thres_exact, test_accuracy_random,'^-');
xlabel('threshold value')
ylabel('accuracy')
title('Recognition performance with Fixed Centers Selected at Random')
legend('train','test')
assignin('base', 'train_outputs', y_train_random);
assignin('base', 'test_outputs', y_test_random);
clc; clear; close all;
disp("Cargando dataset...");
init; % Carga train_data, train_classlabel, test_data, test_classlabel
disp("Entrenando red RBF...");
rbfn_standard % Ejecuta el script. No recibe ni devuelve datos.
% Verifica que se hayan generado estas variables:
% train_outputs
% test_outputs
% disp("Evaluando rendimiento...");
% recognition_performance(train_outputs, train_classlabel, test_outputs,
test_classlabel, 1000);
disp("Todo listo.");
% === Visualizar las primeras 16 imágenes del set de entrenamiento ===
figure;
colormap(gray); % Escala de grises
for i = 1:16
subplot(4, 4, i);
% Extraer la i-ésima imagen (columna) y convertir a 28x28
img = reshape(train_data(:, i), [28, 28]);
% Mostrar imagen en escala de grises
imagesc(img');
axis off;
% Mostrar la clase correspondiente
title(sprintf('Clase: %d', train_classlabel(i)));
end
sgtitle('Primeras 16 imágenes de entrenamiento');
% === Visualizar las primeras 16 imágenes del set de prueba ===
figure;
colormap(gray); % Escala de grises
for i = 1:16
subplot(4, 4, i);
% Extraer la i-ésima imagen del set de prueba (están en columnas)
img = reshape(test_data(:, i), [28, 28]);
% Mostrar imagen en escala de grises
imagesc(img');
axis off;
% Mostrar la clase correspondiente
title(sprintf('Clase: %d', test_classlabel(i)));
end
17
sgtitle('Primeras 16 imágenes del set de prueba');
2. DRN
import torch
import [Link] as nn
import [Link] as optim
import torchvision
import [Link] as transforms
import json
import sys
from [Link] import resnet18
# Argumento desde terminal
modelo_nombre = "ResNet18"
# Dataset
transform = [Link]([
[Link](),
[Link]((0.4914, 0.4822, 0.4465), (0.247, 0.243, 0.261))
])
trainset = [Link].CIFAR10(root='./data', train=True,
download=True, transform=transform)
testset = [Link].CIFAR10(root='./data', train=False,
download=True, transform=transform)
trainloader = [Link](trainset, batch_size=128,
shuffle=True, num_workers=2)
testloader = [Link](testset, batch_size=100, shuffle=False,
num_workers=2)
device = [Link]("cuda" if [Link].is_available() else "cpu")
# Modelos
class CNN3([Link]):
def __init__(self):
super(CNN3, self).__init__()
[Link] = [Link](
nn.Conv2d(3, 32, 3, padding=1), [Link](), nn.MaxPool2d(2),
nn.Conv2d(32, 64, 3, padding=1), [Link](), nn.MaxPool2d(2),
nn.Conv2d(64, 128, 3, padding=1), [Link](), nn.MaxPool2d(2),
)
[Link] = [Link](
[Link](),
[Link](128*4*4, 128), [Link](),
[Link](128, 10)
)
18
def forward(self, x):
return [Link]([Link](x))
class CNN6([Link]):
def __init__(self):
super(CNN6, self).__init__()
[Link] = [Link](
nn.Conv2d(3, 32, 3, padding=1), [Link](),
nn.Conv2d(32, 32, 3, padding=1), [Link](), nn.MaxPool2d(2),
nn.Conv2d(32, 64, 3, padding=1), [Link](),
nn.Conv2d(64, 64, 3, padding=1), [Link](), nn.MaxPool2d(2),
nn.Conv2d(64, 128, 3, padding=1), [Link](),
nn.Conv2d(128, 128, 3, padding=1), [Link](), nn.MaxPool2d(2)
)
[Link] = [Link](
[Link](),
[Link](128 * 4 * 4, 256), [Link](),
[Link](256, 10)
)
def forward(self, x):
return [Link]([Link](x))
class CNN10([Link]):
def __init__(self):
super(CNN10, self).__init__()
layers = []
in_channels = 3
# Primer bloque: 5 conv con 64 canales
for _ in range(5):
layers += [nn.Conv2d(in_channels, 64, 3, padding=1), [Link]()]
in_channels = 64 # después de la primera capa, in_channels = 64
[Link](nn.MaxPool2d(2))
# Segundo bloque: 4 conv con 128 canales
for _ in range(4):
layers += [nn.Conv2d(in_channels, 128, 3, padding=1), [Link]()]
in_channels = 128
[Link](nn.MaxPool2d(2))
# Última conv: 256 canales
layers += [nn.Conv2d(in_channels, 256, 3, padding=1), [Link](),
nn.MaxPool2d(2)]
[Link] = [Link](*layers)
[Link] = [Link](
[Link](),
[Link](256 * 4 * 4, 512), [Link](),
[Link](512, 10)
)
19
def forward(self, x):
return [Link]([Link](x))
# Modelo
if modelo_nombre == "CNN3":
model = CNN3()
elif modelo_nombre == "CNN6":
model = CNN6()
elif modelo_nombre == "CNN10":
model = CNN10()
elif modelo_nombre == "ResNet18":
model = resnet18(weights=None, num_classes=10)
model.conv1 = nn.Conv2d(3, 64, 3, stride=1, padding=1)
[Link] = [Link]()
else:
raise ValueError("Modelo no válido")
if __name__ == '__main__':# Entrenamiento
[Link](device)
optimizer = [Link]([Link](), lr=0.001)
criterion = [Link]()
train_accs, val_accs = [], []
for epoch in range(10):
[Link]()
correct, total = 0, 0
for inputs, labels in trainloader:
inputs, labels = [Link](device), [Link](device)
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, labels)
[Link]()
[Link]()
correct += ([Link](1) == labels).sum().item()
total += [Link](0)
train_accs.append(correct / total)
[Link]()
correct, total = 0, 0
with torch.no_grad():
for inputs, labels in testloader:
inputs, labels = [Link](device), [Link](device)
outputs = model(inputs)
correct += ([Link](1) == labels).sum().item()
total += [Link](0)
val_accs.append(correct / total)
20
print(f"Epoch {epoch+1}/{10}, Train Acc: {train_accs[-1]:.4f}, Val Acc:
{val_accs[-1]:.4f}")
# Guardar resultados
with open(f"{modelo_nombre}_resultados.json", "w") as f:
[Link]({"train": train_accs, "val": val_accs}, f)
print(f" ✅ Resultados guardados en {modelo_nombre}_resultados.json")
import json
import [Link] as plt
modelos = ["CNN3", "CNN6", "CNN10", "ResNet18"]
resultados = {}
for modelo in modelos:
with open(f"{modelo}_resultados.json", "r") as f:
data = [Link](f)
resultados[modelo] = data
[Link](figsize=(12, 5))
# Train
[Link](1, 2, 1)
for modelo in resultados:
[Link](resultados[modelo]["train"], label=modelo)
[Link]("Train Accuracy")
[Link]("Epoch")
[Link]("Accuracy")
[Link]()
# Validation
[Link](1, 2, 2)
for modelo in resultados:
[Link](resultados[modelo]["val"], label=modelo)
[Link]("Validation Accuracy")
[Link]("Epoch")
[Link]("Accuracy")
[Link]()
plt.tight_layout()
[Link]()
21
3.- MC
clc;
clear;
% Matriz de transición para estados de una máquina
P = [0.7 0.2 0.0 0.1 0.0;
0.5 0.3 0.1 0.1 0.0;
0.4 0.3 0.2 0.1 0.0;
0.2 0.3 0.3 0.1 0.1;
0.0 0.0 0.6 0.0 0.4];
% Nombres de los estados
states = {'Operativa', 'Mantenimiento preventivo', 'Mantenimiento correctivo', 'Fallo
leve', 'Fallo grave'};
num_steps = 20; % Número de pasos simulados
current_state = 1; % Estado inicial (1 = Operativa)
state_sequence = zeros(1, num_steps + 1);
state_sequence(1) = current_state;
fprintf('Estado inicial: %s\n', states{current_state});
for step = 1:num_steps
probs = P(current_state, :); % Probabilidades del estado actual
r = rand; % Número aleatorio
cumulative = cumsum(probs); % Suma acumulativa
next_state = find(r <= cumulative, 1); % Encuentra el siguiente estado
fprintf('Paso %2d: %s\n', step, states{next_state}); % Imprime estado
state_sequence(step + 1) = next_state; % Guarda el estado
current_state = next_state; % Actualiza estado
end
% Generar gráfico de evolución de estados
figure;
stairs(0:num_steps, state_sequence, 'LineWidth', 2);
yticks(1:length(states));
yticklabels(states);
xlabel('Paso');
ylabel('Estado');
title('Evolución de los Estados de la Máquina');
grid on;
4-HN:
import numpy as np
import [Link] as plt
# Definir patrones binarios (vectores -1 y 1)
22
P1 = [Link]([1, -1, 1, -1])
P2 = [Link]([-1, -1, 1, 1])
P = [Link]((P1, P2), axis=1)
# Crear la matriz de pesos usando la regla de Hebb
W = P @ P.T
np.fill_diagonal(W, 0)
# Estado inicial (patrón ruidoso similar a P1)
S = [Link]([1, -1, -1, -1])
# Guardar la evolución de S para visualizarla
history = [[Link]()]
energy = []
# Función para calcular la energía
def calc_energy(W, S):
return -0.5 * S @ W @ S.T
# Actualización asincrónica
for epoch in range(5):
for i in range(len(S)):
S[i] = [Link](W[i, :] @ S)
[Link]([Link]())
[Link](calc_energy(W, S))
# Convertir historial a matriz para graficar
history = [Link](history)
# Graficar evolución de cada neurona
fig, axs = [Link](2, 1, figsize=(10, 6))
for i in range([Link][1]):
axs[0].step(range([Link][0]), history[:, i], label=f'Neurona {i+1}')
axs[0].set_title('Evolución de las neuronas')
axs[0].set_xlabel('Iteración')
axs[0].set_ylabel('Estado')
axs[0].legend(loc='upper right')
axs[0].grid(True)
# Graficar energía
axs[1].plot(range(len(energy)), energy, marker='o')
axs[1].set_title('Evolución de la energía')
axs[1].set_xlabel('Iteración')
axs[1].set_ylabel('Energía')
axs[1].grid(True)
23
plt.tight_layout()
[Link]()
import numpy as np
import [Link] as plt
# ====== 1. Definir las letras A, E, I, O, U ======
A = [Link]([
[0,0,1,0,0],
[0,1,0,1,0],
[1,0,0,0,1],
[1,1,1,1,1],
[1,0,0,0,1],
[1,0,0,0,1],
[1,0,0,0,1]
])
E = [Link]([
[1,1,1,1,1],
[1,1,0,0,0],
[1,1,1,1,0],
[1,1,0,0,0],
[1,1,0,0,0],
[1,1,0,0,0],
[1,1,1,1,1]
])
I = [Link]([
[0,1,1,1,0],
[0,0,1,0,0],
[0,0,1,0,0],
[0,0,1,0,0],
[0,0,1,0,0],
[0,0,1,0,0],
[0,1,1,1,0]
])
O = [Link]([
[0,1,1,1,0],
[1,0,0,0,1],
[1,0,0,0,1],
[1,0,0,0,1],
[1,0,0,0,1],
[1,0,0,0,1],
[0,1,1,1,0]
24
])
U = [Link]([
[1,0,0,0,1],
[1,0,0,0,1],
[1,0,0,0,1],
[1,0,0,0,1],
[1,0,0,0,1],
[1,1,0,1,1],
[0,1,1,1,0]
])
# ====== 2. Convertir a vectores bipolares (-1, 1) ======
def bin_to_bipolar(letter):
return [Link]([Link](-1) == 0, -1, 1)
A = bin_to_bipolar(A)
E = bin_to_bipolar(E)
I = bin_to_bipolar(I)
O = bin_to_bipolar(O)
U = bin_to_bipolar(U)
letras = {"A": A, "E": E, "I": I, "O": O, "U": U}
# ====== 3. Entrenar red Hopfield ======
patterns = [Link](list([Link]()))
N = [Link][1]
W = [Link]((N, N))
for p in patterns:
W += [Link](p, p)
np.fill_diagonal(W, 0)
# ====== 4. Probar recuperación para cada letra con ruido ======
for nombre, letra in [Link]():
S = [Link]()
flip_idx = [Link](N, size=10, replace=False) # ruido: cambia 10
bits
S[flip_idx] *= -1
# Iteraciones de recuperación
history = [[Link]()]
for _ in range(30):
for i in range(N):
S[i] = [Link](W[i] @ S)
[Link]([Link]())
# Mostrar iteraciones
25
fig, axs = [Link](1, len(history), figsize=(20, 2))
for i, h in enumerate(history):
axs[i].imshow([Link](7, 5), cmap='gray_r') # Colores invertidos
(blanco sobre negro)
axs[i].axis('off')
axs[i].set_title(f'It {i}')
[Link](f"Recuperación de la letra '{nombre}' distorsionada",
fontsize=16)
plt.tight_layout()
[Link]()
5-NMT
26
27
28
29