En este tutorial, creamos un agente reformista para el uso de computadoras desde cero que puede razonar, planificar y realizar acciones virtuales utilizando un maniquí circunscrito de peso campechano. Creamos un escritorio simulado en miniatura, lo equipamos con una interfaz de aparejo y diseñamos un agente inteligente que puede analizar su entorno, animarse acciones como hacer clic o escribir y ejecutarlas paso a paso. Al final, vemos cómo el agente interpreta objetivos como desobstruir correos electrónicos o tomar notas, lo que demuestra cómo un maniquí de lengua circunscrito puede imitar el razonamiento interactivo y la ejecución de tareas. Mira el CÓDIGOS COMPLETOS aquí.
!pip install -q transformers accelerate sentencepiece nest_asyncio
import torch, asyncio, uuid
from transformers import pipeline
import nest_asyncio
nest_asyncio.apply()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 forma apto sin dependencias externas. Mira el CÓDIGOS COMPLETOS aquí.
class LocalLLM:
def __init__(self, model_name="google/flan-t5-small", max_new_tokens=128):
self.pipe = pipeline("text2text-generation", model=model_name, device=0 if torch.cuda.is_available() else -1)
self.max_new_tokens = max_new_tokens
def generate(self, prompt: str) -> str:
out = self.pipe(prompt, max_new_tokens=self.max_new_tokens, temperature=0.0)(0)("generated_text")
return out.strip()
class VirtualComputer:
def __init__(self):
self.apps = {"browser": "https://example.com", "notes": "", "mail": ("Welcome to CUA", "Invoice #221", "Weekly Report")}
self.focus = "browser"
self.screen = "Browser open at https://example.comnSearch bar focused."
self.action_log = ()
def screenshot(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"Browser tab: {self.apps('browser')}nAddress bar focused."
elif target=="notes":
self.screen = f"Notes AppnCurrent notes:n{self.apps('notes')}"
elif target=="mail":
inbox = "n".join(f"- {s}" for s in self.apps('mail'))
self.screen = f"Mail App Inbox:n{inbox}n(Read-only preview)"
else:
self.screen += f"nClicked '{target}'."
self.action_log.append({"type":"click","target":target})
def type(self, text:str):
if self.focus=="browser":
self.apps("browser") = text
self.screen = f"Browser tab now at {text}nPage headline: Example Domain"
elif self.focus=="notes":
self.apps("notes") += ("n"+text)
self.screen = f"Notes AppnCurrent notes:n{self.apps('notes')}"
else:
self.screen += f"nTyped '{text}' but no editable field."
self.action_log.append({"type":"type","text":text})Definimos los componentes principales, un maniquí circunscrito sutil y una computadora posible. Usamos Flan-T5 como nuestro motor de razonamiento y creamos un escritorio simulado que puede desobstruir aplicaciones, mostrar pantallas y reponer a acciones de escritura y clic. Mira el CÓDIGOS COMPLETOS aquí.
class ComputerTool:
def __init__(self, computer:VirtualComputer):
self.computer = computer
def run(self, command:str, argument:str=""):
if command=="click":
self.computer.click(argument)
return {"status":"completed","result":f"clicked {argument}"}
if command=="type":
self.computer.type(argument)
return {"status":"completed","result":f"typed {argument}"}
if command=="screenshot":
snap = self.computer.screenshot()
return {"status":"completed","result":snap}
return {"status":"error","result":f"unknown command {command}"}Presentamos la interfaz ComputerTool, que actúa como puente de comunicación entre el razonamiento del agente y el escritorio posible. Definimos operaciones de detención nivel como hacer clic, escribir y capturar capturas de pantalla, lo que permite al agente interactuar con el entorno de forma estructurada. Mira el CÓDIGOS COMPLETOS aquí.
class ComputerAgent:
def __init__(self, llm:LocalLLM, tool:ComputerTool, max_trajectory_budget:float=5.0):
self.llm = llm
self.tool = tool
self.max_trajectory_budget = max_trajectory_budget
async def run(self, messages):
user_goal = messages(-1)("content")
steps_remaining = int(self.max_trajectory_budget)
output_events = ()
total_prompt_tokens = 0
total_completion_tokens = 0
while steps_remaining>0:
screen = self.tool.computer.screenshot()
prompt = (
"You are a computer-use agent.n"
f"User goal: {user_goal}n"
f"Current screen:n{screen}nn"
"Think step-by-step.n"
"Reply with: ACTION ARG THEN .n"
)
thought = self.llm.generate(prompt)
total_prompt_tokens += len(prompt.split())
total_completion_tokens += len(thought.split())
action="screenshot"; arg=""; assistant_msg="Working..."
for line in thought.splitlines():
if line.strip().startswith("ACTION "):
after = line.split("ACTION ",1)(1)
action = after.split()(0).strip()
if "ARG " in line:
part = line.split("ARG ",1)(1)
if " THEN " in part:
arg = part.split(" THEN ")(0).strip()
else:
arg = part.strip()
if "THEN " in line:
assistant_msg = line.split("THEN ",1)(1).strip()
output_events.append({"summary":({"text":assistant_msg,"type":"summary_text"}),"type":"reasoning"})
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()
output_events.append({"type":"computer_call_output","call_id":call_id,"output":{"type":"input_image","image_url":snap}})
output_events.append({"type":"message","role":"assistant","content":({"type":"output_text","text":assistant_msg})})
if "done" in assistant_msg.lower() or "here is" in assistant_msg.lower():
break
steps_remaining -= 1
usage = {"prompt_tokens": total_prompt_tokens,"completion_tokens": total_completion_tokens,"total_tokens": total_prompt_tokens + total_completion_tokens,"response_cost": 0.0}
yield {"output": output_events, "usage": usage} Construimos el ComputerAgent, que sirve como regulador inteligente del sistema. Lo programamos para razonar sobre objetivos, animarse qué acciones tomar, ejecutarlas a través de la interfaz de la aparejo y registrar cada interacción como un paso en su proceso de toma de decisiones. Mira el CÓDIGOS COMPLETOS aquí.
async def main_demo():
computer = VirtualComputer()
tool = ComputerTool(computer)
llm = LocalLLM()
agent = ComputerAgent(llm, tool, max_trajectory_budget=4)
messages=({"role":"user","content":"Open mail, read inbox subjects, and summarize."})
async for result in agent.run(messages):
print("==== STREAM RESULT ====")
for event in result("output"):
if event("type")=="computer_call":
a = event.get("action",{})
print(f"(TOOL CALL) {a.get('type')} -> {a.get('text')} ({event.get('status')})")
if event("type")=="computer_call_output":
snap = event("output")("image_url")
print("SCREEN AFTER ACTION:n", snap(:400),"...n")
if event("type")=="message":
print("ASSISTANT:", event("content")(0)("text"), "n")
print("USAGE:", result("usage"))
loop = asyncio.get_event_loop()
loop.run_until_complete(main_demo())Reunimos todo ejecutando la demostración, donde el agente interpreta la solicitud de un favorecido y realiza tareas en la computadora posible. Lo observamos generando razonamientos, ejecutando comandos, actualizando la pantalla posible y logrando su objetivo de forma 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 lengua circunscrito como Flan-T5 pueden disimular poderosamente la automatización a nivel de escritorio interiormente de un entorno circunscrito seguro basado en texto. Este esquema nos ayuda a comprender la edificación detrás de los agentes inteligentes, como los de los agentes que utilizan computadoras, uniendo el razonamiento del lengua natural con el control de herramientas virtuales. Sienta una pulvínulo sólida para ampliar estas capacidades en dirección a sistemas de automatización seguros, multimodales y del mundo auténtico.
Mira el CÓDIGOS COMPLETOS aquí. No dudes en consultar nuestra Página de GitHub para tutoriales, códigos y cuadernos. Por otra parte, no dudes en seguirnos en Gorjeo y no olvides unirte a nuestro SubReddit de más de 100.000 ml y suscríbete a nuestro boletín. ¡Esperar! estas en telegrama? Ahora además puedes unirte a nosotros en Telegram.
Asif Razzaq es el director ejecutor de Marktechpost Media Inc.. Como emprendedor e ingeniero fantasioso, Asif está comprometido a utilizar el potencial de la inteligencia industrial para el proporcionadamente social. Su esfuerzo más flamante es el divulgación de una plataforma de medios de inteligencia industrial, Marktechpost, que se destaca por su cobertura en profundidad del formación espontáneo y las telediario sobre formación 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 sabido.