In diesem Tutorial erstellen wir von Grund auf einen fortschrittlichen Agenten für die Computernutzung, der mithilfe eines lokalen, offenen Modells virtuelle Aktionen begründen, planen und ausführen kann. Wir erstellen einen simulierten Miniatur-Desktop, statten ihn mit einer Software-Schnittstelle aus und entwerfen einen intelligenten Agenten, der seine Umgebung analysieren, über Aktionen wie Klicken oder Tippen entscheiden und diese Schritt für Schritt ausführen kann. Am Ende sehen wir, wie der Agent Ziele wie das Öffnen von E-Mails oder das Erstellen von Notizen interpretiert und demonstrieren so, wie ein lokales Sprachmodell interaktives Denken und Aufgabenausführung nachahmen kann. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
!pip set up -q transformers speed up sentencepiece nest_asyncio
import torch, asyncio, uuid
from transformers import pipeline
import nest_asyncio
nest_asyncio.apply()Wir richten unsere Umgebung ein, indem wir wichtige Bibliotheken wie Transformers, Speed up und Nest Asyncio installieren, die es uns ermöglichen, lokale Modelle und asynchrone Aufgaben nahtlos in Colab auszuführen. Wir bereiten die Laufzeit so vor, dass die kommenden Komponenten unseres Agenten ohne externe Abhängigkeiten effizient arbeiten können. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
class LocalLLM:
def __init__(self, model_name="google/flan-t5-small", max_new_tokens=128):
self.pipe = pipeline("text2text-generation", mannequin=model_name, system=0 if torch.cuda.is_available() else -1)
self.max_new_tokens = max_new_tokens
def generate(self, immediate: str) -> str:
out = self.pipe(immediate, 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://instance.com", "notes": "", "mail": ("Welcome to CUA", "Bill #221", "Weekly Report")}
self.focus = "browser"
self.display screen = "Browser open at https://instance.comnSearch bar centered."
self.action_log = ()
def screenshot(self):
return f"FOCUS:{self.focus}nSCREEN:n{self.display screen}nAPPS:{listing(self.apps.keys())}"
def click on(self, goal:str):
if goal in self.apps:
self.focus = goal
if goal=="browser":
self.display screen = f"Browser tab: {self.apps('browser')}nAddress bar centered."
elif goal=="notes":
self.display screen = f"Notes AppnCurrent notes:n{self.apps('notes')}"
elif goal=="mail":
inbox = "n".be part of(f"- {s}" for s in self.apps('mail'))
self.display screen = f"Mail App Inbox:n{inbox}n(Learn-only preview)"
else:
self.display screen += f"nClicked '{goal}'."
self.action_log.append({"sort":"click on","goal":goal})
def sort(self, textual content:str):
if self.focus=="browser":
self.apps("browser") = textual content
self.display screen = f"Browser tab now at {textual content}nPage headline: Instance Area"
elif self.focus=="notes":
self.apps("notes") += ("n"+textual content)
self.display screen = f"Notes AppnCurrent notes:n{self.apps('notes')}"
else:
self.display screen += f"nTyped '{textual content}' however no editable subject."
self.action_log.append({"sort":"sort","textual content":textual content})Wir definieren die Kernkomponenten, ein leichtes lokales Modell und einen virtuellen Pc. Wir verwenden Flan-T5 als unsere Argumentationsmaschine und erstellen einen simulierten Desktop, der Apps öffnen, Bildschirme anzeigen und auf Tipp- und Klickaktionen reagieren kann. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
class ComputerTool:
def __init__(self, pc:VirtualComputer):
self.pc = pc
def run(self, command:str, argument:str=""):
if command=="click on":
self.pc.click on(argument)
return {"standing":"accomplished","end result":f"clicked {argument}"}
if command=="sort":
self.pc.sort(argument)
return {"standing":"accomplished","end result":f"typed {argument}"}
if command=="screenshot":
snap = self.pc.screenshot()
return {"standing":"accomplished","end result":snap}
return {"standing":"error","end result":f"unknown command {command}"}Wir stellen die ComputerTool-Schnittstelle vor, die als Kommunikationsbrücke zwischen der Argumentation des Agenten und dem virtuellen Desktop fungiert. Wir definieren Vorgänge auf hoher Ebene wie Klicken, Tippen und Screenshot, die es dem Agenten ermöglichen, auf strukturierte Weise mit der Umgebung zu interagieren. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
class ComputerAgent:
def __init__(self, llm:LocalLLM, software:ComputerTool, max_trajectory_budget:float=5.0):
self.llm = llm
self.software = software
self.max_trajectory_budget = max_trajectory_budget
async def run(self, messages):
user_goal = messages(-1)("content material")
steps_remaining = int(self.max_trajectory_budget)
output_events = ()
total_prompt_tokens = 0
total_completion_tokens = 0
whereas steps_remaining>0:
display screen = self.software.pc.screenshot()
immediate = (
"You're a computer-use agent.n"
f"Person objective: {user_goal}n"
f"Present display screen:n{display screen}nn"
"Assume step-by-step.n"
"Reply with: ACTION <click on/sort/screenshot> ARG <goal or textual content> THEN <assistant message>.n"
)
thought = self.llm.generate(immediate)
total_prompt_tokens += len(immediate.break up())
total_completion_tokens += len(thought.break up())
motion="screenshot"; arg=""; assistant_msg="Working..."
for line in thought.splitlines():
if line.strip().startswith("ACTION "):
after = line.break up("ACTION ",1)(1)
motion = after.break up()(0).strip()
if "ARG " in line:
half = line.break up("ARG ",1)(1)
if " THEN " partially:
arg = half.break up(" THEN ")(0).strip()
else:
arg = half.strip()
if "THEN " in line:
assistant_msg = line.break up("THEN ",1)(1).strip()
output_events.append({"abstract":({"textual content":assistant_msg,"sort":"summary_text"}),"sort":"reasoning"})
call_id = "call_"+uuid.uuid4().hex(:16)
tool_res = self.software.run(motion, arg)
output_events.append({"motion":{"sort":motion,"textual content":arg},"call_id":call_id,"standing":tool_res("standing"),"sort":"computer_call"})
snap = self.software.pc.screenshot()
output_events.append({"sort":"computer_call_output","call_id":call_id,"output":{"sort":"input_image","image_url":snap}})
output_events.append({"sort":"message","position":"assistant","content material":({"sort":"output_text","textual content":assistant_msg})})
if "completed" in assistant_msg.decrease() or "right here is" in assistant_msg.decrease():
break
steps_remaining -= 1
utilization = {"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, "utilization": utilization}Wir konstruieren den ComputerAgent, der als intelligenter Controller des Programs dient. Wir programmieren es so, dass es über Ziele nachdenkt, entscheidet, welche Maßnahmen ergriffen werden sollen, diese über die Software-Schnittstelle ausführt und jede Interaktion als Schritt im Entscheidungsprozess aufzeichnet. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
async def main_demo():
pc = VirtualComputer()
software = ComputerTool(pc)
llm = LocalLLM()
agent = ComputerAgent(llm, software, max_trajectory_budget=4)
messages=({"position":"consumer","content material":"Open mail, learn inbox topics, and summarize."})
async for end in agent.run(messages):
print("==== STREAM RESULT ====")
for occasion in end result("output"):
if occasion("sort")=="computer_call":
a = occasion.get("motion",{})
print(f"(TOOL CALL) {a.get('sort')} -> {a.get('textual content')} ({occasion.get('standing')})")
if occasion("sort")=="computer_call_output":
snap = occasion("output")("image_url")
print("SCREEN AFTER ACTION:n", snap(:400),"...n")
if occasion("sort")=="message":
print("ASSISTANT:", occasion("content material")(0)("textual content"), "n")
print("USAGE:", end result("utilization"))
loop = asyncio.get_event_loop()
loop.run_until_complete(main_demo())Wir bringen alles zusammen, indem wir die Demo ausführen, bei der der Agent die Anfrage eines Benutzers interpretiert und Aufgaben auf dem virtuellen Pc ausführt. Wir beobachten, wie es Überlegungen anstellt, Befehle ausführt, den virtuellen Bildschirm aktualisiert und sein Ziel klar und Schritt für Schritt erreicht.
Zusammenfassend haben wir die Essenz eines computergestützten Agenten implementiert, der zu autonomem Denken und Interaktion fähig ist. Wir erleben, wie lokale Sprachmodelle wie Flan-T5 die Automatisierung auf Desktop-Ebene in einer sicheren, textbasierten Sandbox wirkungsvoll simulieren können. Dieses Projekt hilft uns, die Architektur hinter intelligenten Agenten zu verstehen, beispielsweise denen in Pc-Agenten, indem es das Denken in natürlicher Sprache mit der Steuerung virtueller Werkzeuge verbindet. Es schafft eine solide Grundlage für die Ausweitung dieser Fähigkeiten auf reale, multimodale und sichere Automatisierungssysteme.
Schauen Sie sich das an VOLLSTÄNDIGE CODES hier. Schauen Sie sich gerne bei uns um GitHub-Seite für Tutorials, Codes und Notebooks. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 100.000+ ML SubReddit und Abonnieren Unser E-newsletter. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.
Asif Razzaq ist CEO von Marktechpost Media Inc.. Als visionärer Unternehmer und Ingenieur setzt sich Asif dafür ein, das Potenzial der künstlichen Intelligenz für das soziale Wohl zu nutzen. Sein jüngstes Unterfangen ist die Einführung einer Medienplattform für künstliche Intelligenz, Marktechpost, die sich durch eine ausführliche Berichterstattung über maschinelles Lernen und Deep-Studying-Nachrichten auszeichnet, die sowohl technisch fundiert als auch für ein breites Publikum leicht verständlich ist. Die Plattform verfügt über mehr als 2 Millionen monatliche Aufrufe, was ihre Beliebtheit beim Publikum verdeutlicht.