En este tutorial, creamos un agente avanzado para el uso de computadoras desde cero que puede razonar, planificar y realizar acciones virtuales utilizando un modelo local de peso abierto. Creamos un escritorio simulado en miniatura, lo equipamos con una interfaz de herramienta y diseñamos un agente inteligente que puede analizar su entorno, decidir acciones como hacer clic o escribir y ejecutarlas paso a paso. Al final, vemos cómo el agente interpreta objetivos como abrir correos electrónicos o tomar notas, lo que demuestra cómo un modelo de lenguaje local puede imitar el razonamiento interactivo y la ejecución de tareas. Consulta los CÓDIGOS COMPLETOS aquí.
Configuramos nuestro entorno instalando bibliotecas esenciales como Transformers, Accelerate y Nest Asyncio, que nos permiten ejecutar modelos locales y tareas asincrónicas sin problemas en Colab. Preparamos el tiempo de ejecución para que los próximos componentes de nuestro agente puedan funcionar de manera eficiente sin dependencias externas. Consulta los CÓDIGOS COMPLETOS aquí.
return out.strip() clase Computadora virtual: def __init__(self): self.apps = {“navegador”: “https://example.com”, “notas”: “”, “correo”: [“Welcome to CUA”, “Invoice #221”, “Weekly Report”]} self.focus = “browser” self.screen = “Navegador abierto en https://example.com\nBarra de búsqueda enfocada.” self.action_log = []
def captura de pantalla(self): return f”FOCUS:{self.focus}\nSCREEN:\n{self.screen}\nAPPS:{list(self.apps.keys())}” def click(self, target:str): if target in self.apps: self.focus = target if target==”browser”: self.screen = f”Pestaña del navegador: {self.apps[‘browser’]}\nBarra de direcciones enfocada.” elif target==”notes”: self.screen = f”Aplicación Notes\nNotas actuales:\n{self.apps[‘notes’]}” elif target==”mail”: bandeja de entrada = “\n”.join(f”- {s}” para s en self.apps[‘mail’]) self.screen = f”Bandeja de entrada de la aplicación de correo:\n{bandeja de entrada}\n(vista previa de solo lectura)” else: self.screen += f”\nSe hizo clic en ‘{target}'”. self.action_log.append({“type”:”click”,”target”:target}) def tipo(self, text:str): if self.focus==”navegador”: self.apps[“browser”] = text self.screen = f”Pestaña del navegador ahora en {text}\nTítulo de página: Dominio de ejemplo” elif self.focus==”notas”: self.apps[“notes”] += (“\n”+texto) self.screen = f”Aplicación de notas\nNotas actuales:\n{self.apps[‘notes’]}” else: self.screen += f”\nEscribió ‘{text}’ pero no hay campo editable.” self.action_log.append({“type”:”type”,”text”:text})
Definimos los componentes principales, un modelo local liviano y una computadora virtual. Usamos Flan-T5 como nuestro motor de razonamiento y creamos un escritorio simulado que puede abrir aplicaciones, mostrar pantallas y responder a acciones de escritura y clic. Consulta los CÓDIGOS COMPLETOS aquí.
Presentamos la interfaz ComputerTool, que actúa como puente de comunicación entre el razonamiento del agente y el escritorio virtual. Definimos operaciones de alto nivel como hacer clic, escribir y capturar capturas de pantalla, lo que permite al agente interactuar con el entorno de forma estructurada. Consulta los CÓDIGOS COMPLETOS aquí.
pasos_restantes = int(self.max_trajectory_budget) salida_eventos = []
total_prompt_tokens = 0 total_completion_tokens = 0 mientras que los pasos_restantes>0: pantalla = self.tool.computer.screenshot() mensaje = ( “Eres un agente de uso de computadoras.\n” f”Objetivo del usuario: {user_goal}\n” f”Pantalla actual:\n{pantalla}\n\n” “Piensa paso a paso.\n” “Responder con: ACTION ARG THEN .\n” ) pensamiento = self.llm.generate(prompt) total_prompt_tokens += len(prompt.split()) total_completion_tokens += len(thinked.split()) action=”captura de pantalla”; arg=””; asistente_msg=”Trabajando…” para línea en pensamiento.splitlines(): if line.strip().startswith(“ACCIÓN “): después = line.split(“ACCIÓN “,1)[1]
acción = después.split()[0].strip() si “ARG ” en línea: part = line.split(“ARG “,1)[1]
si ” ENTONCES ” en parte: arg = part.split(” ENTONCES “)[0].strip() else: arg = part.strip() si “ENTONCES” en la línea: asistente_msg = line.split(“ENTONCES”,1)[1].strip() salida_eventos.append({“resumen”:[{“text”:assistant_msg,”type”:”summary_text”}],”tipo”:”razonamiento”}) call_id = “call_”+uuid.uuid4().hex[:16]
tool_res = self.tool.run(action, arg) output_events.append({“action”:{“type”:action,”text”:arg},”call_id”:call_id,”status”:tool_res[“status”],”type”:”computer_call”}) snap = self.tool.computer.screenshot() salida_events.append({“type”:”computer_call_output”,”call_id”:call_id,”output”:{“type”:”input_image”,”image_url”:snap}}) salida_eventos.append({“tipo”:”mensaje”,”rol”:”asistente”,”contenido”:[{“type”:”output_text”,”text”:assistant_msg}]}) si “hecho” en asistente_msg.lower() o “aquí está” en asistente_msg.lower(): romper pasos_restantes -= 1 uso = {“prompt_tokens”: total_prompt_tokens,”completion_tokens”: total_completion_tokens,”total_tokens”: total_prompt_tokens + total_completion_tokens,”response_cost”: 0.0} rendimiento {“output”: output_events, “usage”: uso}
Construimos el ComputerAgent, que sirve como controlador inteligente del sistema. Lo programamos para razonar sobre objetivos, decidir qué acciones tomar, ejecutarlas a través de la interfaz de la herramienta y registrar cada interacción como un paso en su proceso de toma de decisiones. Consulta los CÓDIGOS COMPLETOS aquí.
async para el resultado en agent.run(messages): print(“==== STREAM RESULT ====”) para el evento en el resultado[“output”]: si evento[“type”]==”llamada_computadora”: a = event.get(“acción”,{}) print(f”[TOOL CALL] {a.get(‘tipo’)} -> {a.get(‘texto’)} [{event.get(‘status’)}]”) si evento[“type”]==”computer_call_output”: chasquido = evento[“output”][“image_url”]
print(“PANTALLA DESPUÉS DE LA ACCIÓN:\n”, chasquear[:400],”…\n”) si evento[“type”]==”mensaje”: print(“ASISTENTE:”, evento[“content”][0][“text”]”\n”) print(“USO:”, resultado[“usage”]) bucle = asyncio.get_event_loop() bucle.run_until_complete(main_demo())
Reunimos todo ejecutando la demostración, donde el agente interpreta la solicitud de un usuario y realiza tareas en la computadora virtual. Lo observamos generando razonamientos, ejecutando comandos, actualizando la pantalla virtual y logrando su objetivo de manera clara y paso a paso.
En conclusión, implementamos la esencia de un agente de uso de computadora capaz de razonamiento e interacción autónomos. Somos testigos de cómo los modelos de lenguaje local como Flan-T5 pueden simular poderosamente la automatización a nivel de escritorio dentro de un entorno limitado seguro basado en texto. Este proyecto nos ayuda a comprender la arquitectura detrás de los agentes inteligentes, como los de los agentes que utilizan computadoras, uniendo el razonamiento del lenguaje natural con el control de herramientas virtuales. Sienta una base sólida para ampliar estas capacidades hacia sistemas de automatización seguros, multimodales y del mundo real.
Consulta los CÓDIGOS COMPLETOS aquí. No dude en consultar nuestra página de GitHub para tutoriales, códigos y cuadernos. Además, no dude en seguirnos en Twitter y no olvide unirse a nuestro SubReddit de más de 100.000 ML y suscribirse a nuestro boletín. ¡Esperar! estas en telegrama? Ahora también puedes unirte a nosotros en Telegram.
Asif Razzaq es el director ejecutivo de Marktechpost Media Inc.. Como emprendedor e ingeniero visionario, Asif está comprometido a aprovechar el potencial de la inteligencia artificial para el bien social. Su esfuerzo más reciente es el lanzamiento de una plataforma de medios de inteligencia artificial, Marktechpost, que se destaca por su cobertura en profundidad del aprendizaje automático y las noticias sobre aprendizaje profundo que es técnicamente sólida y fácilmente comprensible para una amplia audiencia. La plataforma cuenta con más de 2 millones de visitas mensuales, lo que ilustra su popularidad entre el público.
🙌 Siga MARKTECHPOST: agréguenos como fuente preferida en Google.