UD02 — Modelos de IA y resolución de problemas¶

1. Introducción¶

En la UD01 aprendiste a identificar sistemas de IA y a relacionarlos con la eficiencia operativa. En esta unidad damos un paso más: no solo reconocer la IA, sino formalizar y resolver problemas con modelos de IA. Para ello recorremos un camino progresivo:

1. Primero, qué debe cumplir un sistema que resuelve problemas con IA, y cómo se representa un problema para que una máquina pueda resolverlo (espacio de estados y algoritmos de búsqueda).
2. Después, cómo se clasifican los modelos de IA (por aprendizaje, por análisis, por conocimiento frente a datos).
3. A continuación, qué se puede automatizar y con qué tecnología (RPA frente a IA, agentes).
4. Luego, las dos familias de razonamiento que tocarás en el laboratorio: lógica difusa y sistemas basados en reglas.
5. Por último, cómo elegir el modelo adecuado para cada problema (CE f).

El núcleo práctico usa dos librerías de Python que ya están en el stack del curso: scikit-fuzzy (lógica difusa) y experta (sistemas basados en reglas). La unidad se cierra con Robocode Tank Royale: programar un bot que compite en un campo de batalla es, literalmente, implementar un sistema de resolución de problemas de principio a fin.

2. Resultado de aprendizaje y criterios de evaluación¶

RA2 — Utiliza modelos de sistemas de Inteligencia Artificial implementando sistemas de resolución de problemas.

Nota sobre la tabla anterior.

3. Objetivos de la unidad¶

4. Sistema de resolución de problemas (RA2-a)¶

4.1 Cinco requisitos de un sistema de resolución de problemas¶

Antes de formalizar un problema concreto, conviene fijar qué debe cumplir cualquier sistema de IA que pretenda resolver problemas de forma efectiva y útil:

1. Representación del problema: elegir una estructura de datos y un modelo que reflejen fielmente el dominio. En PLN, por ejemplo, convertir texto a vectores numéricos; en un puzzle, una matriz de fichas (§4.2).
2. Razonamiento y toma de decisiones: aplicar técnicas lógicas, de aprendizaje o de búsqueda heurística para llegar a una solución a partir de la información disponible.
3. Aprendizaje y adaptabilidad: mejorar el rendimiento con la experiencia — aprendizaje automático o por refuerzo cuando el problema lo permite.
4. Eficiencia computacional: usar algoritmos y estructuras que den respuestas rápidas y escalables (por eso importa tanto BFS/DFS/A*, §4.3).
5. Interacción con las personas usuarias: una interfaz comprensible que facilite la comunicación entre el sistema y quien lo usa.

4.2 El espacio de estados¶

Muchos problemas de IA se resuelven convirtiéndolos en una búsqueda: existe un conjunto de configuraciones posibles (los estados) y unas acciones que pasan de un estado a otro. Ese grafo de estados conectados por acciones es el espacio de estados.

Un sistema de resolución de problemas necesita, formalmente (base AIMA):

1. Estado inicial: la configuración de partida.
2. Acciones aplicables: qué movimientos se pueden hacer en cada estado.
3. Modelo de transición: función que, dado un estado y una acción, produce el siguiente estado.
4. Test de objetivo: cómo saber que hemos llegado a la solución.
5. Coste de camino: el coste de cada acción (para encontrar la solución más barata).

Además, se elige la representación (cómo codificar cada estado) y la estrategia de búsqueda (completa, óptima, memoria).

4.3 Ejemplos clásicos de representación¶

Nota sobre la tabla anterior.

4.4 Algoritmos de búsqueda: BFS, DFS y A*¶

• BFS explora por niveles: encuentra el camino más corto en pasos, pero consume mucha memoria (guarda todos los estados del nivel).
• DFS baja hasta el fondo: usa poca memoria, pero puede no encontrar la solución óptima (o no terminar en espacios infinitos). Es la base del backtracking (8-reinas).
• A* combina el coste acumulado g(n) con una heurística h(n) (una estimación de lo que falta): f(n) = g(n) + h(n). Con una heurística admisible (que no sobreestime), A* es completo y óptimo. Se usa mucho en videojuegos, mapas y planificación de rutas.

5. Clasificación de modelos de IA (RA2-b)¶

5.1 Por paradigma de aprendizaje¶

Nota sobre la tabla anterior.

5.2 Por tipo de análisis¶

El prescriptivo es el que aporta más valor: no solo predice, recomienda o ejecuta la decisión óptima (Gartner lo llama "la última frontera" de la analítica).

5.3 Basados en conocimiento frente a basados en datos¶

6. Modelos de automatización de tareas (RA2-c)¶

6.1 RPA frente a IA¶

Nota sobre la tabla anterior.

6.2 Agentes software¶

Un agente de IA es un programa que percibe su entorno y actúa para lograr un objetivo. Se ordenan de más simple a más avanzado:

6.3 Tareas cognitivas automatizables¶

La IA automatiza tareas cognitivas que antes requerían juicio humano:

• Extracción: leer documentos (OCR), extraer entidades (NER), capturar datos de facturas.
• Clasificación: spam, incidencias, prioridades. Los sistemas de reconocimiento de voz (Google Speech-to-Text, Microsoft Azure Speech Service) son otro caso de automatización de tareas: convierten habla en texto y automatizan la transcripción o los comandos de voz.
• Generación: redactar respuestas, resúmenes o informes (IA generativa).

7. Razonamiento impreciso: lógica difusa (RA2-d)¶

7.1 De lo booleano a lo difuso¶

La lógica clásica solo admite verdadero/falso (0/1). La lógica difusa (Zadeh, 1965) permite grados de verdad entre 0 y 1: algo puede ser parcialmente verdadero. Modela la vaguedad del lenguaje humano (la probabilidad, en cambio, modela la incertidumbre). Es la familia de modelos que se usa cuando los datos son incompletos o inciertos y aun así hay que decidir algo razonable.

7.2 Conjuntos difusos y funciones de pertenencia¶

Un conjunto difuso asigna a cada valor un grado de pertenencia µ(x) ∈ [0,1] mediante una función de pertenencia. Las más usadas:

Nota sobre la tabla anterior.

7.3 Operaciones difusas¶

Zadeh definió las operaciones básicas sobre grados de pertenencia:

• AND (intersección): mínimo de los grados (µ_A ∧ µ_B = min(µ_A, µ_B)).
• OR (unión): máximo (µ_A ∨ µ_B = max(µ_A, µ_B)).
• NOT (complemento): 1 − µ.

En scikit-fuzzy, las reglas usan por defecto fmin/fmax para AND/OR (se pueden cambiar a producto/suma difusa).

7.4 El sistema de inferencia difuso (FIS)¶

1. Fuzzificar: convertir cada entrada numérica en grados de pertenencia.
2. Aplicar reglas SI calidad es mala O servicio es pobre ENTONCES propina es baja.
3. Agregar: combinar la salida de todas las reglas.
4. Defuzzificar: obtener un número nítido. Métodos típicos: centroide (centro de gravedad), bisector, MOM/SOM/LOM.

Hay dos familias de sistemas: Mamdani (la salida es un conjunto difuso que luego se defuzzifica; la implementa scikit-fuzzy) y Sugeno/TSK (la salida de cada regla es una función z = f(x,y), más eficiente para control).

7.5 Aplicaciones reales¶

• Metro de Sendai (Japón, 1987): control difuso de aceleración y frenado.
• Autofocus de Canon: 12 entradas (claridad y velocidad del objetivo), 13 reglas, solo 1,1 KB de memoria.
• ABS (frenos): estima el agarre con lógica difusa sobre la temperatura del freno.
• Electrodomésticos: lavadoras Hitachi (peso/suciedad → programa), vacuolas Matsushita.
• Control industrial: hornos de cemento (Dinamarca, 1976), aires acondicionados Mitsubishi (calienta/enfría 5× más rápido con un 24 % menos de consumo).
• Control de tráfico: ajuste de los tiempos de los semáforos en función del flujo vehicular en tiempo real, para reducir la espera de los vehículos.
• Apoyo al diagnóstico médico: evaluación de síntomas cuando los resultados de las pruebas no son concluyentes, para dar una valoración preliminar que considere varios factores a la vez.

7.6 Práctica con scikit-fuzzy¶

pip install -U scikit-fuzzy (versión 0.5.0, 2024). Ejemplo clásico: el problema de la propina — la propina depende de la calidad del servicio y de la comida.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

import numpy as np
import skfuzzy as fuzz
from skfuzzy import control as ctrl

# 1. Variables (universo de discurso)
calidad = ctrl.Antecedent(np.arange(0, 11, 1), 'calidad')
servicio = ctrl.Antecedent(np.arange(0, 11, 1), 'servicio')
propina = ctrl.Consequent(np.arange(0, 26, 1), 'propina')

# 2. Funciones de pertenencia
calidad.automf(3, names=['mala', 'aceptable', 'excelente'])
servicio.automf(3, names=['pobre', 'aceptable', 'bueno'])
propina['baja'] = fuzz.trimf(propina.universe, [0, 5, 10])
propina['media'] = fuzz.trimf(propina.universe, [10, 15, 20])
propina['alta'] = fuzz.trimf(propina.universe, [15, 20, 25])

# 3. Reglas
regla1 = ctrl.Rule(calidad['mala'] | servicio['pobre'], propina['baja'])
regla2 = ctrl.Rule(servicio['aceptable'], propina['media'])
regla3 = ctrl.Rule(servicio['bueno'] | calidad['excelente'], propina['alta'])

# 4. Sistema y simulación
sistema = ctrl.ControlSystem([regla1, regla2, regla3])
sim = ctrl.ControlSystemSimulation(sistema)
sim.input['calidad'] = 6.5
sim.input['servicio'] = 9.8
sim.compute()
print(f"Propina sugerida: {sim.output['propina']:.2f}%")
# Salida esperada: Propina sugerida: ~20% (el valor exacto depende del universo)

8. Sistemas basados en reglas (RA2-e)¶

8.1 El ciclo reconocer-actuar¶

Un sistema de producción (o sistema basado en reglas) tiene:

• Memoria de trabajo: los hechos conocidos en cada momento.
• Base de conocimiento: las reglas SI <condiciones> ENTONCES <acciones>.
• Motor de inferencia: ejecuta el ciclo reconocer-actuar.

El ciclo se repite hasta que no queden reglas aplicables:

1. Reconocer (match): se comparan los hechos de la memoria de trabajo con las condiciones de las reglas; las reglas cuyas condiciones se cumplen van a la agenda.
2. Resolver (resolve): si hay varias reglas activas, se elige una según prioridad (salience), frescura de los hechos o especificidad.
3. Actuar (act): se ejecuta la parte ENTONCES, que modifica la memoria de trabajo (declarar/retractar hechos) y el ciclo se repite.

Los motores industriales usan el algoritmo RETE (Forgy, 1974) para no reevaluar todas las reglas cada vez: construye una red de filtrado en memoria.

8.2 Encadenamiento hacia delante y hacia atrás¶

• Hacia delante (forward chaining, data-driven): parte de los hechos y deduce hechos nuevos. Ideal para monitorización, planificación y entornos dinámicos. Es el que usan CLIPS y experta.
• Hacia atrás (backward chaining, goal-driven): parte de una meta y busca qué hechos la sustentan (preguntando al usuario solo lo necesario). Ideal para diagnóstico (MYCIN, Prolog).

8.3 CLIPS y experta¶

CLIPS (C Language Integrated Production System) es el motor de reglas de referencia, desarrollado por la NASA (1985-1996) y de dominio público desde 1996. experta es una librería de Python inspirada en CLIPS (fork de pyknow) que implementa un motor RETE con sintaxis nativa de Python.

8.4 Ejemplos cotidianos de sistemas basados en reglas¶

Antes de los grandes sistemas expertos históricos (§8.6), los sistemas basados en reglas están en aplicaciones que usas a diario:

• Sistemas de recomendación: plataformas de comercio electrónico como Amazon sugieren productos relacionados aplicando reglas sobre el historial de compras y el comportamiento del usuario.
• Soporte al diagnóstico médico: en asistencia remota, reglas basadas en los síntomas declarados dan una recomendación preliminar antes de que la persona sea atendida por un profesional.

Se usan mucho porque el razonamiento es transparente: las reglas son explícitas y una persona puede leer exactamente por qué el sistema tomó esa decisión — al contrario que una red neuronal.

8.5 Práctica con experta¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

# PARCHE para Python 3.10+ (issue #34 de experta)
import collections
import collections.abc
if not hasattr(collections, 'Mapping'):
    collections.Mapping = collections.abc.Mapping
    collections.Iterable = collections.abc.Iterable
    collections.MutableMapping = collections.abc.MutableMapping

from experta import *

class DiagnosticoVehiculo(KnowledgeEngine):
    @DefFacts()
    def inicio(self):
        yield Fact(accion="diagnosticar")

    @Rule(Fact(accion="diagnosticar"), salience=10)
    def arrancar(self):
        print("Iniciando diagnóstico del vehículo...")
        self.declare(Fact(bateria="descargada"))
        self.declare(Fact(luces="no_encienden"))

    @Rule(Fact(bateria="descargada"), Fact(luces="no_encienden"))
    def bateria(self):
        self.declare(Fact(causa="bateria_descargada"))

    @Rule(Fact(causa="bateria_descargada"))
    def resultado(self):
        print("CAUSA PROBABLE: Batería descargada")

engine = DiagnosticoVehiculo()
engine.reset()   # activa DefFacts e InitialFact
engine.run()     # ejecuta el ciclo reconocer-actuar

Salida esperada:

1
2

Iniciando diagnóstico del vehículo...
CAUSA PROBABLE: Batería descargada

8.6 Sistemas expertos reales¶

Nota sobre la tabla anterior.

9. Adecuación del modelo (RA2-f)¶

9.1 Criterios para elegir modelo¶

Nota sobre la tabla anterior.

9.2 Secuencia práctica recomendada¶

1. Reglas o heurística (explicable, sin datos).
2. Árbol de decisión / regresión logística (datos tabulares pequeños).
3. Ensamble (Random Forest / XGBoost) si hace falta precisión.
4. Deep learning solo si hay datos masivos y el problema lo exige.

10. Caso de estudio: Robocode como sistema de resolución de problemas completo¶

Los cinco requisitos del §4.1 y la elección de modelo del §9 dejan de ser teoría en cuanto se programa un bot de Robocode Tank Royale (la actividad entregable de la unidad):

• Representación: el estado del bot (posición, energía, rumbo del radar) y del campo de batalla se traduce a variables que el programa puede leer en cada turno.
• Razonamiento: decidir hacia dónde disparar o moverse es exactamente el problema de elegir modelo del §9 — puedes usar reglas fijas («si el enemigo está a menos de 100 px, dispara»), lógica difusa sobre la distancia y el ángulo, o una combinación.
• Eficiencia: el bot decide en tiempo real, turno a turno; una lógica demasiado costosa computacionalmente pierde el combate por lentitud, no por mala estrategia.
• Adecuación del modelo (CE f): no hay datos de entrenamiento previos sobre "cómo gana este bot en concreto", así que el punto de partida natural es la regla o heurística (§9.2, paso 1), no el aprendizaje automático.

11. Puntos clave de la unidad¶

• Un sistema de resolución de problemas de IA debe cumplir 5 requisitos: representación, razonamiento, aprendizaje/adaptabilidad, eficiencia computacional e interacción con el usuario.
• Un problema se formaliza con estado inicial, acciones, transición, objetivo y coste; la búsqueda recorre el espacio de estados.
• BFS es completa y óptima en pasos pero usa mucha memoria; DFS usa poca memoria pero no es óptima; A* es óptimo con heurística admisible.
• Los modelos de IA se clasifican por aprendizaje (supervisado/no supervisado/refuerzo), por análisis (descriptivo/predictivo/prescriptivo) y por base (conocimiento vs datos).
• RPA "hace" y la IA "piensa": la automatización inteligente combina IA + BPM + RPA.
• La lógica difusa modela la vaguedad con grados de pertenencia [0,1], funciones de pertenencia, reglas Mamdani/Sugeno y defuzzificación por centroide.
• Los sistemas basados en reglas ejecutan el ciclo reconocer-actuar con un motor RETE; experta es su port Python (requiere parche en Py3.10+).
• Para elegir modelo (CE f): valora datos, explicabilidad, coste, precisión y tiempo real y empieza por el modelo más simple.

12. Glosario¶

13. FAQ¶

14. Planificación sesión a sesión¶

15. Tabla final RA/CE¶

16. Recursos¶

• Diapositivas
• Ejercicios de la unidad
• Talleres: T01 · control difuso · T02 · sistema de reglas · T03 · preparar el entorno · T04 · GitHub · T05 · Markdown
• Actividad entregable: Robocode Tank Royale · comparativa Java/Python · tutorial Java · tutorial Python
• Notebooks — Talleres 1 y 2, con descarga y apertura en Colab, en el menú «Notebooks»

17. Evaluación¶

• La normativa exige alcanzar todos los RA del módulo para superarlo (art. 5.1 de la Orden 8/2025: la calificación del módulo está «en función de la consecución de los RA»; y las Instrucciones 26-27, que impiden calificar positivamente un módulo con RA no superados). El centro concreta ese mandato exigiendo ≥ 5 en cada RA.

18. Recuperación¶

Actividades del programa de recuperación individual por RA (art. 14.4 Orden 8/2025): repetir la resolución de un problema de búsqueda con un caso distinto y las pruebas de autoevaluación de la unidad.

Volver al índice