DEV Community: PyramidBuilder

El secreto para no saturar el contexto de tu IA: El patrón de agentes en capas

PyramidBuilder — Tue, 10 Nov 2026 08:44:45 +0000

La imagen de portada pertenece a jonakoh_

Si como yo, has utilizado la suscripción de Opencode OpencodeGo quizás te cueste llegar a fin de mes con los tokens que se ofrecen.

Tras un año usando Opencode te puedo decir que la solución no está en los prompts, sino en la forma en que implementamos distintos patrones arquitecturales para hacer el trabajo. Podemos expresar estos patrones haciendo uso de las capacidades de definir agentes dentro de un espacio de trabajo con OpenCode. Este feature desata el verdadero potencial de la herramienta.

Hoy te enseñare el primer patrón que he descubierto haciendo utilización de los agentes mediante la creación de un tablero Kanban para demostrar su implementación.

Tipos de agentes en Opencode

En Opencode tenemos dos tipos de agentes:

Primarios: Son los agentes a los que se puede acceder desde la caja de interacción de la ventana principal de Opencode (shift+tab).build y plan son agentes primarios.
Sub-agentes: Son agentes que pueden ser invocados por los agentes primarios. El agente general y explore subagentes.

Si en nuestro proyecto creamos una carpeta llamada .opencode con una sub-carpeta llamada agents podemos definir tanto agentes primarios como secundarios en nuestro proyecto.

Layered Agent Pattern

Primero visualicemos su forma mas general antes de ir a la implementación:

En este caso vamos a hacer tenemos un esquema lineal para abrir la mente sobre la utilización de estos agentes, de a poco iremos añadiendo mas complejidad en futuras entregas.

El agente primario es el orquestador, que funciona como un bus principal donde está todo el historial de cambios del proyecto. Como es un bus principal, el objetivo es mantenerlo limpio con un contexto sumamente acotado y que pueda tener todos los mensajes de principio a fin sin necesidad de compactar ni de crear nuevas conversaciones, como se ve en la imágen:

Los subagentes tienen contextos vacíos al comienzo de cada petición, esto permite que la atención del modelo no se diluya.

Otra cosa fundamental es acotar bien las restricciones de los agentes, esto permitirá utilizar menos tokens y reducir la incertidumbre de los agentes, permitiendo que tengan menos libertad y opciones para realizar, esto permitirá que el modelo divage menos se centre en acabar la taréa

FastKanban

El proyecto a desarrollar es un proyecto de juguete diseñado para este blog, que es un Kanban que permite crear proyectos y cada proyecto tiene su propia pizarra Kanban. Puedes definir distintas columnas y también arrastrar notas de una columna a otra, es bastante simple para no saturar el blog y poder completarlo en pocos prompts.

La definición de los agentes depende del proyecto a desarrollar, no existe una formula, es parte de la ingeniería del proyecto. Para este proyecto decidí usar el siguiente Stack Tecnologico:

Next.JS: Framework web fullstack.
Sqlite: Base de datos en un archivo.

Estas decisiones fueron tomadas para facilitar el proceso de creación.

La carpeta de mi proyecto tiene los siguiente contenidos:

.
└── .opencode
    └── agents
        ├── auditor.md
        ├── backend.md
        ├── database.md
        ├── frontend.md
        ├── integrador.md
        ├── orchestrator.md
        └── qa.md

Los contenidos de cada archivo son:

auditor.md

---
description: "Audita el código buscando antipatrones y fallos de arquitectura. Solo lectura."
mode: subagent
steps: 8
permissions:
  - action: "*"
    resource: "*"
    effect: deny
  - action: read
    resource: "*"
    effect: allow
  - action: shell
    resource: "git diff*"
    effect: allow
---

Eres el auditor de calidad.

OBJETIVO
Detectar código duplicado, funciones huérfanas o antipatrones mediante `git diff`.

FORMATO DE SALIDA (máximo 12 líneas)
`ruta:línea severidad hallazgo` (ordenado por alta, media, baja). Si no hay fallos: `OK`.

Como podemos observar los permisos son limitados, primero se deniegan todas las acciones, para luego definir las acciones permitidas. En este caso el auditor puede leer archivos pero no ejecutar comandos de shell libremente.

backend.md

---
description: Implementa rutas de API y lógica de servidor en Next.js.
mode: subagent
steps: 8
permissions:
  - action: "*"
    resource: "*"
    effect: deny
  - action: read
    resource: "*"
    effect: allow
  - action: edit
    resource: "*"
    effect: allow
  - action: glob
    resource: "*"
    effect: allow
---

Eres el desarrollador backend de Next.js.

OBJETIVO
Implementar los endpoints (API Routes del App Router) requeridos por el orquestador.

REGLAS
- Cambios mínimos. Limítate a la carpeta `src/app/api/`.
- Conéctate limpiamente con Prisma. No edites componentes gráficos (frontend).

FORMATO DE SALIDA (máximo 20 líneas)
- Archivos tocados (rutas).
- Endpoints implementados.
- Bloqueos o decisiones pendientes.

Aquí debemos ser mas permisivos para que el agente pueda trabajar

database.md

---
description: Crea esquemas de base de datos y migraciones con Prisma y SQLite.
mode: subagent
steps: 8
permissions:
  - action: "*"
    resource: "*"
    effect: deny
  - action: read
    resource: "*"
    effect: allow
  - action: edit
    resource: "*"
    effect: allow
  - action: glob
    resource: "*"
    effect: allow
  - action: shell
    resource: "*"
    effect: allow
---

Eres el especialista en base de datos.

OBJETIVO
Implementar esquemas en `prisma/schema.prisma` y funciones con SQLite mediante Prisma.

REGLAS
- Cambios mínimos. No toques archivos de UI ni rutas de API.
- Motor: SQLite. ORM: Prisma.

FORMATO DE SALIDA (máximo 20 líneas)
- Archivos tocados (rutas).
- Comandos ejecutados y resultado (OK/FALLO).
- Decisiones o bloqueos.
No vuelques código completo en la respuesta.

frontend.md

---
description: Implementa componentes y páginas de la interfaz en Next.js y Tailwind CSS.
mode: subagent
steps: 8
permissions:
  - action: "*"
    resource: "*"
    effect: deny
  - action: read
    resource: "*"
    effect: allow
  - action: edit
    resource: "*"
    effect: allow
  - action: glob
    resource: "*"
    effect: allow
---

Eres el desarrollador frontend.

OBJETIVO
Implementar vistas y componentes en Next.js utilizando Tailwind CSS.

REGLAS
- Cambios mínimos. Limítate a `src/app/` (vistas y componentes visuales).
- No modifiques esquemas de base de datos ni lógica de servidor interna.

FORMATO DE SALIDA (máximo 20 líneas)
- Archivos tocados (rutas).
- Componentes creados o modificados.
- Bloqueos o decisiones pendientes.

---
description: Ejecuta pruebas, typecheck y compilación del proyecto Next.js. Solo lectura.
mode: subagent
steps: 10
permissions:
  - action: "*"
    resource: "*"
    effect: deny
  - action: read
    resource: "*"
    effect: allow
  - action: glob
    resource: "*"
    effect: allow
  - action: shell
    resource: "npm run *"
    effect: allow
  - action: shell
    resource: "npx tsc *"
    effect: allow
  - action: shell
    resource: "npx vitest *"
    effect: allow
---

Eres QA del proyecto.

OBJETIVO
Verificar la compilación, tipos y pruebas del código sin alterarlo (solo lectura).

FORMATO DE SALIDA (máximo 15 líneas)
- Comando ejecutado y resultado (OK/FALLO).
- Error exacto con `archivo:línea` si aplica.
- Siguiente acción recomendada.

Y por ultimo el orquestador, como veremos el orquestador esta bastante limitado y tiene todos los subagentes como recursos a su disposicion. Se enfoca en la comunicación y acotar la petición con preguntas:

---
description: Pregunta al usuario, define el alcance mínimo y delega en el equipo de Next.js y base de datos. No lee ni edita código.
mode: primary
steps: 12
permissions:
  - action: "*"
    resource: "*"
    effect: deny
  - action: question
    resource: "*"
    effect: allow
  - action: subagent
    resource: "backend"
    effect: allow
  - action: subagent
    resource: "frontend"
    effect: allow
  - action: subagent
    resource: "database"
    effect: allow
  - action: subagent
    resource: "qa"
    effect: allow
  - action: subagent
    resource: "auditor"
    effect: allow
---

Eres el orquestador de un equipo que construye una aplicación Next.js con Prisma y SQLite.

TU ROL
- Hablas con el usuario y delegas. No lees archivos, no escribes código y no ejecutas comandos.
- Usa la herramienta `question` para decisiones de alcance. Si la petición es clara, delega directo.

DESCOMPOSICIÓN Y FLUJO
- Si una tarea mezcla áreas distintas (DB, API, UI, tests), divídela antes de delegar.
- Cada llamada a un subagente pide un cambio mínimo y verificable en una sola área.
- Orden recomendado: Esquema DB → API/Backend → Componentes Frontend → Tests → Auditoría e Integración.

AHORRO DE TOKENS (OBLIGATORIO)
- No repitas contexto; envía a cada trabajador solo lo que necesita.
- Limita los informes de los subagentes a un máximo de 20 líneas.
- Responde en español, breve y directo.

Habiendo mostrado las instrucciones de cada agente vamos con los prompts que se hicieron para el desarrollo del proyecto.

Desarrollo

Para desarrollar yo opto por usar un archivo llamado prompts.md que es mi fuente de verdad por si algún día necesito recrear el proyecto. también de esta manera puedo trabajar mejor el formato de cada petición.

Prompt 1: Vista de proyectos


Crea la vista inicial (#1: Dashboard de Proyectos) para la aplicación FastKanban usando Next.js (App Router, TypeScript y Tailwind CSS).

Requerimientos de la vista:
1. Estado Vacío (sin proyectos):
   - Mostrar un botón principal cuadrado con bordes punteados (border-dashed) que diga "Agregar proyecto".
2. Lista de Proyectos (con datos presentes):
   - Renderizar una cuadrícula (grid) de tarjetas de proyectos.
   - Cada tarjeta debe mostrar el nombre del proyecto y un preview temporal que diga "Proyecto 1" (placeholder mientras se implementa la vista detallada del Kanban).
   - Incluir el botón "Agregar proyecto" al final de la lista.
3. Funcionalidad mínima:
   - Manejar un estado local/simulado para alternar entre el estado vacío y la lista de proyectos al hacer clic en "Agregar proyecto".

Instrucciones para los agentes:
- Limitarse estrictamente a la Vista #1.
- No implementar el tablero Kanban detallado aún.

Prompt 2: DB Proyectos

Implementa la base de datos para la vista de proyectos:
- Los proyectos tienen un nombre.
- Una fecha de creación.
- Una fecha de actualización.
- Un Blob para el preview (Por ahora un placeholder).

Prompt 3: Tablero Kanban


Crea un tablero de Kanban para los proyectos:

1. Sidebar:
    - Un botón para crear colas.
        - Cuando se presione el botón debe aparecer un dialog para escoger el color de la cola y el nombre.
            - Para el color un color picker. 
            - Para el nombre un input estilizado. 

2. El tablero de kanban con las colas:
    - Cada cola tiene que tener el nombre y su color en la parte superior.
    - Un espacio mas oscuro para delimitar la colulmna.
    - Cada cola ocupa una columna con un overflow.

3. Cuando se haga click en la cola:
    - Aparece un dialog para agregar la nota con soporte para markdown.
    - El dialog tiene un look como de postit con el color correspondiente a la cola.
    - El texto debe ser blanco o negro dependiendo del color de cada cola.
    - No debe tener un campo para el titulo de la nota explicito.
    - El titulo de la nota es el primer header de la nota y si no tiene se pone como (sin titulo).
    - Hay un hint al principio que indica que el titulo es el primer header. 

4. La nota en la cola:
    - Se representa como un titulo con su contenido parcial oculto con ...

5. Cuando arrastro una nota:
    - La puedo cambiar de cola lo que hara mutar so color.
    - Hay una animación drag and drop con framer-motion.

6. Esquema de datos:
    - La nota tiene que tener los campos:
        - Titulo.
        - Fecha de cracion.
        - Fecha de actualización.
        - Cola a la que pertenece.
        - Proyecto al cual pertenece (FK)
    - La cola debe tener los campos:
        - Titulo
        - Fecha de creación
        - Color
        - Proyecto al cual pertenece (FK)
Cualquier detalle omitido debera ser tomado en cuenta para la creación la compatibulidad

Prompt 4: Limpieza y detalles

1. La nota al arrastrarla debe quedar por encima de todos los elementos de la pagina.
2. Añadir soporte para quitar colas (un botón X arriba a la derecha de cada cola).
3. Añadir soporte para quitar notas (Un botón X arriba a la derecha de cada nota).
4. En la pantalla principal al crear un proyecto debe existir un dialogo que te permita definir el titulo del proyecto. 
5. Soporte de edición de los titulos de proyecto y las notas: Si clickeo cualquier de una cola o un proyecto debo poder editarlo. Se indica con un lapiz y un background gris al hacer hover en el elemento. 
6. Verificar que todos los elementos tengan un CRUD completo en el frontend.
7. Agregar un botón de navegación para volver a la ventana de proyectos.

Prompt 5: Ultimos detalles

Corrige los puntos.

1. Integra los snapshots y mejora los cards de proyectos.
    - Un header gris con el nombre 
    - En el cuerpo un snapshot del kanban creado
    - Si no hay un kanban reemplazar por una tarjeta en blanco 
2. Modo oscuro:
    - Para la vista de proyectos y vista del kanban.

Y estos son los prompts que utilice en este proyecto. Por la misma naturaleza del proyecto no se necesitaron mas recursos.

Adjunto algunas imágenes del resultado

Conclusión

En lo personal este patrón me ha ayudado a ahorrar tokens al momento de crear una gran variedad de proyecto, si bien este no es el único patrón de mi caja de herramientas es una base solida para ir mejorando. Es adaptable a cada necesidad y se pueden encadenar distintas rutinas de utilizacion de herramientas de auditoria como SonarQube, ReactDoctor, entre otras. Cada agente puede tener un stack de herramientas a las que puede recurrir y eso hace que esta forma de plantear la utilización de la herramienta sea bastante flexible.

Si bien este es el inicio de una serie de artículos sobre ingeniería de agentes aplicada a Opencode creo que es una base solida para ir construyendo intuición sobre una utilización mas avanzada de la herramienta

¿Que opinas de este patron de diseño?. Dímelo en la caja de comentarios.

Desestandarízate: filosofía, programación y el peligro de hacer siempre “lo correcto”

PyramidBuilder — Sun, 30 Aug 2026 06:10:14 +0000

Jean-Paul Sartre sentenció que "el hombre está condenado a ser libre". Sin embargo, la filosofía existencialista nos advierte sobre el vértigo que acompaña a tal sentencia: la angustia. El ser humano, aterrado ante la inmensidad de su propia libertad, a menudo huye de ella. Sartre llamó a esto "mala fe": la cobardía de engañarse a uno mismo, asumiendo que solo son cosas determinadas por el entorno y no sujetos libres.

Creo que no soy el único de mi círculo cercano a quien le aterra esa libertad. Nos hemos inventado todo tipo de justificaciones racionales para mantenernos restringidos a roles preconcebidos. Pero este miedo está tomando dimensiones peligrosas en nuestra era: cada vez más personas afirmando que existe una "forma correcta" de hacer las cosas, una verdad absoluta sobre cómo entender y moldear el mundo. Esto, fundamentalmente, es un error epistemológico que castra nuestra creatividad y anula nuestra agencia.

Desde gurús que venden la "forma correcta" de estructurar sistemas, hasta recetas dogmáticas como ciertas lecturas rígidas de clean code, pasando por concepciones inamovibles sobre cómo debemos trabajar. Hoy ha llegado el día de decir ¡ALTO! ¿A qué? A la ilusión de que hay algo intrínsecamente malo en atreverse a habitar la disonancia y hacer las cosas de una manera diferente.

La ilusión del control y la anestesia del "se"

Gran parte de nosotros nos aferramos a los estándares porque nos brindan algo que el existencialismo nos niega: LA ilusión de control. Creemos que, al atenernos estrictamente a una metodología, a un patrón de diseño o a un manual de "buenas prácticas", estamos construyendo un escudo contra el caos o el juicio ajeno. Si el sistema colapsa siguiendo una regla, la culpa es de la regla; pero si colapsa por una desviación, la culpa es enteramente nuestra. Los estándares, en el fondo, operan como un mecanismo de defensa psicológica contra la ansiedad de la responsabilidad. Nos convencemos de que, si seguimos el mapa al pie de la letra, el territorio no nos sorprenderá.

Conviene hacer una concesión honesta antes de seguir: en un proyecto donde veinte personas necesitan leer, mantener y extender el mismo código, ciertas convenciones compartidas no son un lujo, son una condición de posibilidad. Sin ellas, el caos no es libertad; es simplemente ruido. El problema no es la convención. EL problema es la sacralización de la convención: el momento en que una preferencia estilística o una heurística útil se convierte en verdad ontológica, en ley moral, en criterio de pertenencia a la tribu, es ahí donde la herramienta deja de servir al artesano y empieza a gobernarlo.

Aquí es donde la filosofía de Michel Foucault resulta reveladora. Foucault nos enseñó que el control en las sociedades modernas no se ejerce principalmente a través de la fuerza bruta o la prohibición, sino a través de la norma. En su análisis sobre las sociedades disciplinarias y el panóptico, demostró cómo el poder termina por internalizarse: el individuo se convierte en su propio carcelero. En nuestra industria, el panóptico no es una torre de vigilancia física; es la revisión de código, la opinión de la comunidad, el dogma del framework de moda y la tiranía del "así se hace". Hemos internalizado la mirada del otro. Nos autocensuramos, pulimos nuestras ideas hasta dejarlas perfectamente simétricas y predecibles, no porque sea lo más eficiente para el problema, sino para evitar el castigo social de ser tildados de "herejes", "inexpertos" o "disruptivos".

Martin Heidegger describió esta misma dinámica con otra palabra: Das man, el "se" impersonal. El "se dice", el "se hace así", el "se espera que". Esa fuerza anónima que nos dicta cómo debemos pensar, sentir y actuar para ser aceptados por la manada. La estandarización llevada al dogma es la anestesia del espíritu: nos conecta con nuestro instinto más primitivo de supervivencia social, pero nos desconecta de la pregunta más incómoda de toda ética: ¿A quién le estamos rindiendo cuentas? ¿Al "se" impersonal, o a nuestra propia consciencia?

Sin embargo, esta obsesión por la normalización es una trampa mortal. Al optimizar nuestros sistemas y nuestras mentes para la predictibilidad, eliminamos la fricción, pero también eliminamos la chispa. La verdadera innovación nunca nace en el centro de la norma; nace en los márgenes, en la anomalía, en el "error" que resulta ser un descubrimiento. Cuando imponemos una única epistemología sobre cómo debe construirse el software, no estamos garantizando el éxito; estamos asegurando el estancamiento. Cambiamos el asombro del descubrimiento por la comodidad de la burocracia técnica.

La ceguera ontológica de Kodak

En 1975, Steven Sasson, un ingeniero de Kodak, inventó la primera cámara digital. Tenía el tamaño de una tostadora, grababa imágenes en blanco y negro en un casete y tardaba 23 segundos en tomar una foto.

Cuando Sasson presentó el prototipo a la alta dirección, la reacción fue de rechazo inmediato. No porque la tecnología fuera inválida, sino porque atentaba contra el dogma de la compañía. Kodak sufrió de lo que en filosofía podríamos llamar ceguera ontológica: confundieron el ente con el ser del ente. Se quedaron mirando la película, el papel, los químicos (los entes concretos que llenaban sus estanterías) y olvidaron el ser que esos entes estaban revelando: la captura de luz, la preservación de la memoria, el deseo humano de detener el tiempo. Al aferrarse a su "forma correcta" de dominar el mundo, se convirtieron en prisioneros de su propio éxito. Años después, competidores sin los sesgos ni el miedo de Kodak cambiaron el paradigma para siempre. Kodak intentó reaccionar demasiado tarde y murió en 2012, aplastada por el peso de su propia ortodoxia.

Carmack y la voluntad de poder sobre el código

A principios de los 90, la teleología de la industria dictaba que las PCs no tenían potencia para renderizar 3D en tiempo real. El "estándar" exigía estaciones de trabajo de decenas de miles de dólares o limitarse al 2D.

John Carmack no consultó los manuales de arquitectura ni pidió permiso a la academia. Para crear Commander Keen, Wolfenstein 3D y Doom, desarrolló trucos matemáticos fuera de la norma, como el Binary Space Partitioning adaptado de papers militares de los 70 que la ortodoxia comercial ignoraba. En lugar de seguir estructuras de código convencionales, escribió rutinas en ensamblador y C con optimizaciones agresivas que desafiaban la teoría establecida. Carmack entendió que la pureza teórica es inútil si no dialoga con la realidad del hardware.

Nietzsche habló de la Wille zur Macht, la voluntad de poder, no como dominio sobre otros, sino como la fuerza autoafirmativa de la vida que impone una forma propia sobre la materia resistente, que se supera a sí misma en el acto de crear. Carmack ejerció exactamente eso: no se sometió a los valores dados por la industria, no esperó a que el hardware "madurara" para que el problema se volviera legítimo. Forjó su propia solución y, al hacerlo, no solo escribió código; alteró la fenomenología de lo que creíamos posible en una máquina. Si se hubiera paralizado buscando "la forma correcta", la revolución 3D se habría retrasado años.

La hipertrofia del mapa y el olvido del territorio

Vivimos en la era de la hipertrofia del mapa y el olvido del territorio. Tenemos un exceso de información y de "buenas prácticas" que actúan como un panóptico multiplicado: múltiples voces dispuestas a refutar nuestra forma de crear antes de que siquiera termine de nacer. En el diseño de sistemas no existen verdades absolutas; solo existen estados donde una solución supera a otra en un contexto dado. Y sin embargo, cada propuesta alternativa es recibida como una transgresión.

El fenómeno no es nuevo, pero se ha intensificado. La cantidad de manuales sobre cómo hacer las cosas "correctamente" a la que un desarrollador podía acceder en los años 80 o 90 era infinitamente menor a la de hoy. Y, sin embargo, los cimientos tecnológicos que sostienen el mundo (desde los primeros sistemas operativos hasta Linux o FFmpeg) nacieron en esa era de experimentación libre. La ausencia de un manual rígido no fue un impedimento; fue un catalizador. No tenían un mapa, pero tenían la valentía de explorar el territorio.

Hacia un pluralismo epistemológico: la IIT y el coraje de borrar fronteras

¿Qué esperas para desestandarizarte? No te digo que hagas las cosas mal a propósito, sino que dejes de buscar en un manual el patrón correcto y empieces a fluir hacia una forma más orgánica de crear. Al igual que la informática, existen formas de programar que aún no se han descubierto y otras fascinantes que, por estar encasilladas en dominios rígidos, ignoramos en el diseño de aplicaciones cotidianas.

El verdadero salto no ocurre dentro de las fronteras de una disciplina, sino en su intersección. Pensemos en la Teoría de la Información Integrada (IIT), propuesta por el neurocientífico Giulio Tononi para explicar matemáticamente la consciencia. Esta teoría no habría podido ser concebida si hubiéramos mantenido la teoría de la información, la cibernética de segundo orden (que estudia al observador dentro del sistema) y la fenomenología como campos aislados. Si hubiéramos aceptado el dogma de que la fenomenología "no es para ingenieros" o que la cibernética "no tiene nada que ver con la experiencia subjetiva", seguiríamos atrapados en el reduccionismo. Fue precisamente la osadía de borrar las fronteras entre lo que mide la información, lo que regula el sistema y lo que experimenta el fenómeno, lo que permitió dar el salto.

Esa misma osadía es la que necesitamos en el software. Trascender la visión newtoniana y la cartesiana (rígida, determinista y predecible) y atrevernos a pensar en sistemas que se autorregulan como organismos, en soluciones que evolucionan por mutación e iteración en lugar de seguir reglas fijas, en el coraje de integrar el azar y la probabilidad aceptando que el universo no es determinista y que a veces la mejor solución emerge del ruido. No se trata de abandonar la lógica, sino de dejar de creer que la lógica es lo único que hay.

La eudaimonía del creador

Desestandarizarse no es un acto de rebeldía vacía; es un imperativo ético. Los antiguos griegos, específicamente Aristóteles, acuñaron el término eudaimonía, que a menudo se traduce de forma reduccionista como "felicidad", pero significa con mayor precisión "florecimiento humano": la realización del máximo potencial de un ser a través de la excelencia y la virtud.

Cuando un programador se atreve a desestandarizarse, a fusionar la biología con el silicio, o el azar con la lógica, no solo está escribiendo código más interesante. Está alcanzando la eudaimonía de su oficio. Pasa de ser un obrero alienado que ensambla piezas prefabricadas según un manual a un pensador libre que da forma a la realidad. La verdadera creatividad no es elegir entre dos patrones de diseño aceptados; es la capacidad de mirar el vacío entre las disciplinas y ver un puente.

Al disolver los muros que separan a la computación de la biología, la lógica de la fenomenología, los datos de la consciencia, no solo estamos mejorando nuestra tecnología. Estamos expandiendo los límites de lo que significa ser humano en un mundo digital. Al escribir tu próxima línea de código, no estás solo resolviendo un problema técnico; estás tomando una decisión existencial sobre cómo quieres que sea el mundo.

Hay una ironía que no puedo ignorar, y que me obligó a señalar: este ensayo está construido con citas de Sartre, Foucault, Heidegger, Nietzsche y Aristóteles. Uso el lenguaje del canon para cuestionar el canon. Uso la autoridad de los muertos para defender la libertad de los vivos. No se me escapa la contradicción. Pero asumo porque Sartre mismo la asumió: no hay forma de hablar desde fuera del lenguaje que uno ha heredado. Lo que importa no es la pureza del origen, sino qué haces con lo que tienes en las manos. Yo elegí usar estas herramientas para abrir una puerta, no para cerrar una más.

¿Por qué estudié filosofía?

Permítanme una confesión personal, porque este artículo no habría existido sin ella. Hace unos años, cuando decidí que comenzaría a estudiar filosofía, mis congéneres (colegas desarrolladores, amigos de la universidad) se rieron de mí. Con esa mezcla de burla y condescendencia que solo tienen los que creen poseer la verdad, me dijeron que ahora sí estaba "perdiendo lo que me quedaba de vida". Que la filosofía era inútil, que no me daría trabajo, que no era "aplicable". Que estaba traicionando el pragmatismo sagrado de nuestra profesión.

Y tenían razón en algo: la filosofía no me dio trabajo. No me enseñó un framework nuevo. No me hizo más rápido escribiendo código.

Pero lo que sí hizo fue algo infinitamente más valioso: me dio las herramientas para pensar sobre el código, sobre la industria, sobre mí mismo.

Si no hubiera cruzado mis habilidades autodidactas previas con la filosofía, nunca habría podido escribir este artículo. Nunca habría podido articular de esta forma los pensamientos que quería expresar. La filosofía no reemplazó lo que ya sabía; lo potenció, lo profundizó, lo transformó. Me permitió ver que la angustia que sentía ante los estándares no era un defecto mío, sino un síntoma de algo mucho más grande: la tiranía de la norma, la internalización del panóptico, la ceguera ontológica.
Hubo momentos en que pensé que tenían razón. Momentos en que dudé. Momentos en que casi dejo la filosofía. Pero algo me mantuvo leyendo, pensando, cuestionando. Y ese algo, creo, era la misma angustia que describo en este ensayo: la sensación de que había algo más, algo más profundo, algo que los manuales no me estaban dando.

Y aquí está la ironía más profunda: aquellos que se rieron de mí no lo hicieron por maldad. Lo hicieron porque estaban atrapados en la misma ansiedad que yo describo en este ensayo. Estaban tan asustados de la libertad que necesitaban convencerse de que yo estaba equivocado. Ellos no perdieron la vida; la están pasando siguiendo un mapa que alguien más dibujó. Y eso, en el fondo, es trágico.

La filosofía, en el fondo, es el acto más subversivo que puede cometer un programador. Es la decisión de preguntar por qué antes de preguntar cómo. Es la negativa a aceptar que la única forma de ser útil es ser inmediatamente aplicable. Es entender que lo que parece "inútil" hoy puede ser lo que te dé las herramientas para ver el mundo de una forma completamente nueva mañana.

Y eso, mis congéneres, no es perder la vida.

Es empezar a vivirla.

Cómo escribir una herramienta para generar gráficos con lenguaje natural usando ChatGPT.

PyramidBuilder — Wed, 22 Mar 2023 03:19:29 +0000

Con el rápido desarrollo de los grandes modelos del lenguaje, han surgido varias oportunidades de automatización a través del uso del lenguaje natural. En este artículo vamos a ir paso a paso por la creación guiada de un sistema de IA para generar gráficos a partir de un conjunto de datos de forma automatizada. Es una herramienta teórica, y está desarrollada para mostrar lo fácil que es usar la API de ChatGPT para crear nuestros propios proyectos.

Zero Shot o Few Shots, el concepto clave

¿Te imaginas usar un modelo de inteligencia artificial para resolver tareas para las que no fue entrenado específicamente? Con el auge de los modelos del lenguaje se han generado modelos preentrenados que nos permiten aprovechar una técnica llamada Zero Shot Learning y es fácilmente aplicable usando modelos como ChatGPT.

ChatGPT es una herramienta de procesamiento del lenguaje. Su principal aplicación es la de conversar con los usuarios, por eso generalmente se le clasifica dentro de los modelos conversacionales.

Si bien fue creada para mantener conversaciones con los usuarios, ChatGPT al estar basada en modelos de procesamiento del lenguaje natural, puede ayudarnos a desarrollar muchas tareas de procesamiento del lenguaje usando una técnica llamada “Zero Shot”.

Los modelos donde se pueden aplicar estas técnicas son los modelos preentrenados. Estos representan una gran oportunidad para poder acelerar nuestro trabajo respecto al Deep Learning, debido a que han sido previamente entrenados en grandes volúmenes de datos. Usar modelos preentrenados para resolver tareas rutinarias en nuestras aplicaciones de inteligencia artificial nos puede ahorrar mucho tiempo y recursos.

¿Pero qué es Zero Shot? El concepto de “Zero Shot Learning” no es nuevo, lleva varios años dando vueltas por el campo de la inteligencia artificial. El Zero Shot Learning es un paradigma para trabajar con modelos preentrenados. Este paradigma nos indica que los modelos preentrenados pueden desarrollar tareas para las que no fueron entrenados explícitamente.

Las técnicas de Zero Shot representan una oportunidad para el desarrollo de múltiples aplicaciones, esto debido a que permiten usar y adaptar modelos para tareas distintas a las que fueron entrenados.

No tenemos que confundir las técnicas de Zero Shot con las técnicas de Transfer Learning. En el Transfer Learning se reentrena un modelo para aplicarlo a un problema distinto al original. Para el Zero Shot no se necesita entrenamiento adicional, simplemente saber cómo expresar la tarea a resolver.

Un ejemplo Zero Shot Q&A:

Q: Roger tenía 16 pelotas de distintos tipos. La mitad eran pelotas de golf y la mitad de las pelotas de golf eran azules. ¿Cuántas pelotas azules tenía Roger?
A:

Respuesta:
Roger tenía 4 pelotas azules.

Si la mitad de las 16 pelotas eran de golf, eso significa que tenía 8 pelotas de golf. Y si la mitad de las pelotas de golf eran azules, entonces tenía 4 pelotas de golf azules. Por lo tanto, Roger tenía 4 pelotas azules en total.

Si bien esta técnica es efectiva para desarrollar aplicaciones, podemos mejorarla cuando le damos ejemplos y seguimos un patrón más parecido al aprendizaje por una muestra (one-shot learning).

Dentro de este prompt podemos reconocer 4 secciones importantes:

El prompt principal, el que provee instrucciones y una descripción general de la tarea
Las categorías a clasificar
El texto a clasificar
Las instrucciones adicionales.

Pero vamos a volver al tema más adelante, por ahora solo mantén en mente que este patrón de pregunta es más efectivo para las respuestas que un patrón basado en Zero Shot Learning o One Shot para usarlo en tareas relativas al Natural Language Understanding.

A pesar de las ventajas que ofrecen el Zero Shot Learning y el One Shot Learning, como la posibilidad de aplicar modelos preentrenados a una gran variedad de tareas que involucran el procesamiento del lenguaje natural y la reducción del costo computacional y temporal, también hay que reconocer los desafíos y limitaciones asociados a estas dos técnicas, como la falta de consistencia y la dificultad para evaluar los resultados generados por los modelos.

Pensando en ChatGPT como un compresor de datos

Los compresores de datos son programas que tienen por finalidad reducir el tamaño de los datos. Los modelos de lenguaje son modelos capaces de predecir la siguiente palabra de una secuencia de palabras, pero ¿cómo podemos relacionar estos dos conceptos?

Si tomamos en cuenta el volumen de los datos con los que está entrenado ChatGPT, podemos cuantificarlo de muchas formas, pero no se puede negar que ChatGPT es una representación compacta de esa cantidad masiva de datos.

Una manera de considerar al prompt, es como una herramienta para filtrar información que el modelo tiene en sus datos de entrenamiento, y al modelo como una estructura que codifica toda la información que queremos obtener.

Por ejemplo, supongamos que queremos usar a ChatGPT para generar una pregunta para un examen de sociologia podriamos usar el siguiente prompt:

Pregunta teorica para un examen de sociologia.

Si consideramos el concepto Materialismo historico propuesto por Karl Marx, podriamos afirmar que:

a. ___________ (Alternativa a maximo 200 caracteres)
b. ___________ (Alternativa b maximo 200 caracteres)
c. ___________ (Alternativa c maximo 200 caracteres)
d. ___________ (Alternativa d maximo 200 caracteres)

Repuesta correcta:
_ (Alternativa para la respuesta correcta)

¿Puedes completar la plantilla?

Respuesta:
Si consideramos el concepto Materialismo histórico propuesto por Karl Marx, ¿podríamos afirmar que:

a. La economía es el motor de la historia, y los conflictos entre clases sociales son la principal fuerza impulsora del cambio social.

b. El desarrollo tecnológico y científico es el principal factor que determina el curso de la historia.

c. La religión es la fuente de todos los conflictos sociales y políticos.

d. El individualismo es la principal causa de la desigualdad social.

La respuesta correcta es:
a. La economía es el motor de la historia, y los conflictos entre clases sociales son la principal fuerza impulsora del cambio social.

En este ejemplo podemos observar que al utilizar un prompt específico, estamos filtrando la información que el modelo ChatGPT posee respecto al concepto de materialismo histórico. Estamos guiando de cierta manera al modelo a generar una pregunta relacionada con esta teoría sociológica en particular. De esta manera, el prompt tiene la función de controlar el tipo de información que el modelo utiliza para generar la respuesta deseada. Con esto podemos observar cómo se puede percibir al prompt como una herramienta para filtrar la información de un modelo de procesamiento del lenguaje, en este caso ChatGPT.

Si lo pensamos de esta manera, el prompt es la forma de buscar información dentro de ChatGPT, en cierta manera una forma de filtrar ese volumen masivo de datos comprimidos dentro de sus parámetros. Por lo tanto, para filtrar exactamente la información que queremos tenemos que seguir algunos pasos que he podido notar en mi proceso de experimentación directo con ChatGPT:

Ser específico: Siempre tenemos que intentar ser lo más específico posible y eliminar cualquier posible concepto ambiguo en nuestro prompt.
Proveer ejemplos: Proveer ejemplos sobre cómo contestar es clave para poder obtener buenas respuestas por parte del modelo.
Proveer un formato claro de respuesta: Proveer plantillas y un formato claro de cómo responder puede ser bastante ventajoso al momento de ocupar ChatGPT para desarrollar aplicaciones, debido a que si podemos hacer que el modelo facilite el proceso, de postprocesado de datos, ahorraremos mucho tiempo de escritura de código.

La pregunta más grande que se puede generar en este momento es: ¿Por qué estos consejos funcionan?.

Los modelos de lenguaje son aprendices de pocas muestras

En 2020, OpenAI publicó un artículo llamado "Language Models Are Few Shot Learning" que puede ayudarnos a comprender cómo mejorar los prompts de ChatGPT. En él, se explican algunas pistas sobre cómo entrenaron a GPT-3 utilizando una técnica llamada "Few Shot Learning".

Esta técnica se basa en el aprendizaje automático que permite realizar una tarea específica a partir de pocos ejemplos de entrenamiento y generalizarlos a nuevas aplicaciones. Se inspira en la forma en que los humanos aprendemos, donde no solo adquirimos conocimientos teóricos, sino que también aprendemos a partir de ejemplos concretos.

Por ejemplo, si vemos un animal con cuatro patas, pelo y cola, podemos deducir que es un mamífero, mientras que si vemos un animal con aletas, escamas y agallas, podemos decir que es un animal marino. Esto demuestra que el conocimiento no se basa únicamente en teorías, sino que también se relaciona con ejemplos concretos que nos ayudan a realizar las tareas que se nos piden.

Sabiendo los detalles del proceso de entrenamiento de GPT-3, podemos mejorar nuestras capacidades de prompting. Por ejemplo, en lugar de pedirle a ChatGPT que "Describa un león", es recomendable proporcionar varios ejemplos para aclarar el concepto de "descripción", proporcionando ejemplos de descripciones de otros animales, por ejemplo:

Ejemplos de descripción de animales:
- El tigre es un animal con 4 patas, pelo y cola. Los tigres se encuentran en hábitats increíblemente diversos, por ejemplo "selvas tropicales" (...)

- El búho es un ave con 2 patas, 2 alas, y plumas. Los búhos habitan típicamente en los bosques (...)

Ahora, describe un león.

Estos ejemplos ayudarán a ChatGPT a entender el tipo de descripción precisa que estás buscando y pueden lograr que ChatGPT te proporcione detalles específicos, use una plantilla, etc.

Pero hay que tener en cuenta que las peticiones deben contener información relevante sobre cómo resolver la tarea que estamos pidiendo. Es importante dividir tu petición en partes pequeñas que aporten los detalles necesarios para responder a la petición de manera adecuada.

Con estos conceptos en mente, podemos mejorar los prompts que hacemos a ChatGPT para lograr respuestas más efectivas y útiles en diversas aplicaciones.

Para pedir a ChatGPT que resuelva una tarea específica, es importante proporcionarle varios ejemplos sobre cómo resolverla y cómo responder a la petición. Esto se debe a que los modelos de lenguaje, como ChatGPT, están diseñados para aprender a partir de pocos ejemplos utilizando la técnica de Few Shot Learning, que se basa en la idea de que los humanos también aprendemos a partir de ejemplos.

Además, es importante entender el concepto de "tokens". Los tokens son las unidades mínimas utilizadas para procesar texto. Cuando se procesa texto para ChatGPT, se divide en tokens para poder procesarlo de manera efectiva. La cantidad de tokens en una entrada determina la calidad de la respuesta generada por el modelo. Sin embargo, no es solo la cantidad de tokens lo que importa. También es importante que los tokens sean relevantes y proporcionen información adicional sobre la respuesta específica que se busca.

Si deseas conocer la cantidad de tokens que tiene tu petición y aprender más sobre cómo se preprocesa el texto de entrada para GPT-3, puedes usar el siguiente enlace, que utiliza una implementación de GPT-3-Encoder: https://platform.openai.com/tokenizer.

El verdadero potencial oculto en LangChain 🦜

LangChain es una herramienta que facilita la creación de aplicaciones basadas en modelos del lenguaje. Algunos ejemplos de los modelos que se pueden utilizar mediante la librería LangChain son GPT-3, BERT o ChatGPT.

Los modelos del lenguaje se pueden emplear para realizar diferentes tareas, como se ha demostrado anteriormente, aprovechando la capacidad de generalización de un modelo para realizar diversas tareas. Para explotar el potencial de los diferentes modelos del lenguaje es necesario crear una infraestructura de código que les permita interactuar con otras herramientas y fuentes de datos o con el usuario final.

Aquí es donde entra LangChain. Con esta librería se pueden crear diferentes cadenas de ejecución, gestionar los prompts, diseñar agentes, gestionar y almacenar los datos generados por los diferentes modelos, etc.

Conocí Langchain leyendo el código de Visual ChatGPT publicado por Microsoft. El paper presentaba un nuevo paradigma para el desarrollo de agentes conversacionales capaces de enviar y recibir imágenes a través del chat. Esto me pareció muy innovador y así fue como se me ocurrió el siguiente proyecto.

En concreto Visual ChatGPT usaba Langchain para comunicar a GPT-3 con una serie de modelos fundamentales visuales especializados en distintos dominios. Por ejemplo:

Modelos para editar imágenes
Modelos para generar imágenes
Modelos pix2pix
etc.

Todos estos modelos conformaban un toolkit y se usaba ChatGPT como un intermediario entre el usuario y estas herramientas; es decir, ChatGPT sabía operar con este toolkit. Lo que más me llamó la atención es que no era necesario reentrenar al modelo para poder aplicar el paradigma y ahí es donde vi la innovación. De pronto se me ocurrió implementar este mismo patrón para varios proyectos, incluido el que voy a mostrar a continuación.

No voy a profundizar en cada una de las capacidades de LangChain, pero si estás interesado en saber más sobre la librería, puedes visitar su documentación: https://langchain.readthedocs.io/en/latest/index.html.

Para este proyecto solo usaré el Prompt Template y el LLMChain, ya que son bastante fáciles de implementar y entender incluso si no tienes conocimientos previos sobre LangChain, pero los explicaré brevemente antes de pasar al código:

El prompt template es una forma estandarizada para definir la entrada y la salida esperada de un modelo del lenguaje, como hemos visto anteriormente, tenemos que pensar en el prompt como una herramienta para filtrar datos; por lo tanto, el PromptTemplate nos permite adaptar el modelo a una tarea específica o personalizar su comportamiento.
El LLMChain permite definir una llamada al modelo del lenguaje con los parámetros que queramos usar, se usa para comunicarse con la API de un modelo y recibir una respuesta en formato string.

PlotGPT: Una aplicación creada con ChatGPT.

PlotGPT es una herramienta que facilita la generación de visualizaciones simples de los datos usando a ChatGPT como una interfaz. Se basa en ChatGPT del lenguaje especializado en conversaciones, el rol que cumple es interpretar las peticiones del usuario y producir el código en Python y los gráficos correspondientes.

La entrada de PlotGPT es una petición en lenguaje natural que especifica el tipo y los datos a utilizar en el gráfico a generar, por ejemplo: "Show me a bar plot with the month revenues". El código generado se puede modificar para personalizar le gráfico posteriormente.

Esta implementación no es más que una prueba de concepto que ilustra las posibilidades de ChatGPT cuando se combina con LangChain. No se trata de una solución optima ni definitiva, sino una forma de explorar las capacidades del modelo y sus limitaciones. Este proyecto ésta hecho con propositos de investigación y no se trata de un producto real.

El primer paso es obtener nuestro api key de OpenAI y configurarla como variable del sistema.

Para obtener un API key de openAI, puedes dirigirte al siguiente enlace, registrarte, y solicitarla.

Despues vamos a instalar las siguientes librerias:

pip install langchain
pip install openai
pip install pandas
pip install matplotlib

Una vez hecho esto, podemos empezar. Lo primero que tenemos que hacer para desarrollar la aplicación es crear nuestro sistema de archivos para organizar el código. Mi estructura es la siguiente:

carpeta_principal
|
+-- src
    |
    |_src.py
|_ main.py

El archivo src.py puede tener el nombre que prefieras. Yo le decidí llamar templates.py, debido a que ahí tengo todos los templates de los prompts para ChatGPT.

Lo primero que vamos a revisar es cómo hacer los prompts para que ChatGPT haga lo que esperamos. La forma en que yo lo hice fue subdividir las tareas en 3 partes: la primera recibe el prompt del usuario y genera código; la segunda extrae el código de Python; y la tercera detecta las dependencias del código generado, esto es con el propósito de saber si hay que instalar librerías adicionales.

Para el primer ejemplo hice una estructura con 3 ejemplos, los cuales son los siguientes:

[    {        
        "question": "Can you select the 'name' and 'age' columns from the database",       
        "answer": "pandas_dataframe.loc[:, ['name', 'age']]"
        },    
        {        
        "question": "Can you calculate the average of the 'age' column from the database",        
        "answer": "pandas_dataframe['age'].mean()"    
        },    
        {        
        "question": "Can you plot the 'age' and 'income' columns from the database",        
        "answer": "pandas_dataframe.plot(x='age', y='income')"    
        }
]

Lo que pretendo hacer con estos ejemplos es proveer suficiente información al modelo sobre cómo resolver la tarea:

El lenguaje de programación, en este caso Python.
El uso de pandas para filtrar los datos.
El formato de respuesta.

El prompt completo que incluye todos los ejemplos es el siguiente:

    database_query_prompt = PromptTemplate(
        input_variables=['columns', 'query'],
        template=f"Following the reasoning: \nFor example: {examples[0]['question']}\n{examples[0]['answer']}\n{examples[1]['question']}\n{examples[1]['answer']}\n{examples[2]['question']}\n{examples[2]['answer']}\nWithin the following database we have the following columns"+"{columns}. How can I {query} from the variable pandas_dataframe?. Give only one answer and don't include any library imports. Actual code: \```

py import pandas as pd\nimport matplotlib.pyplot as plt\npandas_dataframe('db_csv')\

``` continue the code
        """,
    )

PromptTemplate Es un objeto que se comunica con LangChain para poder llevar a cabo la cadena de ejecución.

El resto del prompt especifica a ChatGPT que siga los ejemplos anteriores, y también se les provee el nombre de las columnas del dataframe utilizado, y también se le provee el input del usuario, esto específicamente en este punto:

{columns}. How can I {query}

Los inputs variables son los identificadores de las variables dentro del template. Esto permite que LangChain pueda sustituir los identificadores por los valores correspondientes a la cadena, pero esto lo explicaremos más adelante.

A continuación, defino otros parámetros como la variable pandas_dataframe, y también especifico el formato de las respuestas y le indico a ChatGPT que utilice las librerías matplotlib y pandas. Después le pido que genere el código.

El siguiente prompt que creé fue para filtrar la salida del primer prompt. La finalidad del segundo prompt es extraer únicamente el código del primero. Esto se debe a que la salida de ChatGPT no era muy precisa, pese a todas las indicaciones previas. Por eso, elaboré un segundo prompt con ejemplos que es el siguiente:

code_extraction_prompt = PromptTemplate(
        input_variables=['generated_text'],
        template= """
        This are 3 examples of how extract code from text:
           Begin Example 1
              User Input:
                The answer for the question can you make a program that prints hello world is:
                \```


                print("hello world")
                \

            However, the code is very basic because it only prints hello world.
          Your Output:
            \```

                print("hello world")
            \

            End Example 1
            Begin Example 2
                User Input:
                    The answer for the "fibonacci sequence of 10" is:
                    def fibonacci(n):
                        if n <= 1:
                            return n
                        else:
                            return(fibonacci(n-1) + fibonacci(n-2))
                    print(fibonacci(10))
                    Note that the variable n is the number of the fibonacci sequence. is the number of the fibonacci sequence.
                Your Output:
                    \```


                    def fibonacci(n):
                        if n <= 1:
                            return n
                        else:
                            return(fibonacci(n-1) + fibonacci(n-2))
                    print(fibonacci(10))
                    \

        End Example 2
        Begin Example 3
            User Input:
                The code for select the columns 'name' and 'age' from the database is:
                    pandas_dataframe.loc[:, ['name', 'age']]
                However it seems the columns names that you provide are not corect.
            Your Output:
                \```

                pandas_dataframe.loc[:, ['name', 'age']]
                \

            End Example 3

            Now that you have seen 3 examples of how to extract code from text, please extract the code from the following text:
            Important:  Only give your answer, dont give any additional text, only the answer.

            User Input:
                {generated_text}
            Your Output: 
         """

En este caso, integré los ejemplos al prompt completamente. Además, definí claramente dónde empieza y termina cada ejemplo. Por lo general, este segundo método funciona mucho mejor que el primero.

Los 3 ejemplos muestran cómo extraer el código del prompt previo. Este prompt no depende del nombre de las columnas ni de las variables ni nada parecido. Su única función es separar el código del texto generado por ChatGPT. Después de los 3 ejemplos proporcionados se indica la tarea a realizar y se sigue el mismo formato que en los ejemplos.

Decidí hacerlo así porque las IAs como ChatGPT están diseñadas para predecir la siguiente palabra de una secuencia. Así que si les das ejemplos de cómo completar la secuencia y al final les das una plantilla igual a la de los ejemplos es más probable que el modelo siga la secuencia de los ejemplos dados al inicio del prompt.

Y para acabar le damos un prompt para obtener más información del código generado por ChatGPT con el siguiente y último prompt:

code_analysis_prompt = PromptTemplate(
        input_variables=['generated_code'],
        template="""
        There is a lot of information that can be extracted from code. I will give you 3 examples of how to extract information from code.
        Begin Example 1
            User Input:
                pandas_dataframe['Sex'].value_counts().plot(kind='bar')
                plt.xticks([0, 1], ['Man', 'Woman'])
                plt.show()
            Your Thought Process Will be:
                Dependencies: Pandas, Matplotlib
                Requires Plotting: True
                Requires Result Printing: False
            Your Output:
                ["Pandas, Matplotlib", True, False]
        End Example 1

        Begin Example 2
            User Input:
                def fibonacci(n):
                    if n <= 1:
                        return n
                    else:
                        return(fibonacci(n-1) + fibonacci(n-2))
                print(fibonacci(10))
            Your Thought Process Will be:
                Dependencies: None
                Requires Plotting: False
                Requires Result Printing: True
            Your Output:
                ["None", False, True]
        End Example 2

        Begin Example 3
            User Input:
                pandas_dataframe['age'].mean()
            Your Thought Process Will be:
                Dependencies: Pandas
                Requires Plotting: False
                Requires Evaluation: True
            Your Output:
                ["Pandas", False, True]
        Can you give me Your Output for the following code supressing your thought process, is important that you only give me the output, not the input or any other text, and dont repeat "Your Output:" Only give me the dependecies, requires ploting, and requires result printing nothing more.
            {generated_code}
        Your Output:
        """
    )

Aquí adopto un tercer patrón para optimizar los prompts. Como este proyecto es solo una muestra, los 3 prompts tienen patrones distintos. En este caso quiero que identifique las dependencias, si necesita generar un gráfico o si solo necesita evaluar el código y mostrar un resultado. Estas 3 categorías son fundamentales para saber cómo ejecutar el código, crear la plantilla o guardar una imagen del gráfico si hace falta.

Cuando llegué a este último prompt pensé en formas más elaboradas de comunicarme con ChatGPT, pero vi que lo más sencillo era darle ejemplos de cómo obtener los valores finales y que me devolviera directamente una lista de Python fácil de "parsear" con Python. Entonces le digo "Your Thought Process Will be"... Así ChatGPT sabe cómo conseguir los valores que va a poner en la lista.

Ya enseñé los prompts, pero creo que antes de continuar con mi implementación hay que detenerse y preguntarse: ¿Por qué esto funciona realmente?

Stop para profundizar

¿Recuerdas que al inicio hablamos sobre dejar la explicación del Few Shot Learning para el final?

Sin embargo, los casos en que usamos los paradigmas One Shot y Zero Shot no entregaban buenos resultados. El nivel de especificidad de los resultados no era suficiente para desarrollar una aplicación. Esto se debe principalmente a que en el paradigma Zero Shot el modelo intenta adivinar lo que nosotros le estamos pidiendo y responder de una manera que satisface las condiciones que les entregamos.

Por eso elegí el estilo Few Shot. El modelo tiene bastante más información sobre cómo realizar la tarea e incluso puede sortear las ambigüedades que irán apareciendo en la respuesta. En este caso el modelo no está encontrando la mejor forma de responder a una pregunta sino que está replicando el formato que le proveímos y adaptándolo a una respuesta generada por él mismo.

Según mis observaciones para el desarrollo de tareas relacionadas con el NLU (Natural Language Understanding) siempre necesitaremos proveer ejemplos a los modelos de procesamiento del lenguaje actual.

También es recomendable para evitar ambigüedades como en el último ejemplo darle ejemplos sobre cómo se llega a la respuesta final. Esto una vez más puede ayudar a quitar las ambigüedades que puedan presentarse en la respuesta del modelo. Una vez dicho esto vamos a continuar con la implementación.

Explicando el resto de la implementación en Python

A continuación definimos las cadenas. Las cadenas son secuencias de pasos que permiten transferir la información desde nuestro programa a los modelos de lenguaje. Para ello debemos añadir el siguiente código en Python:

    chain_code_generation = LLMChain(llm=llm, prompt=database_query_prompt)
    chain_code_extraction = LLMChain(llm=llm, prompt=code_extraction_prompt)
    chain_code_analysis = LLMChain(llm=llm, prompt=code_analysis_prompt)

A continuación definí los parámetros de entrada del primer modelo en un diccionario y ejecuté la cadena completa. Luego realicé una limpieza básica a los resultados:

    params ={
        "columns": pandas_dataframe.columns,
        "query": query
    }
    output = chain_code_generation.run(**params)

    code = chain_code_extraction.run(generated_text=output)

    # Actual code is between the "\`\`\`py" and "\`\`\`"
    code = code.replace("\\`\`\`py", "").replace("\`\`\`", "")
    analysis = chain_code_analysis.run(generated_code=code)

    return code, analysis

Luego cree un par de funciones auxiliares para generar el archivo final y ejecutarlo:

def code_inyection(generated_code_path, db_path, model_code, model_analysis):
    print("Inyection")
    generated_code = []
    # Agregamos pandas
    if "Pandas" in model_analysis:
        generated_code.append("import pandas as pd")
    # Agregamos matplotlib
    if "Matplotlib" in model_analysis:
        generated_code.append("import matplotlib.pyplot as plt")

    # Agregamos los preparativos teniendo en cuenta el nombre del dataframe es los ejemplo 
    # Proveidos en los prompts
    generated_code += f"pandas_dataframe = pd.read_csv('{db_path}')", model_code.replace("plt.show()", "").

    # Corregimos cualquier problema de indentaión
    replace("\t", "").replace(" ", "")

    # Model Analysis input: ["Pandas, Matplotlib", True, False]
    # Parseamos el analisis de dependencias
    model_analysis = model_analysis.replace("[", "").replace("]", "").replace("'", "").split(", ")
    # Guardamos el codigo y la imagen
    plot_image_path = None
    if model_analysis[2] == "True":
        plot_image_path = "plot.png"
        generated_code.append(f"plt.savefig('{plot_image_path}')")
    generated_code = "\n".join(generated_code)
    with open(generated_code_path, "w+") as f:
        f.write(generated_code)

    return generated_code_path, plot_image_path, generated_code

# Usamos os.system para ejecutar el codigo generado
def execute_code(file_path):
    print("Excecuting")
    os.system(f"python {file_path}")

Para finalizar la implementación, cree una API Simple en Flask:

from src.templates import fake_db_lookup, code_inyection, execute_code
from flask import Flask, request, jsonify
from langchain.llms import OpenAI
import os
from pathlib import Path
app = Flask(__name__)

@app.route("/")
def index():
    # Función de prueba
    return jsonify({"hello": "World"})

llm = OpenAI(openai_api_key=os.environ["OPENAI"], temperature=.1)

# Parse the text query and return the code and analysis
@app.route("/generate_code", methods=["GET"])
def generate_code():
    # Recibimos los parametros y extraemos el Query
    query: str = request.args.get("query")

    # Si falta el Query enviamos un error
    if query is None:
        return jsonify({"error": "No query provided"})

    # Generamos el codigo 
    code, analysis = db_lookup(query=query, llm=llm)
    file_path, plot_image_path, generated_code = code_inyection("/home/yo/code.py", "db.csv", code, analysis)
    execute_code(file_path)
    p = Path(plot_image_path).absolute() if plot_image_path else "Not Provided"

    # Generamos una respuesta en JSON
    response = {
        "code": generated_code,
        "plot": str(p)
    }


    # Retornamos la respuesta en formato JSON hacia el frontend
    return jsonify(response)

if __name__ == "__main__":
    app.run(debug=True)

Y con eso tenemos cubierta la porción mas significativa del backend de mi implementación.

No entraré en detalles con el frontend, lo unico que puedo decir es que use electron ya que la aplicación la pense para el uso local, pero igualmente el codigo del frontend y el backend estan disponibles en el siguiente enlace:

https://github.com/harpiechoise/PlotGPT

Resultados

El dataset utilizado para hacer estas pruebas, es el dataset Titanic, se puede encontrar fácilmente en Kaggle.

Prompt Original
Can you select 'Sex' column and make a plot with a pie chart and replace the axis labels with 'men' and 'woman' respectively

Resultado:

Prompt Original
Can you select 'Sex' column and make a plot them with a bar chart then rotate the X axis labels 45° and make green and red bars respectly.

Resultado:

Prompt Original:
Can you make an histogram for 'Age' variable with 10 bins with the title "Age distribution on titanic dataset", with red colored bins?

Resultado:

Conclusión

En este artículo hemos visto cómo ChatGPT representa una gran oportunidad para agilizar el desarrollo de aplicaciones que antes eran impensables gracias a su gran capacidad de generar textos coherentes y creativos a partir de una entrada entregada por el usuario. Hemos facilitado un punto de entrada para combinar expandir las capacidades de ChatGPT, este mismo patrón se puede aplicar con el fin de generar audio, imágenes, textos, etc. Sin duda siento que en el futuro saldrán otros avances para expandir las fronteras de lo que podríamos lograr gracias a la inteligencia artificial.

Sin embargo, también hemos conocido que existen algunos riesgos y desafíos asociados a estos patrones de diseño, la ética y la seguridad de los contenidos es nuestra responsabilidad. Por ello, es que gracias a los patrones presentados tenemos la oportunidad de agregar una capa de seguridad a las respuestas del modelo, solo con el uso de prompts.

En mi opinión, tecnologías como ChatGPT y los modelos similares aportan un avance muy valioso y si sabemos ver la oportunidad, podemos usarlo para facilitar nuestro trabajo y enriquecer nuestra experiencia de usuario. No obstante, tenemos que ser conscientes de sus limitaciones y potenciales peligros.

Espero que este artículo te haya parecido interesante e informativo. Si tienes cualquier duda o comentario sobre el tema, puedes dejarlo en cualquiera de las publicaciones donde haya compartido el link a este artículo. Gracias por leer hasta el final y nos vemos en el próximo artículo.

Bibliografia

Brown, T. B., Mann, B., Ryder, N., Subbiah, M., Kaplan, J., Dhariwal, P., Neelakantan, A., Shyam, P., Sastry, G., Askell, A., Agarwal, S., Herbert-Voss, A., Krueger, G., Henighan, T., Child, R., Ramesh, A., Ziegler, D. M., Wu, J., Winter, C., … Amodei, D. (2020). Language Models are Few-Shot Learners (arXiv:2005.14165). arXiv. https://doi.org/10.48550/arXiv.2005.14165
Fedewa, J. (s. f.). What Is ChatGPT, and Why Is It Important? Recuperado 20 de marzo de 2023, de https://www.howtogeek.com/871071/what-is-chatgpt/
Murzone, F. (2020, octubre 5). Procesamiento de texto para NLP 1: Tokenización. EscuelaDeInteligenciaArtificial. https://medium.com/escueladeinteligenciaartificial/procesamiento-de-texto-para-nlp-1-tokenizaci%C3%B3n-4d533f3f6c9b
Raja, A. (s. f.). (12) Zero-Shot, One-Shot, Few-Shot Learnings: How the different types of N-Short learning disciplines help Data scientists?! | LinkedIn. Recuperado 20 de marzo de 2023, de https://www.linkedin.com/pulse/zero-shot-one-shot-few-shot-learnings-how-different-types-raja-csm/
S, A. (S. F.). Welcome to LangChain—🦜🔗 LangChain 0.0.118. https://langchain.readthedocs.io/en/latest/index.html
Shanahan, M. (2023). Talking About Large Language Models (arXiv:2212.03551). arXiv. http://arxiv.org/abs/2212.03551
Soto, J. A. (2019, diciembre 11). Winrar vs 7-Zip vs Winzip - ¿Cual es el mejor descompresor para Windows? - Guía. GEEKNETIC. https://www.geeknetic.es/Noticia/17666/Winrar-vs-7-Zip-vs-Winzip-Cual-es-el-mejor-descompresor-para-Windows.html
Torres, M. E. (2020, abril 22). Modelos de lenguaje en el NLP. Medium. https://monica-echeverrt.medium.com/modelos-de-lenguaje-en-el-nlp-8922dc34753b
Wu, C., Yin, S., Qi, W., Wang, X., Tang, Z., & Duan, N. (2023). Visual ChatGPT: Talking, Drawing and Editing with Visual Foundation Models (arXiv:2303.04671). arXiv. https://doi.org/10.48550/arXiv.2303.04671

Introducción a la computación cuantica (Parte 1)

PyramidBuilder — Sat, 18 Feb 2023 00:09:41 +0000

La imagen de portada fue hecha por Manuel y rescatada de Unplash

Esta es una serie donde voy a documentar mi proceso de aprendizaje, voy a investigar sobre la computación cuántica, como funciona, como programar con Qiskit y otros temas a futuro. Esta serie va a detallar mi viaje por el conocimiento de uno de los temas que en mi opinión personal considero importante para el futuro de la computación.

La estructura de los artículos y su orden se basa en la estructura de distintos libros de computación cuántica que puedes encontrar en la bibliografía.

Computación cuántica es un campo multidisciplinario que consiste en usar los fenómenos y conocimientos actuales de la mecánica cuántica a pequeña escala para poder realizar cálculos sobre estructuras informáticas con una mayor velocidad respecto a la computación cotidiana (computación clásica).

Si bien los computadores cuánticos no ofrecen un reemplazo a los computadores actuales, si nos ofrecen un gran complemento para poder acelerar las capacidades de cómputo actuales.

Actualmente, la computación cuántica se usa como complemento en muchos casos al hardware común. En este artículo veremos algunas diferencias y conceptos básicos para entender la computación cuántica y los artículos futuros.

¿Por qué es importante la computación cuántica?

En 1985, en un artículo llamado "Simulating Physics with computers" publicado en 1982, Richard Feynman (Físico teórico) habló sobre el problema de simular la física cuántica con computación clásica, y planteo un sistema de computación para simular sistemas cuánticos con mayor precisión, ese sistema se llamó Computadora Cuántica. También planteo que los problemas que podía resolver el nuevo sistema de computación, no eran posibles de simular en una computadora clásica.

Superposición y el Q-Bit

La superposición es algo curioso, nosotros damos por hecho de que si compramos un cuaderno rojo en la tienda, si lo llevamos a una capa de abstracción, podríamos pensar en el color del cuaderno como una propiedad, y tendríamos el color rojo como una constante en nuestra estructura, lo compramos rojo, no tendría sentido que mañana fuera azul.

Ahora, si pensamos en términos de mecánica cuántica, es un poco distinto, el cuaderno sigue teniendo una propiedad color, el cual puede ser rojo y azul al mismo tiempo, es decir, pensando en términos cuánticos, el cuaderno en su propiedad de color tiene dos colores al mismo tiempo, es decir, es rojo y azul al mismo tiempo.

Entendiendo que el color es una propiedad física inherente al cuaderno, imagina que hacemos una medición sobre esa propiedad, lo curioso es que la medición solo nos arrojará un resultado, rojo o azul, nunca nos dará un indicio que es de dos colores al mismo tiempo.

Aunque esto suene un poco extraño, es la forma exacta sobre como funcionan los Q-Bits, ahora hagamos el paralelo donde la propiedad de color, la renombramos como "espín". Pero más adelante volveremos a esta noción, pero para abrir el apetito, a decir lo siguiente: Las computadoras clásicas se basan en 0 y 1, y también hay una notación simbólica parecida en la computación cuántica y es, |0〉 y |1〉. Por ahora solo quédate con esta noción de la superposición y la propiedad de espín.

Aplicaciones

El título intenta dar razones para aprender computación cuántica, y aquí vamos a repasar aplicaciones comunes para la computación cuántica.

Simulaciones Físicas

La computación cuántica, como la planteó Feynman fue principalmente propuesta por su potencial de simular sistemas cuánticos complejos con mayor precisión, podríamos por ejemplo simular materiales, reacciones químicas, o interacciones moleculares. Esto nos podría ayudar a entender mejor estos sistemas y como manipularlos.

Machine Learning

La computación cuántica podría acelerar de gran el proceso de entrenamiento y evaluación de modelos de Machine Learning, en la computación cuántica el aprendizaje de máquina aún es un campo relativamente prematuro, pero los avances de la tecnología nos ayudará a seguir expandiendo las capacidades de estas máquinas.

Otra forma de aprovechar las capacidades cuánticas en este campo es la computación híbrida, en esta se combinarían ambos enfoques, el clásico y el cuántico y de este modo hacer procesamiento de imágenes o procesamiento del lenguaje natural.

Finanzas

También la computación cuántica puede tener aplicaciones en las finanzas, principalmente por su capacidad de optimizar y automatizar con más fidelidad el proceso de toma de decisiones de inversión, también se podría mejorar significativamente el proceso de evaluación de riesgos de inversión y significativamente mejorar las predicciones.

Criptografía

La criptografía está más presente que nunca en nuestro día a día seamos conscientes o no. La criptografía clásica se apoya en un principio que informalmente se describiría así: "Confío que tu tecnología no es tan avanzada como para factorizar este gran número", ese gran número se llama llave, y nos sirve para encriptar y desencriptar mensajes

Este campo está actualmente en crecimiento y hay bastante investigación al respecto.

Y más

La computación cuántica aún es un campo poco explorado respecto a la computación clásica, por lo tanto, los avances están a la orden del día, y el número de aplicaciones igualmente va al alza, es por esto que te recomiendo que no cierres tu mente solo a las posibilidades expuestas aquí, hay mucho más que aún no se ha descubierto.

¿En qué son diferentes las computadoras cuánticas a las clásicas?, si estás aquí es porque algo sabes del tema, siempre se dice que la computación cuántica es distinto a la computación clásica, pero ¿en qué son distintas?, ¿realmente sabes por qué lo son?

¿Es el computador cuántico, parecido a un computador clásico?

Cuando te sientas en tu computador, aunque sepas poco sobre arquitectura de computación, sabes más o menos cuáles son las partes principales que componen tu computador, por ejemplo:

CPU (Unidad de procesamiento central)
RAM (Memoria de acceso aleatorio)
GPU (Unidad de procesamiento de gráficos)
Discos Duros

De todos estos dispositivos de la computación clásica, para entender la diferencia entre la computación cuántica y la clásica, primero detallaré como funcionan todos estos dispositivos, la placa madre y la fuente de poder se excluyen a propósito.

Las unidades de procesamiento central, son los cerebros de nuestros computadores, y en la computación moderna se componen de distintas partes:

CU (Unidad de control)
ALU (Unidad Aritmética Lógica)

No entraré en muchos detalles, sino que daré una explicación bastante escueta de cada una de las tareas que cumple cada una:

CU: La unidad de control decodifica las operaciones del ciclo de instrucciones. La principal (MU o RAM) función de la unidad de control es decodificar las instrucciones que se leen de la memoria principal del computador. La forma en que la unidad de control obtiene la información desde la memoria principal es usando el contador de programa (PC), el PC es un registro del procesador que retiene la dirección de la instrucción que se está ejecutando en el momento, alterando el registro se pueden acceder a distintos sectores de la RAM. La unidad de control también se encarga de regular la velocidad del ciclo de instrucciones, regulando la velocidad del reloj. La unidad de control igualmente regula las operaciones de varios componentes del hardware del computador, generando las señales de control. Estas señales de control son transmitidas al hardware a través de los Bus de control.
ALU: es la encargada de ejecutar las instrucciones aritméticas y lógicas, la unidad de control se encarga de decodificar la información como operandos y operadores para que la ALU pueda llevar a cabo las operaciones del procesador.
- Las operaciones de las que se encarga la ALU son: suma, resta, incremento, decremento, and, or, xor, rotl, rotr, comparaciones y complementos.

La memoria RAM funciona como un almacenamiento temporal, la RAM almacena valores en que se usan los programas para realizar sus operaciones, puede almacenar tanto resultados completos como incompletos. El procesador accede a la RAM para leer instrucciones, la dirección se almacena en el PC. A través de los buses de conexión de la RAM se pueden leer y escribir valores, cada vez que abrimos un programa en nuestros computadores, cada variable, instrucción, se va directamente a la memoria RAM.

La GPU es un poco distinta al procesador, debido a que la GPU puede procesar una cantidad mayor de valores al mismo tiempo. Las GPU son sumamente eficientes en la manipulación, cálculo y transformación de matrices, es por eso que la forma principal de usarlas es a través de transformaciones lineales (¿Qué son las transformaciones lineales?). Las GPU también tienen su memoria RAM donde almacenan los datos que el procesador mueva para que la GPU pueda calcular y comunicar los resultados de vuelta a la unidad de control.

Teniendo todo esto en cuenta, quizás una de las representaciones más pobres en donde encaja nuestro computador cuántico, es en la comparación directa con la GPU, Aunque son distintos a las GPU en la mayoría de los aspectos, ambas requieren al álgebra lineal para comunicarse, quizás la forma de trabajar con ambos sea totalmente distinta, pero su funcionamiento más que pensar en una pieza de Hardware completa como la que tenemos en nuestros hogares, bolsillos etc., es pensarlo como un complemento para acelerar la computación.

Aritmetica

Como bien sabemos, los procesadores normales trabajan con la aritmética binaria. La forma en que tenemos de generar resultados con los computadores convencionales es a través de manipulación de bits. Los bits tienen un valor conocido que puede ser 1 o 0. Por otro lado, en la computación cuántica, tenemos que hacer manipulación de Qbits, estos pueden estar en un estado de superposición, es decir, que pueden ser 0 y 1 a la vez.

La manipulación de Qbits se basa en las leyes de la mecánica cuántica, lo cual puede llevarnos a fenómenos cuánticos como la interferencia o entrelazamiento cuántico. Pero el funcionamiento de los Qbits a fondo, será tema para el siguiente artículo, espero que este artículo haya servido para abrir tu apetito respecto al potencial de la computación cuántica.

Conclusión

Si bien la computación clásica no será reemplazada por la computación cuántica, es importante aprender a usarla, ya que puede acelerar la capacidad de cómputo considerablemente. Hoy en día "computación cuántica" es un término empleado por las personas comunes, pero no todas saben exactamente a que se refiere, espero este primer artículo te dé una mejor idea sobre a lo que se refiere el término "computación cuántica".

Agradecimientos

Si estás leyendo esto, te agradezco el interés por este artículo, recuerda compartirlo con tus contactos, seguirme para estar enterado de los futuros artículos.

Bibliografia

Sutor. Robert. Dancing with Qubits. 1st ed. Packt Publishing Ltd.; 2019.
Fisher, Tim. Everything You Need to Know About Computer Hardware. Lifewire. Accessed February 17, 2023. https://www.lifewire.com/computer-hardware-2625895
Wong D. How to Backdoor Diffie-Hellman. Accessed February 17, 2023. https://eprint.iacr.org/2016/644.pdf
Wong D. How to Backdoor Diffie-Hellman. Published online 2016. Accessed February 17, 2023. https://eprint.iacr.org/2016/644
Ledin J, Farley D. Modern Computer Architecture and Organization: Learn x86, ARM, and RISC-V architectures and the design of smartphones, PCs, and cloud servers, 2nd Edition.; 2022.
IBM. Quantum computing use cases for financial services. IBM. Published September 12, 2019. Accessed February 17, 2023. https://www.ibm.com/thought-leadership/institute-business-value/en-us/report/exploring-quantum-financial
Grasselli F. Quantum Cryptography: From Key Distribution to Conference Key Agreement. Springer International Publishing; 2021. doi:10.1007/978-3-030-64360-7
Li T, Yin ZQ. Quantum superposition, entanglement, and state teleportation of a microorganism on an electromechanical oscillator. Science Bulletin. 2016;61(2):163-171. doi:10.1007/s11434-015-0990-x
Feynman RP. Simulating physics with computers. Int J Theor Phys. 1982;21(6):467-488. doi:10.1007/BF02650179
Sutor. Robert. What’s inside a computer? In: Dancing With Qubits. 1st ed. Packt Publishing Ltd.; 2019:445.