Examen – Inteligencia Artificial y Agentes (Resuelto)
Fecha de resolución: 2025-09-11 16:20
1) Introducción a la IA – Preguntas abiertas
1. Definición de IA. Rama de la computación que estudia modelos capaces de realizar actividades humanas
como razonamiento, aprendizaje, percepción y comprensión del lenguaje natural.
2. Campos de aplicación. Asistentes virtuales, vehículos autónomos, diagnóstico médico, educación, industria,
agricultura.
3. Hitos. 1956 (Dartmouth), 2012 (AlexNet en ImageNet), 2020 (modelos de lenguaje a gran escala, [Link].
GPT-3).
4. Impacto de modelos recientes. Mejoran PLN y generación de texto, habilitan asistentes y herramientas
creativas y de programación.
5. Capacidades: Razonamiento (decidir lógicamente), Aprendizaje (mejorar con datos/experiencia), Percepción
(interpretar sensores), Lenguaje natural (entender/producir texto/habla).
6. IA simbólica vs conectivista vs evolutiva. Simbólica: reglas y símbolos; Conectivista: redes neuronales;
Evolutiva: algoritmos genéticos y afines.
7. Ventajas conectivistas. Escalan en datos, generalizan y manejan problemas con patrones complejos no
lineales.
8. Métodos de aprendizaje. Supervisado (con etiquetas), No supervisado (patrones sin etiquetas), Por refuerzo
(recompensas/castigos).
1.2) Verdadero / Falso (justificar)
1) Falso: lo conectivista no se basa en reglas simbólicas sino en redes neuronales y pesos sinápticos.
2) Verdadero: el APR se guía por recompensas/castigos para mejorar su política.
3) Falso: aprender sin etiquetas corresponde a no supervisado, no a supervisado.
2) Agentes Inteligentes – Preguntas abiertas
1. Componentes: Sensores (perciben), función del agente (decide), actuadores (actúan).
2. Tipos por sensores/actuadores: Humano (ojos/oídos – voz/manos), Robótico (cámaras/proximidad –
motores), Software (APIs/archivos – respuestas digitales).
3. Agente de reflejo simple: útil en entornos simples y completamente observables ([Link]., termostato);
limitación: no usa memoria ni planifica.
4. Basado en utilidad vs metas: el de utilidad compara alternativas y puede ser más eficiente al optimizar
desempeño, no solo alcanzar la meta.
5. Diseño robot aspiradora: Sensores: suciedad/posición/batería; Actuadores: motor de succión/movimiento;
Objetivo: maximizar % limpio minimizando pasos y energía; Criterio de término: todo limpio o batería baja.
6. Entorno estático vs dinámico: Estático (ajedrez durante la decisión), Dinámico (tráfico en conducción).
2.2) Verdadero / Falso (justificar)
1) Falso: el reflejo simple no considera historia.
2) Falso: el basado en metas sí considera el objetivo futuro (meta) para decidir.
3) Falso: en parcialmente observable no se tiene toda la información; “completamente observable” es lo
contrario.
3) Representación de problemas y búsqueda
1. Elementos de un problema: Estado inicial (configuración de partida), Operadores/acciones (cómo transitar),
Prueba de meta (verifica objetivo), Función de costo (mide recursos). Ej.: Rutas en mapa.
2. BFS vs DFS: BFS expande por niveles y halla rutas más cortas si costos iguales; DFS profundiza una rama y
usa poca memoria pero no garantiza óptimo.
3. Costo uniforme: Expande siempre el camino de menor costo acumulado con cola de prioridad; útil cuando
los costos varían y se busca minimizar distancia/tiempo.
4. Mensajero: Estado inicial: oficina central; Operadores: moverse por calles no bloqueadas; Meta: estar en la
casa; Costo: tiempo/distancia ponderando bloqueos/tráfico.
5. Viajero: Para distancia → costo uniforme; para tiempo → redefinir costo por tiempo (velocidades, tráfico) y
usar la misma estrategia.
3.2) Verdadero / Falso (justificar)
1) Verdadero: se modela como espacio de estados.
2) Falso: DFS no garantiza solución óptima en costo.
3) Verdadero: la función de costo guía y determina la eficiencia/óptimo hallado.
4) Agente Aspiradora
a) Explicación del código original (intención vs efecto real):
• Comparar cadenas con == y no con is (identidad).
• Alternar A↔B sin 'or pos' innecesario.
• Contar todos los pasos (aspirar y mover).
• Si hay límite de pasos, usar pasos < pasos_max.
b) Versión corregida con límite y c) versión sin límite (termina al 100%).
# Versión sin límite: se detiene cuando todo está limpio
def aspiradora_hasta_limpiar(seed=7):
import random
[Link](seed)
ESTADOS = ("sucio", "limpio")
habitaciones = {"A": [Link](ESTADOS), "B": [Link](ESTADOS)}
posicion = [Link](["A", "B"])
def todo_limpio(hs): return [Link]("A") == "limpio" and [Link]("B") == "limpio"
def avanzar(p): return "B" if p == "A" else "A"
def aspirar(hs, p): hs[p] = "limpio"
pasos = 0
while not todo_limpio(habitaciones):
actual = posicion
if [Link](actual) == "sucio":
aspirar(habitaciones, actual)
else:
posicion = avanzar(posicion)
pasos += 1
limpias = sum(1 for v in [Link]() if v == "limpio")
porcentaje = 100*limpias/len(habitaciones)
return pasos, porcentaje, posicion
d) Evidencia de ejecución (salida en consola):
Versión corregida con límite (simulación de 3 pasos máx.)
Estado inicial: {'A': 'limpio', 'B': 'sucio'} | Posición inicial: B
[0] Pos=B Estado={'A': 'limpio', 'B': 'sucio'}
- Acción: aspirar
FIN Pos=B Estado={'A': 'limpio', 'B': 'limpio'} Pasos=1
Versión que se detiene cuando todo está limpio
Estado inicial: {'A': 'limpio', 'B': 'sucio'} | Posición inicial: B
[0] Pos=B Estado={'A': 'limpio', 'B': 'sucio'}
- Acción: aspirar
FIN Pos=B Estado={'A': 'limpio', 'B': 'limpio'} Pasos=1 Limpieza=100%
Resumen: pasos=1, limpieza=100%, posición final=B
5) Agente de Navegación
a) Explicación (intención vs efecto original):
• El mínimo debe calcularse por valor (distancia), no por la clave (nombre de ruta).
• Devolver todas las rutas empatadas con el mínimo para informes completos.
b/c) Corrección y refactor a una función seleccionar_rutas_optimas que regresa (distancia_min, [rutas]).
d) Pruebas: con empate, sin empate y vacío.
def seleccionar_rutas_optimas(rutas: dict):
if not rutas:
return None, []
dmin = min([Link]())
mejores = sorted([k for k, v in [Link]() if v == dmin])
return dmin, mejores
Evidencia de ejecución (pruebas):
Rutas (semilla=3): {'ruta_1': 6, 'ruta_2': 12, 'ruta_3': 11, 'ruta_4': 5}
Óptimas → distancia=5, rutas=['ruta_4']
Rutas (empate): {'r1': 5, 'r2': 7, 'r3': 5, 'r4': 9}
Óptimas → distancia=5, rutas=['r1', 'r3']
Rutas (sin empate): {'r1': 8, 'r2': 3, 'r3': 10}
Óptimas → distancia=3, rutas=['r2']
Rutas (vacías): {}
Óptimas → None, []
