Was wäre, wenn die KI-gestützte Codierung zuverlässiger würde, indem Produktplanung, technische Prüfung, Freigabe und Qualitätssicherung in verschiedene Betriebsmodi unterteilt würden? Das ist die Idee hinter Garry Tan gstackein Open-Supply-Toolkit, das Pakete erstellt Claude Code in 8 eigenwillige Workflow-Fähigkeiten, die von einer dauerhaften Browser-Laufzeit unterstützt werden. The takeit beschreibt sich selbst als „Acht eigenwillige Workflow-Fähigkeiten für Claude Code.“‚ und gruppiert allgemeine Softwarebereitstellungsaufgaben in verschiedene Modi wie Planung, Überprüfung, Versand, Browser-Automatisierung, QA-Exams und Retrospektiven. Das Ziel besteht nicht darin, Claude Code durch eine neue Modellebene zu ersetzen. Dadurch soll Claude Code bei der Produktplanung, der technischen Überprüfung, der Freigabe und beim Testen mit expliziteren Rollengrenzen arbeiten.

Die 8 Kernbefehle

Der gstack Das Repository stellt derzeit 8 Hauptbefehle bereit: /plan-ceo-review, /plan-eng-review, /evaluate, /ship, /browse, /qa, /setup-browser-cookiesUnd /retro. Jeder Befehl ist einem bestimmten Betriebsmodus zugeordnet. /plan-ceo-review ist als Planungsdurchlauf auf Produktebene positioniert. /plan-eng-review wird für Architektur, Datenfluss, Fehlermodi und Exams verwendet. /evaluate konzentriert sich auf Produktionsrisiken und Codeüberprüfung. /ship wird zum Vorbereiten eines fertigen Zweigs, zum Synchronisieren mit dem Hauptzweig, zum Ausführen von Exams und zum Öffnen eines PR verwendet. /browse gewährt dem Agenten Browserzugriff, whereas /qa ist für die systematische Prüfung betroffener Routen und Flüsse konzipiert. /setup-browser-cookies importiert Cookies von einem lokalen Browser in die Headless-Sitzung und /retro wird für technische Retrospektiven verwendet.

Der persistente Browser ist das Kernsystem

Der wichtigste technische Teil von gstack sind nicht die Markdown-Fähigkeiten. Es ist das Browser-Subsystem. gstack gibt Claude Code ein persistenter Browser und dass der Browser der schwierige Teil ist, während der Relaxation hauptsächlich Markdown ist. Anstatt für jede Aktion einen neuen Browser zu starten, führt gstack einen aus langlebiger kopfloser Chromium-Daemon und kommuniziert mit ihm über localhost HTTP. Der Grund ist Latenz und Zustandserhaltung. Ein Kaltstart kostet ca 3–5 Sekunden professional Werkzeugaufrufwährend nachfolgende Aufrufe nach dem Begin so konzipiert sind, dass sie ungefähr einlaufen 100–200 ms. Da der Browser am Leben bleibt, können Cookies, Tabs, localStorageund der Anmeldestatus bleiben über alle Befehle hinweg bestehen. Der Server wird danach auch automatisch heruntergefahren 30 Minuten Leerlaufzeit.

Wie gstack Browser-Automatisierung mit Qualitätssicherung verbindet

Diese Daemon-Architektur ist wichtig für die Qualitätssicherung und die browsergesteuerte Entwicklung. In vielen Agenten-Workflows ist die Browser-Automatisierung ein separater Debugging-Schritt oder ein Screenshot-Dienstprogramm. In gstack ist der Browserzugriff Teil des Kernworkflows. Das Repo beschreibt /browse als Modus, in dem sich der Agent anmelden, durch die App klicken, Screenshots machen und Schäden untersuchen kann. /qa baut darauf auf, indem es den Department-Diff analysiert, betroffene Routen identifiziert und die relevanten Seiten oder Flows testet. Der Beispielfluss im Repo zeigt /qa inspizieren 8 geänderte Dateien Und 3 betroffene Streckenund testen Sie diese Routen dann anhand einer lokalen App-Instanz. Das bedeutet, dass das Projekt versucht, Quelländerungen mit dem tatsächlichen Anwendungsverhalten zu verknüpfen, anstatt die Qualitätssicherung als separaten manuellen Durchgang zu behandeln.

Installationsanforderungen und Projektlayout

Die Implementierungsoptionen des Repositorys sind ebenfalls ziemlich spezifisch. gstack erfordert Claude Code, GitUnd Brötchen v1.0+. Der package deal.json zeigt die aktuelle Model als 0.3.3Pay attention Dramatiker Und diff als Laufzeitabhängigkeiten und kompiliert a browse ausführbar aus dem browse Quellbaum. Laut der README-Datei des Repos: /browse kompiliert eine native Binärdatei und wird unterstützt von macOS und Linuxfür beide x64 Und arm64. Der Installationsablauf kopiert das Repo in ~/.claude/expertise/gstackläuft ./setupund registriert die Fähigkeiten für Claude Code. Groups können dasselbe Setup auch in ein lokales Repository kopieren .claude/expertise/gstack Verzeichnis, damit der Workflow innerhalb eines Projekts geteilt wird.

Warum das Projekt Bun verwendet

Das Architekturdokument erklärt, warum das Projekt verwendet Brötchen anstelle eines konventionelleren Node.js-Setups. Es werden vier Gründe genannt: kompilierte Binärdateien, nativer SQLite-Zugriff, native TypeScript-Ausführung und ein integrierter HTTP-Server mit Bun.serve(). Diese Entscheidungen sind eher praktischer als kosmetischer Natur. gstack liest die SQLite-Cookie-Datenbank von Chromium direkt und die integrierte Datenbankunterstützung von Bun macht zusätzliche native Pakete überflüssig. Das kompilierte Binärmodell passt auch zum Installationsstil des Repos, da von Benutzern nicht erwartet wird, dass sie darin eine separate Laufzeit-Toolchain verwalten ~/.claude/expertise/.

Wichtige Erkenntnisse

• gstack ist eine Workflow-Ebene für Claude Code, kein neues Modell oder Agent-Framework. Es bündelt die Softwarebereitstellung in 8 eigenwilligen Slash-Command-Fähigkeiten für Planung, Überprüfung, Versand, Browser-Automatisierung, Qualitätssicherung, Cookie-Einrichtung und Retrospektiven.
• Der persistente Browser-Daemon ist die wichtigste technische Komponente. gstack führt einen langlebigen, kopflosen Chromium-Prozess über localhost HTTP aus, sodass Cookies, Tabs, localStorageund der Anmeldestatus bleiben über alle Befehle hinweg bestehen.
• Die Qualitätssicherung ist direkt mit Codeänderungen verbunden. Der /qa Der Workflow analysiert Zweigunterschiede, identifiziert betroffene Routen und testet die relevanten Anwendungspfade, anstatt Browserprüfungen als separaten manuellen Schritt zu behandeln.
• Aus systemtechnischen Gründen ist das Projekt rund um Bun aufgebaut. Bun wird für kompilierte Binärdateien, nativen SQLite-Zugriff, native TypeScript-Ausführung und einen integrierten HTTP-Server für den Browser-Daemon verwendet.
• Der Beitrag von gstack ist die Betriebsstruktur. Sein Hauptwert besteht darin, Produktüberprüfung, technische Überprüfung, Codeüberprüfung, Freigabe und browsergesteuerte Validierung in explizite Modi mit engen Verantwortlichkeiten zu unterteilen.

Kasse Repo hier. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 120.000+ ML SubReddit und Abonnieren Unser E-newsletter. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.

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.

Seit Ryan Kh Good Knowledge Collective übernommen hat, konzentriert sich der Weblog stärker darauf, wie Daten praktische Entscheidungen in öffentlichen Räumen wie Spielplätzen leiten können. Sie können diesen Wandel daran erkennen, wie Artikel Analysen mit alltäglichen Sicherheitsbedenken für Familien und Stadtplaner verbinden. Besonders hervorzuheben ist das wachsende Interesse daran, bei der Gestaltung von Orten, an denen Kinder spielen, auf fundierten Erkenntnissen und nicht auf Annahmen zu basieren. Dies ist nur eine der Möglichkeiten, wie wir das sehen können Vorteile von KI für die Sicherheit.

Ein Bericht der Huron Consulting Group zeigt, dass Unternehmen, die KI-gesteuerte Sicherheitstools einsetzen, eine Reduzierung der Arbeitsunfälle um 25 % gemeldet haben, obwohl sie KI-gestützte Sicherheitstools nutzen prädiktive Analytik kann schwere Verletzungen um bis zu 40 % reduzieren. Sie können eine klare Grenze zwischen diesen Ergebnissen und dem Potenzial ähnlicher Instruments zur Unterstützung einer sichereren Spielplatzplanung ziehen und weiterlesen, um mehr zu erfahren.

Datengesteuerte Ansätze für sicherere öffentliche Spielplätze

Das berichtet eine Studie von Frequent Sense Media quick ein Drittel der Befragten29 % gaben an, dass ihr Type KI für schulisches Lernen genutzt hat. Sie können sehen, wie der frühe Umgang mit Datentools die Erwartungen an Sicherheit und Verantwortlichkeit in gemeinsam genutzten Räumen beeinflusst. Es mehren sich die Anzeichen dafür, dass Eltern bei der Spielplatzgestaltung offener für datengestützte Entscheidungen sind. Im Folgenden werden Planer dazu aufgefordert, zu erklären, wie Zahlen Entscheidungen über Materialien, Layouts und Wartung beeinflussen.

Öffentliche Spielplätze gehören zu den wenigen Orten im Land, an denen alle in der Gemeinschaft zusammenkommen. An jedem Wochenendnachmittag treffen Sie Kleinkinder, Jugendliche, Betreuer und Nachbarn jeden Alters und jeder Gesellschaftsschicht. Was Sie wahrscheinlich nicht sehen oder erkennen, ist, dass öffentliche Spielplätze hinsichtlich des Betriebs erhebliche Herausforderungen mit sich bringen. Städte müssen sich auf Daten verlassen, die bei Inspektionen, Reparaturen, Verletzungen und der Erfüllung der Bedürfnisse der Gemeinde helfen.

Hier sehen Sie, wie Städte Daten nutzen, um genau das und noch mehr zu erreichen:

Echtzeitwartung

Was ein Echtzeit-Spielplatzprogramm ist, ist nicht nur ein schickes Dashboard, das die Wartung verfolgt. Dies ist eine Gelegenheit für Ihr Wartungsteam, Probleme schnell zu erkennen, die Groups effizient einzuleiten und dann zu notieren, was sie behoben haben. Städte beginnen in der Regel mit grundlegenden Betriebsmaßnahmen Daten wie Serviceanfrageprotokolle, cellular Arbeitsaufträge und Inspektionschecklisten. San Diego beispielsweise veröffentlicht seine „Get It Carried out“-Berichte als offene Daten, sodass die Bewohner nachverfolgen können, wie mit ihren Berichten umgegangen wurde.

Darüber hinaus können Städte eine Triage basierend auf Risiko und Auswirkungen durchführen und nicht nur darauf, wer am lautesten schreit. Stellen Sie sich zum Beispiel vor, dass zwei Spielplätze in derselben Stadt Aufmerksamkeit benötigen. Bei einem ist der Belag beschädigt, bei dem anderen ist die Financial institution kaputt. Eine Stadt kann Regeln festlegen, die der Sicherheit, stark genutzten Standorten und sich wiederholenden Problemen Priorität einräumen. Durch die Kombination von Echtzeitberichten mit dem Inspektionsverlauf können Städte außerdem erkennen, wo Probleme auftreten und wiederkehren. So können die Ursachen angegangen werden, statt sie zu wiederholen.

Vorausschauende Wartung und Sicherheit

Predictive Upkeep ist im Grunde wie Präventivmedizin. Sie möchten das Downside beheben, bevor es zu einem Downside wird, in diesem Fall zu einer Verletzung. Stürze sind die häufigste Verletzungsursache auf Spielplätzen. Und defekte oder beschädigte Ausrüstung kann eine Hauptursache für solche Stürze sein. Das sind mehr als nur hilfreiche Informationen. Es ist ein Einblick in das, was überwacht werden muss: lose {Hardware}, abgenutzte Oberflächen, kaputte Leitplanken und stark verschlissene Teile, wie Ihre Parkschaukel oder Anschlüsse.

Städte können diese Informationen und Erkenntnisse mithilfe der bereits gesammelten Daten in Vorhersagemodelle umwandeln. Sie können beispielsweise jedem Vermögenswert, wie Schaukeln, Rutschen oder Klettergeräten, eine Risikobewertung basierend auf Alter, Materials, Hitzeeinwirkung und mehr zuweisen. Von dort aus legen Sie die Inspektionshäufigkeiten entsprechend den Risiken fest. Anlagen mit hohem Risiko werden häufiger besucht, Anlagen mit geringerem Risiko benötigen lediglich Routinezyklen. Auf diese Weise müssen Sie nicht darauf warten, dass eine Oberfläche oder Schaukel unter die zulässige Leistung sinkt, sondern Sie planen bereits den Austausch.

Gerechtigkeit und Zugänglichkeit

Daten können auch hilfreich sein, indem sie verhindern, dass die „Qualität“ einer Nachbarschaft die Qualität eines Spielplatzes bestimmt. Auf städtischer Ebene werden Kennzahlen Ungleichheiten schnell sichtbar machen. Momentan, 76 % der Einwohner in ParkScore-Städten leben im Umkreis von 10 Gehminuten um einen Park. Das ist ein Allzeitrekord. Und die 100 bevölkerungsreichsten Städte haben 12,2 Milliarden US-Greenback in ihre Park- und Erholungssysteme investiert. Vor Ort können Sie sehen, welche Blöcke einen nahegelegenen Spielplatz haben, welche sichere Wege haben und vieles mehr.

Mithilfe von Daten können Städte erkennen, dass Barrierefreiheit weit mehr bedeutet als nur die Frage, ob es eine Rampe gibt. Sie können Inventar verwenden, das Merkmale kennzeichnet, die Familien tatsächlich benötigen, wie unter anderem barrierefreie Oberflächen, Transferplattformen und inklusive Schaukeln. Dann können Sie Upgrades dort priorisieren, wo Sie den größten Bedarf sehen, und nicht dort, wo die Befürworter am lautesten sind. Gerechtigkeit ist auch an die Instandhaltung gebunden: Wenn Parks unterfinanziert sind, stellt die aufgeschobene Instandhaltung ein Sicherheitsproblem dar. Wenn der Spielplatzplan jedoch Daten nutzt, ist es einfacher, Kapitalausgaben dort zu rechtfertigen, wo sie am meisten benötigt werden.

Nutzungsverfolgung und Verhaltensanalyse

Sicherere und effizientere Spielplätze durch Daten

In diesem Tutorial erstellen wir einen selbstverifizierenden DataOps AIAgent, der Datenoperationen mithilfe lokaler Hugging Face-Modelle automatisch planen, ausführen und testen kann. Wir entwerfen den Agenten mit drei intelligenten Rollen: einem Planer, der eine Ausführungsstrategie erstellt, einem Executor, der Code mit Pandas schreibt und ausführt, und einem Tester, der die Ergebnisse auf Genauigkeit und Konsistenz validiert. Durch die lokale Verwendung des Phi-2-Modells von Microsoft in Google Colab stellen wir sicher, dass der Workflow effizient, reproduzierbar und datenschutzkonform bleibt, und demonstrieren gleichzeitig, wie LLMs komplexe Datenverarbeitungsaufgaben durchgängig automatisieren können. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

!pip set up -q transformers speed up bitsandbytes scipy
import json, pandas as pd, numpy as np, torch
from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline, BitsAndBytesConfig


MODEL_NAME = "microsoft/phi-2"


class LocalLLM:
   def __init__(self, model_name=MODEL_NAME, use_8bit=False):
       print(f"Loading mannequin: {model_name}")
       self.tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
       if self.tokenizer.pad_token is None:
           self.tokenizer.pad_token = self.tokenizer.eos_token
       model_kwargs = {"device_map": "auto", "trust_remote_code": True}
       if use_8bit and torch.cuda.is_available():
           model_kwargs("quantization_config") = BitsAndBytesConfig(load_in_8bit=True)
       else:
           model_kwargs("torch_dtype") = torch.float32 if not torch.cuda.is_available() else torch.float16
       self.mannequin = AutoModelForCausalLM.from_pretrained(model_name, **model_kwargs)
       self.pipe = pipeline("text-generation", mannequin=self.mannequin, tokenizer=self.tokenizer,
                            max_new_tokens=512, do_sample=True, temperature=0.3, top_p=0.9,
                            pad_token_id=self.tokenizer.eos_token_id)
       print("✓ Mannequin loaded efficiently!n")


   def generate(self, immediate, system_prompt="", temperature=0.3):
       if system_prompt:
           full_prompt = f"Instruct: {system_prompt}nn{immediate}nOutput:"
       else:
           full_prompt = f"Instruct: {immediate}nOutput:"
       output = self.pipe(full_prompt, temperature=temperature, do_sample=temperature>0,
                          return_full_text=False, eos_token_id=self.tokenizer.eos_token_id)
       outcome = output(0)('generated_text').strip()
       if "Instruct:" in outcome:
           outcome = outcome.break up("Instruct:")(0).strip()
       return outcome

Wir installieren die erforderlichen Bibliotheken und laden das Phi-2-Modell lokal mithilfe von Hugging Face Transformers. Wir erstellen eine LocalLLM-Klasse, die den Tokenizer und das Modell initialisiert, optionale Quantisierung unterstützt und eine Generiermethode definiert, um Textausgaben zu erzeugen. Wir stellen sicher, dass das Modell sowohl auf der CPU als auch auf der GPU reibungslos läuft, sodass es sich superb für den Einsatz auf Colab eignet. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

PLANNER_PROMPT = """You're a Information Operations Planner. Create an in depth execution plan as legitimate JSON.


Return ONLY a JSON object (no different textual content) with this construction:
{"steps": ("step 1","step 2"),"expected_output":"description","validation_criteria":("standards 1","standards 2")}"""


EXECUTOR_PROMPT = """You're a Information Operations Executor. Write Python code utilizing pandas.


Necessities:
- Use pandas (imported as pd) and numpy (imported as np)
- Retailer remaining end in variable 'outcome'
- Return ONLY Python code, no explanations or markdown"""


TESTER_PROMPT = """You're a Information Operations Tester. Confirm execution outcomes.


Return ONLY a JSON object (no different textual content) with this construction:
{"handed":true,"points":("any points discovered"),"suggestions":("recommendations")}"""


class DataOpsAgent:
   def __init__(self, llm=None):
       self.llm = llm or LocalLLM()
       self.historical past = ()


   def _extract_json(self, textual content):
       strive:
           return json.hundreds(textual content)
       besides:
           begin, finish = textual content.discover('{'), textual content.rfind('}')+1
           if begin >= 0 and finish > begin:
               strive:
                   return json.hundreds(textual content(begin:finish))
               besides:
                   cross
       return None

Wir definieren die Systemeingabeaufforderungen für die Rollen Planner, Executor und Tester unseres DataOps-Agenten. Anschließend initialisieren wir die DataOpsAgent-Klasse mit Hilfsmethoden und einem JSON-Extraktionsdienstprogramm, um strukturierte Antworten zu analysieren. Wir bereiten die Grundlage für die Argumentations- und Ausführungspipeline des Agenten. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

 def plan(self, process, data_info):
       print("n" + "="*60)
       print("PHASE 1: PLANNING")
       print("="*60)
       immediate = f"Activity: {process}nnData Info:n{data_info}nnCreate an execution plan as JSON with steps, expected_output, and validation_criteria."
       plan_text = self.llm.generate(immediate, PLANNER_PROMPT, temperature=0.2)
       self.historical past.append(("PLANNER", plan_text))
       plan = self._extract_json(plan_text) or {"steps":(process),"expected_output":"Processed knowledge","validation_criteria":("Consequence generated","No errors")}
       print(f"n Plan Created:")
       print(f"  Steps: {len(plan.get('steps', ()))}")
       for i, step in enumerate(plan.get('steps', ()), 1):
           print(f"    {i}. {step}")
       print(f"  Anticipated: {plan.get('expected_output', 'N/A')}")
       return plan


   def execute(self, plan, data_context):
       print("n" + "="*60)
       print("PHASE 2: EXECUTION")
       print("="*60)
       steps_text="n".be a part of(f"{i}. {s}" for i, s in enumerate(plan.get('steps', ()), 1))
       immediate = f"Activity Steps:n{steps_text}nnData out there: DataFrame 'df'n{data_context}nnWrite Python code to execute these steps. Retailer remaining end in 'outcome' variable."
       code = self.llm.generate(immediate, EXECUTOR_PROMPT, temperature=0.1)
       self.historical past.append(("EXECUTOR", code))
       if "```python" in code: code = code.break up("```python")(1).break up("```")(0)
       elif "```" in code: code = code.break up("```")(1).break up("```")(0)
       traces = ()
       for line in code.break up('n'):
           s = line.strip()
           if s and (not s.startswith('#') or 'import' in s):
               traces.append(line)
       code="n".be a part of(traces).strip()
       print(f"n Generated Code:n" + "-"*60)
       for i, line in enumerate(code.break up('n')(:15),1):
           print(f"{i:2}. {line}")
       if len(code.break up('n'))>15: print(f"    ... ({len(code.break up('n'))-15} extra traces)")
       print("-"*60)
       return code

Wir implementieren die Planungs- und Ausführungsphasen des Agenten. Wir lassen den Planer detaillierte Aufgabenschritte und Validierungskriterien erstellen, und dann generiert der Ausführende den entsprechenden Python-Code basierend auf Pandas, um die Aufgabe auszuführen. Wir visualisieren, wie der Agent autonom von der Argumentation zur Generierung umsetzbaren Codes übergeht. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

def check(self, plan, outcome, execution_error=None):
       print("n" + "="*60)
       print("PHASE 3: TESTING & VERIFICATION")
       print("="*60)
       result_desc = f"EXECUTION ERROR: {execution_error}" if execution_error else f"Consequence kind: {kind(outcome).__name__}n"
       if not execution_error:
           if isinstance(outcome, pd.DataFrame):
               result_desc += f"Form: {outcome.form}nColumns: {checklist(outcome.columns)}nSample:n{outcome.head(3).to_string()}"
           elif isinstance(outcome, (int,float,str)):
               result_desc += f"Worth: {outcome}"
           else:
               result_desc += f"Worth: {str(outcome)(:200)}"
       criteria_text="n".be a part of(f"- {c}" for c in plan.get('validation_criteria', ()))
       immediate = f"Validation Standards:n{criteria_text}nnExpected: {plan.get('expected_output', 'N/A')}nnActual Consequence:n{result_desc}nnEvaluate if outcome meets standards. Return JSON with handed (true/false), points, and suggestions."
       test_result = self.llm.generate(immediate, TESTER_PROMPT, temperature=0.2)
       self.historical past.append(("TESTER", test_result))
       test_json = self._extract_json(test_result) or {"handed":execution_error is None,"points":("Couldn't parse check outcome"),"suggestions":("Overview manually")}
       print(f"n✓ Check Outcomes:n  Standing: {' PASSED' if test_json.get('handed') else ' FAILED'}")
       if test_json.get('points'):
           print("  Points:")
           for problem in test_json('points')(:3):
               print(f"    • {problem}")
       if test_json.get('suggestions'):
           print("  Suggestions:")
           for rec in test_json('suggestions')(:3):
               print(f"    • {rec}")
       return test_json


   def run(self, process, df=None, data_info=None):
       print("n SELF-VERIFYING DATA-OPS AGENT (Native HF Mannequin)")
       print(f"Activity: {process}n")
       if data_info is None and df is just not None:
           data_info = f"Form: {df.form}nColumns: {checklist(df.columns)}nSample:n{df.head(2).to_string()}"
       plan = self.plan(process, data_info)
       code = self.execute(plan, data_info)
       outcome, error = None, None
       strive:
           local_vars = {'pd': pd, 'np': np, 'df': df}
           exec(code, local_vars)
           outcome = local_vars.get('outcome')
       besides Exception as e:
           error = str(e)
           print(f"n  Execution Error: {error}")
       test_result = self.check(plan, outcome, error)
       return {'plan': plan,'code': code,'outcome': outcome,'check': test_result,'historical past': self.historical past}

Wir konzentrieren uns auf die Check- und Verifizierungsphase unseres Workflows. Wir lassen den Agenten seine eigene Ausgabe anhand vordefinierter Validierungskriterien bewerten und das Ergebnis als strukturiertes JSON zusammenfassen. Anschließend integrieren wir alle drei Phasen, Planung, Ausführung und Check, in einer einzigen selbstverifizierenden Pipeline, die eine vollständige Automatisierung gewährleistet. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

def demo_basic(agent):
   print("n" + "#"*60)
   print("# DEMO 1: Gross sales Information Aggregation")
   print("#"*60)
   df = pd.DataFrame({'product':('A','B','A','C','B','A','C'),
                      'gross sales':(100,150,200,80,130,90,110),
                      'area':('North','South','North','East','South','West','East')})
   process = "Calculate whole gross sales by product"
   output = agent.run(process, df)
   if output('outcome') is just not None:
       print(f"n Closing Consequence:n{output('outcome')}")
   return output


def demo_advanced(agent):
   print("n" + "#"*60)
   print("# DEMO 2: Buyer Age Evaluation")
   print("#"*60)
   df = pd.DataFrame({'customer_id':vary(1,11),
                      'age':(25,34,45,23,56,38,29,41,52,31),
                      'purchases':(5,12,8,3,15,7,9,11,6,10),
                      'spend':(500,1200,800,300,1500,700,900,1100,600,1000)})
   process = "Calculate common spend by age group: younger (underneath 35) and mature (35+)"
   output = agent.run(process, df)
   if output('outcome') is just not None:
       print(f"n Closing Consequence:n{output('outcome')}")
   return output


if __name__ == "__main__":
   print(" Initializing Native LLM...")
   print("Utilizing CPU mode for optimum compatibilityn")
   strive:
       llm = LocalLLM(use_8bit=False)
       agent = DataOpsAgent(llm)
       demo_basic(agent)
       print("nn")
       demo_advanced(agent)
       print("n" + "="*60)
       print(" Tutorial Full!")
       print("="*60)
       print("nKey Options:")
       print("  • 100% Native - No API calls required")
       print("  • Makes use of Phi-2 from Microsoft (2.7B params)")
       print("  • Self-verifying 3-phase workflow")
       print("  • Runs on free Google Colab CPU/GPU")
   besides Exception as e:
       print(f"n Error: {e}")
       print("Troubleshooting:n1. pip set up -q transformers speed up scipyn2. Restart runtimen3. Attempt a distinct mannequin")

Wir haben zwei Demobeispiele erstellt, um die Fähigkeiten des Agenten anhand einfacher Verkaufs- und Kundendatensätze zu testen. Wir initialisieren das Modell, führen den Information-Ops-Workflow aus und beobachten den gesamten Zyklus von der Planung bis zur Validierung. Wir schließen das Tutorial mit einer Zusammenfassung der wichtigsten Vorteile ab und ermutigen zu weiteren Experimenten mit lokalen Modellen.

Zusammenfassend haben wir ein vollständig autonomes und selbstverifizierendes DataOps-System erstellt, das auf einem lokalen Hugging Face-Modell basiert. Wir erleben, wie jede Part – Planung, Ausführung und Exams – nahtlos zusammenwirkt, um zuverlässige Ergebnisse zu erzielen, ohne auf Cloud-APIs angewiesen zu sein. Dieser Workflow unterstreicht die Stärke lokaler LLMs wie Phi-2 für eine leichte Automatisierung und inspiriert uns, diese Architektur in Zukunft für fortschrittlichere Datenpipelines, Validierungsframeworks und Multi-Agenten-Datensysteme zu erweitern.

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 Publication. 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.