CS-6601 Inteligencia Artificial: Una Breve Reseña

Últimamente no he tenido mucho tiempo para escribir. Entre el trabajo como consultor y mis estudios de maestría, el tiempo libre es escaso — algo comprensible, creo.

Aun así, realmente disfruto lo que hago, aunque pueda ser agotador. He aprendido (y sigo aprendiendo) muchísimo en cada curso, entonces desde ya tengo sentimientos encontrados sobre terminar el programa el próximo año.

Dicho esto, no se puede negar que la carga de trabajo es considerable. Por eso pensé en compartir algunos consejos para quienes estén planeando tomar CS-6601: Artificial Intelligence en Georgia Tech.

El Curso

Este es el curso de inteligencia artificial del programa. Cubre la mayoría de los temas importantes de la IA y el aprendizaje automático clásicos, con algunos temas más “modernos” como el deep learning incluidos aquí y allá.

El material sigue la estructura del libro de texto de Russell & Norvig — el clásico de la IA — y se complementa con artículos en la sección de lecturas recomendadas. (En serio, lean los artículos. Son importantes.)

He estado usando una copia antigua de la edición global que compré hace unos años, y funciona perfectamente. Algunos capítulos están en distinto orden, pero los nombres coinciden, así que es fácil ubicarse.

Para ser honesto, no he visto las clases grabadas. En cambio, me he concentrado en el libro y en los artículos, y hasta ahora me ha ido muy bien. Ya había leído el libro antes, así que esta vez ha sido más una actualización de conocimientos — lo tengo siempre a mano en el escritorio para consultarlo cuando me trabo o necesito repasar algún concepto.

Evaluación

Aproximadamente el 60% de la nota final proviene de seis tareas. Son pesadas y requieren bastante tiempo, pero también es donde más se aprende. Los temas son:

• A1: Búsqueda
• A2: Juegos y Búsqueda Adversaria
• A3: Redes Bayesianas
• A4: Árboles de Decisión y Aprendizaje por Conjunto
• A5: Modelos de Mezcla Gaussiana
• A6: Modelos Ocultos de Markov

También hay un examen parcial (15%) y un examen final (20%). Ambos son de libro abierto y nota abierta, y te dan una semana completa para resolverlos, pero no te confíes: siguen siendo difíciles. No querrás esperar hasta la semana del examen para empezar a estudiar.

El 5% restante viene de pequeños cuestionarios, bastante fáciles de aprobar.

Además, hay 10 cuestionarios extra que pueden darte hasta 3% adicional sobre la nota final. Los puntos extra no son muchos, pero sirven como excelente práctica para los exámenes, así que vale la pena hacerlos si tienes tiempo.

Dificultad

El parcial fue manejable — mucho trabajo, sí, pero totalmente realizable. Aún no he hecho el examen final, pero espero algo similar.

Las tareas, sin embargo, son difíciles y requieren mucho tiempo (entre 20 y 60 horas cada una). La dificultad tampoco está distribuida de manera uniforme. Hasta ahora (todavía me faltan las dos últimas), las clasificaría así:

• A1: La más difícil, sin duda — se siente como un ritual de iniciación al curso.
• A2: La tercera más difícil — un respiro después de A1.
• A3: La más fácil — muy guiada e intuitiva.
• A4: La segunda más difícil — la implementación fue sencilla, pero optimizar la solución tomó horas y varios intentos.
• A5: ???
• A6: ???

Consejos Prácticos

He estado intentando terminar las tareas con anticipación para poder compartir algunos consejos en el foro del curso. A varios compañeros les han resultado útiles, así que los copio aquí. (Obviamente no se pueden compartir detalles de implementación, así que la mayoría son sobre estrategia y herramientas.)

Además, las tareas cambian cada semestre, así que tal vez no sean tan útiles como me gustaría. Aun así, el consejo más importante para todas ellas es el mismo: empieza temprano y usa el libro cada vez que te atasques.

Para la Tarea 1

• Aprende a usar el depurador de PyCharm: es mucho más fácil entender qué está fallando si utilizas las funciones integradas del IDE. Coloca algunos puntos de ruptura y revisa el flujo de tu código inspeccionando las variables importantes; te ahorrará muchísimo tiempo. Si usas clases para modelar tu problema, implementa el método __repr__ en cada una: facilita la inspección. Mucho más efectivo que usar simples print().

• Haz bien los ejercicios de calentamiento: Los primeros cuatro ejercicios son relativamente sencillos, pero vale la pena dedicar tiempo a entender todos los detalles, limpiar tu código y comparar mecanismos; te servirá muchísimo para el resto.

• Sobrescribe entradas: Puedes asignar valores a cualquier entrada (goal, target, etc.) al inicio del método. Esto es útil para depurar. Descubrí que los escenarios de prueba con t y n son especialmente útiles para detectar errores. Actualización: No hace falta hacerlo, Raymond señaló que search_case_visualizer.py es una mejor herramienta para esto. PD: Resulta que los TA ya te habían dado una herramienta para hacerlo, y mejor.

• Ejecuta a mano: Cada vez que me quedaba atascado, terminaba resolviendo el problema tomando papel y lápiz, recorriendo un escenario de prueba a mano, y comparando los pasos con los de mi programa. No puedo enfatizar lo útil que es este proceso.

• El principio de Pareto: No necesitas resolver el 100% de cada ejercicio para obtener una buena nota. Asegúrate de tener todos los ejercicios de calentamiento perfectos (son la base para los más grandes), pero sé más flexible con los ejercicios mayores. Los últimos casos borde pueden consumir horas. Es mejor avanzar en los otros problemas que quedarte estancado buscando el 100% en uno solo.

Para la Tarea 2

Sigue el orden de implementación sugerido en el notebook: es tentador saltar directo a poda alfa-beta, pero es mucho más fácil añadirla sobre una implementación clara de min-max.

• La recursión puede ser más simple: Implementar ambas técnicas de forma recursiva fue fácil y limpio; recomendaría probar ese camino primero.
• La búsqueda con profundización iterativa ayuda: Lo que vimos sobre búsqueda iterativa en secciones anteriores resulta útil aquí. Con una buena función de evaluación, puedes lograr una puntuación perfecta.
• Hay algo de aleatoriedad en la evaluación de GS: Si estás cerca del umbral, vuelve a ejecutar; puede bastar para alcanzar la nota completa.
• Sé creativo con las funciones de evaluación: Puedes ajustar qué tan agresiva es tu estrategia según la etapa del juego. Pero recuerda: esta función se llama muchas veces, así que debe ser rápida.
• Ponle atención a time_left: No es necesario para las primeras partes, pero es clave para vencer a todos los bots de la parte C.
• Diseño limpio y claro: Tener un código fácil de entender te ahorrará mucho tiempo al ajustar hiperparámetros.

Para la Tarea 3

• Entiende la cardinalidad: La parte de James Bond fue sencilla, pero me trabé porque no entendí de inmediato qué significaba “cardinality”. Comprenderlo es clave para ajustar correctamente variable_card y evidence_card.
• Calcula los valores del juego con código: Para el tablero de juego, programar los cálculos de las probabilidades resulta mucho más eficiente que hacerlo a mano.
• Sobre los muestreadores: Sorprendentemente, el MH sampler fue más fácil de implementar que el Gibbs. El reto del Gibbs es mantener los índices correctos, así que dibuja la estructura de datos antes de programar.
• Haz tus propias pruebas: Crear un pequeño test para comparar los muestreadores me ayudó a validar mis resultados.
• El reto principal: Solo tienes 7 intentos, así que prueba tus ideas localmente. Ejecuta comparaciones varias veces y recoge datos antes de enviar tu solución final.

Para la Tarea 4

• Implementar es fácil, optimizar es difícil: Las instrucciones son claras, pero lograr que el código sea lo bastante rápido para pasar Gradescope requiere trabajo.
• Vectoriza todo: No podrás aprobar sin vectorizar operaciones. Reemplacé Counter por np.bincount y ahorré tiempo.
• Usa el profiler: PyCharm (y otros IDEs) incluyen uno. En PyCharm, abre el test, haz clic derecho y elige Profile. Es una herramienta indispensable para esta tarea.
• Evita divisiones por cero: Especialmente en la parte estadística.
• Optimizaciones útiles:
  1. Vectoriza al máximo y usa funciones de NumPy.
  2. Cachea resultados y actualiza solo lo necesario.
  3. Identifica las funciones que más tiempo consumen y optimízalas primero.

Para la Tarea 5

No lo sé, aún no la he hecho.

Para la Tarea 6

Tampoco lo sé, todavía no la he hecho.

¿Vale la Pena?

Estoy disfrutando muchísimo este curso — es un fuerte candidato a ser mi favorito del programa (de los ocho que llevo hasta ahora). Exige mucha atención y esfuerzo, pero no creo haber aprendido tanto en ningún otro. Los TA son muy atentos y competentes (probablemente los mejores del programa hasta ahora), así que siempre puedes pedir ayuda si te atascas.

Así que sí, ¡lo recomiendo totalmente!