MIT-Forscher haben einen auf generativer künstlicher Intelligenz basierenden Ansatz zur Planung langfristiger visueller Aufgaben wie der Roboternavigation entwickelt, der etwa doppelt so effektiv ist wie einige bestehende Techniken.

Ihre Methode nutzt ein spezielles Imaginative and prescient-Sprach-Modell, um das Szenario in einem Bild wahrzunehmen und die zum Erreichen eines Ziels erforderlichen Aktionen zu simulieren. Anschließend übersetzt ein zweites Modell diese Simulationen in eine Standardprogrammiersprache für Planungsprobleme und verfeinert die Lösung.

Am Ende generiert das System automatisch eine Reihe von Dateien, die in klassische Planungssoftware eingespeist werden können, die einen Plan zur Zielerreichung berechnet. Dieses zweistufige System generierte Pläne mit einer durchschnittlichen Erfolgsquote von etwa 70 Prozent und übertraf damit die besten Basismethoden, die nur etwa 30 Prozent erreichen konnten.

Wichtig ist, dass das System neue Probleme lösen kann, auf die es bisher noch nicht gestoßen ist, wodurch es sich intestine für reale Umgebungen eignet, in denen sich die Bedingungen jederzeit ändern können.

„Unser Framework kombiniert die Vorteile von Imaginative and prescient-Language-Modellen, wie ihre Fähigkeit, Bilder zu verstehen, mit den starken Planungsfähigkeiten eines formalen Lösers“, sagt Yilun Hao, ein Doktorand der Luft- und Raumfahrttechnik (AeroAstro) am MIT und Hauptautor einer Open-Entry-Artikel zu dieser Technik. „Es kann ein einzelnes Bild aufnehmen und es durch Simulation weiterleiten und dann zu einem zuverlässigen, langfristigen Plan führen, der in vielen realen Anwendungen nützlich sein könnte.“

Sie wird bei dem Artikel von Yongchao Chen unterstützt, einem Doktoranden am MIT Laboratory for Info and Determination Methods (LIDS); Chuchu Fan, außerordentlicher Professor bei AeroAstro und leitender Forscher bei LIDS; und Yang Zhang, Forschungswissenschaftler am MIT-IBM Watson AI Lab. Das Papier wird auf der Worldwide Convention on Studying Representations vorgestellt.

Visuelle Aufgaben bewältigen

In den letzten Jahren haben Fan und ihre Kollegen den Einsatz generativer KI-Modelle zur Durchführung komplexer Überlegungen und Planungen untersucht und dabei häufig große Sprachmodelle (LLMs) zur Verarbeitung von Texteingaben eingesetzt.

Viele reale Planungsprobleme, wie die Robotermontage und das autonome Fahren, erfordern visuelle Eingaben, die ein LLM allein nicht intestine bewältigen kann. Die Forscher versuchten, in den visuellen Bereich vorzudringen, indem sie Imaginative and prescient-Language-Modelle (VLMs) nutzten, leistungsstarke KI-Systeme, die Bilder und Textual content verarbeiten können.

VLMs haben jedoch Schwierigkeiten, die räumlichen Beziehungen zwischen Objekten in einer Szene zu verstehen, und können bei vielen Schritten oft nicht richtig argumentieren. Dies erschwert den Einsatz von VLMs für eine langfristige Planung.

Andererseits haben Wissenschaftler robuste, formale Planer entwickelt, die effektive Langzeitpläne für komplexe Situationen erstellen können. Allerdings können diese Softwaresysteme keine visuellen Eingaben verarbeiten und erfordern Expertenwissen, um ein Drawback in eine Sprache zu kodieren, die der Löser verstehen kann.

Fan und ihr Staff haben ein automatisches Planungssystem entwickelt, das das Beste aus beiden Methoden vereint. Das als VLM-geführte formale Planung (VLMFP) bezeichnete System nutzt zwei spezialisierte VLMs, die zusammenarbeiten, um visuelle Planungsprobleme in gebrauchsfertige Dateien für formale Planungssoftware umzuwandeln.

Die Forscher trainierten zunächst sorgfältig ein kleines Modell, das sie SimVLM nennen, um sich darauf zu spezialisieren, das Szenario in einem Bild mithilfe natürlicher Sprache zu beschreiben und eine Abfolge von Aktionen in diesem Szenario zu simulieren. Dann verwendet ein viel größeres Modell, das sie GenVLM nennen, die Beschreibung von SimVLM, um einen Satz anfänglicher Dateien in einer formalen Planungssprache zu generieren, die als Planning Area Definition Language (PDDL) bekannt ist.

Die Dateien können nun in einen klassischen PDDL-Löser eingespeist werden, der einen Schritt-für-Schritt-Plan zur Lösung der Aufgabe berechnet. GenVLM vergleicht die Ergebnisse des Solvers mit denen des Simulators und verfeinert die PDDL-Dateien iterativ.

„Der Generator und der Simulator arbeiten zusammen, um genau das gleiche Ergebnis zu erzielen, nämlich eine Aktionssimulation, die das Ziel erreicht“, sagt Hao.

Da GenVLM ein großes generatives KI-Modell ist, hat es während des Trainings viele Beispiele von PDDL gesehen und gelernt, wie diese formale Sprache eine Vielzahl von Problemen lösen kann. Dieses vorhandene Wissen ermöglicht es dem Modell, genaue PDDL-Dateien zu generieren.

Ein flexibler Ansatz

VLMFP generiert zwei separate PDDL-Dateien. Die erste ist eine Domänendatei, die die Umgebung, gültige Aktionen und Domänenregeln definiert. Außerdem wird eine Problemdatei erstellt, die den Ausgangszustand und das Ziel eines bestimmten Issues definiert.

„Ein Vorteil von PDDL besteht darin, dass die Domänendatei für alle Instanzen in dieser Umgebung gleich ist. Dadurch ist unser Framework intestine in der Lage, auf unsichtbare Instanzen unter derselben Domäne zu verallgemeinern“, erklärt Hao.

Um eine effektive Verallgemeinerung des Methods zu ermöglichen, mussten die Forscher sorgfältig gerade genug Trainingsdaten für SimVLM entwerfen, damit das Modell lernte, das Drawback und das Ziel zu verstehen, ohne sich Muster im Szenario zu merken. Beim Testen beschrieb SimVLM erfolgreich das Szenario, simulierte Aktionen und erkannte in etwa 85 Prozent der Experimente, ob das Ziel erreicht wurde.

Insgesamt erreichte das VLMFP-Framework eine Erfolgsquote von etwa 60 Prozent bei sechs 2D-Planungsaufgaben und mehr als 80 Prozent bei zwei 3D-Aufgaben, einschließlich Multiroboter-Kollaboration und Robotermontage. Es generierte außerdem gültige Pläne für mehr als 50 Prozent der Szenarien, die es zuvor noch nicht gesehen hatte, und übertraf damit die Basismethoden bei weitem.

„Unser Framework kann verallgemeinern, wenn sich die Regeln in verschiedenen Situationen ändern. Dies gibt unserem System die Flexibilität, viele Arten visueller Planungsprobleme zu lösen“, fügt Fan hinzu.

Zukünftig möchten die Forscher VLMFP in die Lage versetzen, komplexere Szenarien zu bewältigen und Methoden zur Identifizierung und Linderung von Halluzinationen durch die VLMs zu erforschen.

„Langfristig könnten generative KI-Modelle als Agenten fungieren und die richtigen Werkzeuge nutzen, um viel kompliziertere Probleme zu lösen. Aber was bedeutet es, über die richtigen Werkzeuge zu verfügen, und wie integrieren wir diese Werkzeuge? Es liegt noch ein weiter Weg vor uns, aber indem wir die visuelle Planung ins Spiel bringen, ist diese Arbeit ein wichtiger Teil des Puzzles“, sagt Fan.

Diese Arbeit wurde teilweise vom MIT-IBM Watson AI Lab finanziert.

Das Florence-2-Modell und ein Beispielbild werden geladen

Nach der Set up und dem Import der erforderlichen Bibliotheken (wie im beigefügten Colab-Notizbuch gezeigt) beginnen wir mit dem Laden des Florence-2-Modells, des Prozessors und des Eingabebilds einer Kamera:

#Load mannequin:
model_id = ‘microsoft/Florence-2-large’
mannequin = AutoModelForCausalLM.from_pretrained(model_id, trust_remote_code=True, torch_dtype='auto').eval().cuda()
processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)
#Load picture:
picture = Picture.open(img_path)

Hilfsfunktionen

In diesem Tutorial werden wir mehrere Hilfsfunktionen verwenden. Das Wichtigste ist das run_example Kernfunktion, die eine Antwort aus dem Florence-2-Modell generiert.

Der run_example Die Funktion kombiniert die Aufgabenaufforderung mit allen zusätzlichen Texteingaben (falls vorhanden) in einer einzigen Eingabeaufforderung. Mit der processorgeneriert es Textual content- und Bildeinbettungen, die als Eingaben für das Modell dienen. Die Magie geschieht während des mannequin.generate Schritt, in dem die Antwort des Modells generiert wird. Hier ist eine Aufschlüsselung einiger wichtiger Parameter:

• max_new_tokens=1024: Legt die maximale Länge der Ausgabe fest und ermöglicht detaillierte Antworten.
• do_sample=Falsch: Gewährleistet eine deterministische Reaktion.
• num_beams=3: Implementiert die Strahlsuche mit den drei wahrscheinlichsten Token bei jedem Schritt und untersucht mehrere potenzielle Sequenzen, um die beste Gesamtausgabe zu finden.
• Early_stopping=False: Stellt sicher, dass die Strahlsuche fortgesetzt wird, bis alle Strahlen die maximale Länge erreichen oder ein Ende-der-Sequenz-Token generiert wird.

Abschließend wird die Ausgabe des Modells dekodiert und mit nachbearbeitet processor.batch_decode Und processor.post_process_generation um die endgültige Textantwort zu erstellen, die von zurückgegeben wird run_example Funktion.

def run_example(picture, task_prompt, text_input=''):
immediate = task_prompt + text_input
inputs = processor(textual content=immediate, photos=picture, return_tensors=”pt”).to(‘cuda’, torch.float16)
generated_ids = mannequin.generate(
input_ids=inputs(“input_ids”).cuda(),
pixel_values=inputs(“pixel_values”).cuda(),
max_new_tokens=1024,
do_sample=False,
num_beams=3,
early_stopping=False,
)
generated_text = processor.batch_decode(generated_ids, skip_special_tokens=False)(0)
parsed_answer = processor.post_process_generation(
generated_text,
job=task_prompt,
image_size=(picture.width, picture.top)
)
return parsed_answer

Zusätzlich nutzen wir Hilfsfunktionen zur Visualisierung der Ergebnisse (draw_bbox ,draw_ocr_bboxes Und draw_polygon) und übernimmt die Konvertierung zwischen Begrenzungsrahmenformaten (convert_bbox_to_florence-2 Und convert_florence-2_to_bbox). Diese können im beigefügten Colab-Notizbuch erkundet werden.

Florence-2 kann eine Vielzahl visueller Aufgaben erfüllen. Lassen Sie uns einige seiner Funktionen erkunden, beginnend mit der Bildunterschrift.

1. Aufgaben im Zusammenhang mit der Untertitelgenerierung:

1.1 Untertitel generieren

Florence-2 kann Bildunterschriften mit verschiedenen Detaillierungsebenen erstellen '<CAPTION>' , '<DETAILED_CAPTION>' oder '<MORE_DETAILED_CAPTION>' Aufgabenaufforderungen.

print (run_example(picture, task_prompt='<CAPTION>'))
# Output: 'A black digicam sitting on high of a wood desk.'
print (run_example(picture, task_prompt='<DETAILED_CAPTION>'))
# Output: 'The picture reveals a black Kodak V35 35mm movie digicam sitting on high of a wood desk with a blurred background.'
print (run_example(picture, task_prompt='<MORE_DETAILED_CAPTION>'))
# Output: 'The picture is a close-up of a Kodak VR35 digital digicam. The digicam is black in colour and has the Kodak brand on the highest left nook. The physique of the digicam is manufactured from wooden and has a textured grip for simple dealing with. The lens is within the heart of the physique and is surrounded by a gold-colored ring. On the highest proper nook, there's a small LCD display and a flash. The background is blurred, nevertheless it seems to be a wooded space with timber and greenery.'

Das Modell beschreibt das Bild und seine Umgebung genau. Es identifiziert sogar die Marke und das Modell der Kamera und demonstriert so deren OCR-Fähigkeit. Allerdings in der '<MORE_DETAILED_CAPTION>' Aufgabe gibt es geringfügige Inkonsistenzen, was von einem Zero-Shot-Modell zu erwarten ist.

1.2 Generieren Sie eine Beschriftung für einen bestimmten Begrenzungsrahmen

Florence-2 kann Beschriftungen für bestimmte Bereiche eines Bildes generieren, die durch Begrenzungsrahmen definiert sind. Hierzu wird die Place des Begrenzungsrahmens als Eingabe verwendet. Sie können die Kategorie mit extrahieren '<REGION_TO_CATEGORY>' oder eine Beschreibung mit '<REGION_TO_DESCRIPTION>' .

Zur Vereinfachung habe ich dem Colab-Notizbuch ein Widget hinzugefügt, mit dem Sie einen Begrenzungsrahmen auf dem Bild zeichnen und es mit Code in das Florence-2-Format konvertieren können.

task_prompt = '<REGION_TO_CATEGORY>'
box_str = '<loc_335><loc_412><loc_653><loc_832>'
outcomes = run_example(picture, task_prompt, text_input=box_str)
# Output: 'digicam lens'

task_prompt = '<REGION_TO_DESCRIPTION>'
box_str = '<loc_335><loc_412><loc_653><loc_832>'
outcomes = run_example(picture, task_prompt, text_input=box_str)
# Output: 'digicam'

In diesem Fall ist die '<REGION_TO_CATEGORY>' identifizierte das Objektiv, während die '<REGION_TO_DESCRIPTION>' battle weniger konkret. Diese Leistung kann jedoch je nach Bild variieren.

2. Aufgaben im Zusammenhang mit der Objekterkennung:

2.1 Begrenzungsrahmen und Textual content für Objekte generieren

Florence-2 kann dicht gepackte Bereiche im Bild identifizieren und ihre Begrenzungsrahmenkoordinaten sowie die zugehörigen Beschriftungen oder Beschriftungen bereitstellen. Um Begrenzungsrahmen mit Beschriftungen zu extrahieren, verwenden Sie die ’<OD>’Aufgabenaufforderung:

outcomes = run_example(picture, task_prompt='<OD>')
draw_bbox(picture, outcomes('<OD>'))

Um Begrenzungsrahmen mit Beschriftungen zu extrahieren, verwenden Sie '<DENSE_REGION_CAPTION>' Aufgabenaufforderung:

task_prompt outcomes = run_example(picture, task_prompt= '<DENSE_REGION_CAPTION>')
draw_bbox(picture, outcomes('<DENSE_REGION_CAPTION>'))

2.2 Erkennung geerdeter Objekte mit Textual content

Florence-2 kann auch eine textbasierte Objekterkennung durchführen. Durch die Bereitstellung spezifischer Objektnamen oder Beschreibungen als Eingabe erkennt Florence-2 Begrenzungsrahmen um die angegebenen Objekte.

task_prompt = '<CAPTION_TO_PHRASE_GROUNDING>'
outcomes = run_example(picture,task_prompt, text_input=”lens. digicam. desk. brand. flash.”)
draw_bbox(picture, outcomes('<CAPTION_TO_PHRASE_GROUNDING>'))

3. Segmentierungsbezogene Aufgaben:

Florence-2 kann auch textbasierte Segmentierungspolygone generieren ('<REFERRING_EXPRESSION_SEGMENTATION>') oder durch Begrenzungsrahmen ('<REGION_TO_SEGMENTATION>'):

outcomes = run_example(picture, task_prompt='<REFERRING_EXPRESSION_SEGMENTATION>', text_input=”digicam”)
draw_polygons(picture, outcomes(task_prompt))

outcomes = run_example(picture, task_prompt='<REGION_TO_SEGMENTATION>', text_input="<loc_345><loc_417><loc_648><loc_845>")
draw_polygons(output_image, outcomes('<REGION_TO_SEGMENTATION>'))

4. OCR-bezogene Aufgaben:

Florence-2 weist starke OCR-Fähigkeiten auf. Es kann mit dem Textual content aus einem Bild extrahieren '<OCR>' Process-Eingabeaufforderung und extrahieren Sie sowohl den Textual content als auch seinen Speicherort mit '<OCR_WITH_REGION>' :

outcomes = run_example(picture,task_prompt)
draw_ocr_bboxes(picture, outcomes('<OCR_WITH_REGION>'))

Florence-2 ist ein vielseitiges Imaginative and prescient-Language-Modell (VLM), das mehrere Sehaufgaben innerhalb eines einzigen Modells bewältigen kann. Seine Zero-Shot-Fähigkeiten sind bei verschiedenen Aufgaben wie Bildunterschrift, Objekterkennung, Segmentierung und OCR beeindruckend. Während Florence-2 sofort eine gute Leistung erbringt, kann eine zusätzliche Feinabstimmung das Modell weiter an neue Aufgaben anpassen oder seine Leistung bei einzigartigen, benutzerdefinierten Datensätzen verbessern.