Immer häufiger sieht man Roboter, die die Straße entlanglaufen, umgeben von staunenden Zuschauern. Aber diese Maschinen sind noch nicht die Allround-Assistenten, die man sich für die Arbeit in einer Küche oder Fabrik wünscht, und ein großer Engpass sind die Daten. Ähnlich wie Menschen lernen Roboter am besten durch Erfahrung. Die Herausforderung besteht darin, dass es arbeitsintensiv und zeitaufwändig ist, diesen Maschinen so viele Aktionen in verschiedenen Umgebungen physisch beizubringen.

„Eine natürliche Idee besteht darin, Simulationen als Übungsgelände zu nutzen. Während es in den letzten Jahren erhebliche Fortschritte bei den Physik-Engines gab, die Robotersimulatoren antreiben, besteht eine der verbleibenden Herausforderungen darin, ausreichend umfangreiche und vielfältige Simulationsinhalte zu erstellen, um die Komplexität der realen Welt zu erfassen“, sagt Russ Tedrake, Toyota-Professor für Elektrotechnik und Informatik (EECS), Luft- und Raumfahrt sowie Maschinenbau am MIT und leitender Forscher am Pc Science and Synthetic Intelligence Laboratory (CSAIL) des MIT.

Es stellt sich heraus, dass KI-Agenten oder halbautonome Programme, die „denken“ und genau definierte Aufgaben ausführen, dabei helfen könnten, die lebensechten virtuellen Umgebungen zu schaffen, die Roboter benötigen. Das neue „SceneSmithDas von Forschern des MIT CSAIL und des Toyota Analysis Institute entwickelte System verwendet drei Agenten, um die Objekte, Wände und das Gesamtbild einer 3D-Szene zusammenzusetzen. Die Nachbildungen von Innenräumen wie Eating places, Schlafzimmern und Lodges sind realistischer und detaillierter als frühere Systeme und helfen Robotern, Fähigkeiten zu üben und verschiedene Arten der Aufgabenerledigung auszuprobieren, bevor sie eingeschaltet werden. Im Gegenzug sparen Ingenieure Zeit bei Exams in der realen Welt.

Die Agenten haben ein Gespür dafür, wie alltägliche Orte aussehen sollen, weil sie jeweils auf ein multimodales System namens Imaginative and prescient-Language-Modell (VLM) zurückgreifen, insbesondere auf das hochmoderne VLM GPT-5.2. Es wurde mit vielen Texten und Bildern aus dem Web trainiert, um mehr visuelle Eingabeaufforderungen verarbeiten zu können. Dieses fortschrittliche Modell vermittelt jedem Agenten eine Artwork räumliches Wissen: Zuerst generiert ein „Designer“-Agent die Elemente einer Szene, dann berät ein „Kritiker“, ob sie realistisch aussieht, und schließlich verwaltet ein „Orchestrator“ ihr Hin und Her und entscheidet, wann der Entwurf fertig ist. Sobald die drei VLMs ihre kreative Zusammenarbeit abgeschlossen haben, kann die Szene direkt in die Physiksimulationssoftware geladen werden.

„Wir haben herausgefunden, dass das System 3D-Szenen so konstruieren kann, wie es ein menschlicher Designer tun würde“, sagt Nicholas Pfaff, Doktorand am MIT EECS, CSAIL-Forscher und Hauptautor von a Papier mit Tedrake, der die Arbeit vorstellt. „Wir haben über 1.300 Szenen mit einem führenden VLM erstellt, der über Priorisierungen im Web-Maßstab verfügt, und er hat wahnsinnig kreative und vielfältige Preparations getroffen. Ich hatte dem System das nicht in den Eingabeaufforderungen beigebracht; es hat einfach improvisiert.“

Sprechen Sie mit meinem Agenten

Dank der VLM-Agenten können Sie SceneSmith bitten, Dinge wie „eine Storage mit einem Auto, einer Werkbank, in der Ecke gestapelten Reifen und einer Leiter an der Wand zu erstellen“ zu tun und einen virtuellen Spielplatz voller Objekte zu schaffen, an denen ein Roboter basteln kann. Diese Räume sind professional Szene mit bis zu sechsmal mehr Gegenständen dekoriert als bei früheren Methoden und eignen sich daher hervorragend, um Robotern dabei zu helfen, Fähigkeiten zu erlernen, z. B. eine Tasse in die Spüle zu stellen, Obst auf Teller zu legen und eine Getränkedose von einem Regal auf einen Tisch zu stellen.

Da Ihnen so viele umfangreiche virtuelle Umgebungen zur Verfügung stehen, können Sie ohne viel Versuch und Irrtum in der physischen Welt beurteilen, ob Ihr Roboter für den Einsatz bereit ist. Die Forscher testeten verschiedene Aktionspläne (auch „Richtlinien“ genannt) in den digitalen Welten von SceneSmith und generierten dabei 100 einzigartige Räume. Ein VLM-Agent bewertete jeden Versuch und stellte fest, dass die Pläne des Roboters fehlerhaft waren und die Maschine bei ihren Aufgaben oft versagte. Die Menschen stimmten den Urteilen des Modells in über 99 Prozent der Fälle zu, was Robotikern dabei helfen könnte, fehlerhafte Ansätze in der Simulation auszusortieren, bevor sich ein Roboter in der realen Welt bewegt.

Doch wie realistisch sind diese virtuellen Welten wirklich? Es kann schwierig sein, es eindeutig zu beweisen, daher näherten sich die Forscher der Frage aus mehreren Blickwinkeln. Der aussagekräftigste Check: Sie fügten eine vorab trainierte Roboterrichtlinie – einen KI-Controller, der weitgehend auf realen Daten trainiert wurde und noch nie eine SceneSmith-Szene gesehen hatte – in die generierten Umgebungen ein. In einem Check forderten Benutzer das System auf, „den Apfel aus der Schüssel zu nehmen und auf das Schneidebrett zu legen“, und der simulierte Roboter tat genau das. Wenn die Szenen nicht den realen Schauplätzen entsprochen hätten, aus denen die Politik gelernt hatte, hätte es einfach nicht funktioniert.

Das Group teleoperierte außerdem Roboter durch die virtuellen Räume und führte sie dabei, Schränke zu öffnen, Flaschen wegzuräumen und zwischen Räumen zu navigieren. Ihre Experimente zeigten, dass die Umgebungen einer anhaltenden physischen Interaktion standhalten und sich über die visuelle Inspektion hinaus ausdehnen.

Hinter den Kulissen

Die von SceneSmith verwendeten Agenten spielen jeweils eine genau definierte Rolle im Generierungsprozess und konkretisieren Szenen schrittweise. Sie erstellen im Wesentlichen einen Grundriss und erwecken ihn zum Leben.

Nehmen wir an, Sie möchten eine Szene erstellen, die dem ersten Inventory eines Hauses ähnelt. Der „Designer“-VLM würde mit einem allgemeinen Format beginnen, das vom „Kritiker“ überprüft und dann vom „Orchestrator“ abgesegnet wird. Die Agenten wiederholen diesen Ansatz für jeden Schritt: Hinzufügen von Möbeln, Platzieren von Objekten an Wänden und dann an Decken und schließlich Einfügen von Objekten, die Roboter manipulieren können. Beispielsweise können die VLMs Schränke hinzufügen, die die Roboter öffnen und schließen können – ein beweglicher Gegenstand, den frühere Basislinien nicht oft hatten.

In jeder Section stellt der zweite VLM sicher, dass die Szene praktisch ist, indem er beispielsweise darauf hinweist, dass eine Badewanne aus einem Wohnzimmer entfernt wird. Der dritte VLM stellt sicher, dass eine qualitativ hochwertige Szene generiert wird, und verzögert den Designprozess sogar um einige Umdrehungen, wenn die visuelle Darstellung nicht den Anforderungen entspricht. Sobald die drei VLMs ihre kreative Zusammenarbeit abgeschlossen haben, werden die Mechanismen der physischen Welt über eine Simulationssoftware hinzugefügt.

Mit einem fundierten Verständnis davon, wie Räume aussehen sollten, wo Objekte platziert werden sollten und der realen Physik, hat SceneSmith einen spürbaren Vorteil gegenüber früheren Methoden. Im Vergleich zu Basislinien zur Szenengenerierung wie „HSM“ Und „Holodeck„SceneSmith hat Umgebungen mit mehr Objekten erstellt, darunter ein privates Büro, ein Töpfergeschäft und sogar ein Spielzimmer im Minecraft-Stil.

SceneSmith battle auch bei über 200 Benutzern einer der Favoriten. Sie fanden, dass die visuelle Darstellung des Techniques in über 90 Prozent der Fälle realistischer battle. Sie stellten auch fest, dass es im Allgemeinen den Aufforderungen besser folgte als andere Ansätze. Mit anderen Worten: Es battle am besten geeignet, die virtuellen Spielplätze zu generieren, die die Benutzer tatsächlich sehen wollten.

Ein System mit vielen Talenten

Realismus, Vielfalt und Reichtum sind allesamt Stärken von SceneSmith, selbst wenn es um die Erstellung individueller 3D-Objekte geht. Sie können es auffordern, einen rollenden Servierwagen zu erstellen, und es erstellt ein 2D-Bild, das dann in ein detailliertes Modell mit physikalischen Eigenschaften wie Masse, Reibung und Trägheit umgewandelt wird.

Ein derart detaillierter Prozess geht jedoch mit einem Kompromiss bei der Geschwindigkeit einher. Die Erstellung einer einzelnen Szene kann mehrere Stunden dauern, da die Agenten jedes Objekt erstellen und genau prüfen. Mit mehr Rechenleistung könnte die Effizienz des Techniques dramatisch gesteigert werden. CSAIL-Ingenieure hoffen auch auf eine Ausweitung auf verformbare Objekte (wie Schwämme), falls umfangreiche 3D-Bibliotheken verfügbar werden.

„SceneSmith stellt in dieser Hinsicht einen erheblichen Fortschritt dar, indem es ein Agenten-Framework zur Generierung simulationsbereiter Innenumgebungen mit nur einer einfachen Texteingabe bereitstellt“, sagt Jeremy Binagia, ein angewandter Wissenschaftler bei Amazon Robotics, der nicht an der Forschung beteiligt battle. „Es bringt den Stand der Technik in mehrfacher Hinsicht voran, unter anderem indem es die Grenzen der Objektdichte in der simulierten Umgebung erweitert, sicherstellt, dass alle Objekte physisch korrekt sind (anstatt nur visuell realistisch zu sein) und Property erstellt, die nicht auf eine feste Bibliothek beschränkt sind, da sie über Textual content-zu-3D generiert werden können.“

Pfaff und Tedrake verfassten den Artikel zusammen mit Thomas Cohn SM ’24, einem MIT-Doktoranden und CSAIL-Forscher; und die Robotiker Sergey Zakharov und Rick Cory vom Toyota Analysis Institute SM ’08, PhD ’10. Ihre Arbeit wurde teilweise von Amazon, dem US Workplace of Naval Analysis, dem Toyota Analysis Institute und der US Nationwide Science Basis unterstützt.

Das Group präsentierte seine Ergebnisse letzte Woche im Rampenlicht auf der Worldwide Convention on Machine Studying.

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.

Folgen Sie MARKTECHPOST: Fügen Sie uns als bevorzugte Quelle bei Google hinzu.