Forscher der Stanford College haben veröffentlicht Öffnen Sie Jarvisein Open-Supply-Framework zum Erstellen persönlicher Agenten für künstliche Intelligenz, die vollständig auf dem Gerät ausgeführt werden.

Das Framework zielt darauf ab, Latenz, wiederkehrende Kosten und Bedenken hinsichtlich der Datenexposition im Zusammenhang mit Cloud-basierten KI-Lösungen zu reduzieren, indem die lokale Ausführung priorisiert wird. Dieser Ansatz positioniert lokale KI als Customary, wobei die Cloud-Nutzung zu einer optionalen Komponente wird.

OpenJarvis stammt aus dem Scaling Intelligence Lab von Stanford. Es fungiert sowohl als Forschungsplattform als auch als Bereitstellungsinfrastruktur für lokale KI-Systeme.

Das Projekt legt den Schwerpunkt auf den gesamten Software program-Stack, der für On-Gadget-Agenten erforderlich ist, einschließlich Benutzerfreundlichkeit, Messung und langfristige Anpassungsfähigkeit. Die Studie zitiert die frühere Arbeit „Intelligence Per Watt“, die ergab, dass lokale Sprachmodelle 88,7 % der Chat- und Argumentationsanfragen mit interaktiven Latenzen verarbeiten können. Nach Angaben des Groups hat sich die Effizienz zwischen 2023 und 2025 um das 5,3-fache verbessert.

OpenJarvis verwendet eine „5-Primitives“-Architektur: Intelligenz, Engine, Agenten, Instruments & Speicher und Lernen. Diese Grundelemente fungieren als zusammensetzbare Abstraktionen für unabhängiges Benchmarking und Optimierung.

Das Intelligence-Grundelement fungiert als Modellebene und stellt einen einheitlichen Katalog für verschiedene lokale Modellfamilien bereit. Diese Abstraktion ermöglicht es Entwicklern, Modelle auszuwählen, ohne die Parameteranzahl oder die {Hardware}-Passform manuell zu verfolgen.

Das Engine-Primitiv dient als Inferenzlaufzeit und bietet eine gemeinsame Schnittstelle für Backends wie Ollama, vLLM, SGLang, llama.cpp und Cloud-APIs. Es enthält Befehle wie „jarvis init“ zum Erkennen von {Hardware} und Empfehlen von Konfigurationen sowie „jarvis physician“ für die Wartung.

Das Agenten-Grundelement bildet die Verhaltensschicht und übersetzt Modellfunktionen in strukturierte Aktionen unter Geräteeinschränkungen. Es unterstützt zusammensetzbare Rollen, einschließlich eines Orchestrators für die Aufgabenaufteilung und eines Agenten für persönliche Arbeitsabläufe.

Das Grundelement „Instruments & Speicher“ bildet die Erdungsschicht. Dazu gehört die Unterstützung von MCP (Mannequin Context Protocol) für die Instrument-Nutzung, Google A2A für die Agent-zu-Agent-Kommunikation und semantische Indexierung für den lokalen Abruf. Es verbindet auch lokale Modelle mit Instruments und einem dauerhaften persönlichen Kontext.

Das Lernprimitiv bietet einen Verbesserungsmechanismus mit geschlossenem Regelkreis. Es nutzt lokale Interaktionsspuren, um Trainingsdaten zu generieren, das Agentenverhalten zu verfeinern und die Modellauswahl zu verbessern. Die Optimierung erfolgt über Modellgewichtungen, LM-Eingabeaufforderungen, Agentenlogik und die Inferenz-Engine.

OpenJarvis priorisiert Effizienz und behandelt neben der Aufgabenqualität auch Energie, FLOPs, Latenz und Kosten als Haupteinschränkungen. Es beinhaltet ein hardwareunabhängiges Telemetriesystem zur Profilierung der Energie auf NVIDIA-GPUs, AMD-GPUs und Apple Silicon mit Abtastintervallen von 50 ms. Der Befehl „jarvis bench“ standardisiert das Benchmarking für Latenz, Durchsatz und Energie professional Abfrage.

Zu den Entwicklerschnittstellen für OpenJarvis gehören eine Browseranwendung, eine Desktopanwendung für macOS, Home windows und Linux, ein Python SDK und eine Befehlszeilenschnittstelle (CLI). Alle Kernfunktionen funktionieren ohne Netzwerkverbindung.

Der Befehl „jarvis servo“ startet einen FastAPI-Server mit SSE-Streaming, der nach Angaben der Entwickler als Drop-In-Ersatz für OpenAI-Purchasers dienen kann. Diese Funktion soll die Migrationskosten für Entwickler senken, die Prototypen mit einer API-förmigen Schnittstelle erstellen und gleichzeitig die lokale Inferenz beibehalten.

Hervorgehobener Bildnachweis

In diesem Tutorial führen wir den Prozess der Erstellung eines vollständig autonomen Flottenanalyseagenten mithilfe von SmolAgents und einem lokalen Qwen-Modell durch. Wir generieren Telemetriedaten, laden sie über ein benutzerdefiniertes Software und lassen unseren Agenten ohne externe API-Aufrufe Wartungsrisiken begründen, analysieren und visualisieren. Bei jedem Implementierungsschritt sehen wir, wie der Agent strukturierte Protokolle interpretiert, logische Filter anwendet, Anomalien erkennt und schließlich eine klare visuelle Warnung für Flottenmanager erstellt. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

print(" Putting in libraries... (approx 30-60s)")
!pip set up smolagents transformers speed up bitsandbytes ddgs matplotlib pandas -q


import os
import pandas as pd
import matplotlib.pyplot as plt
from smolagents import CodeAgent, Software, TransformersModel

Wir installieren alle erforderlichen Bibliotheken und importieren die Kernmodule, auf die wir für die Erstellung unseres Agenten angewiesen sind. Wir richten SmolAgents, Transformers und grundlegende Datenverarbeitungstools ein, um Telemetrie zu verarbeiten und das lokale Modell reibungslos auszuführen. In dieser Part bereiten wir unsere Umgebung vor und stellen sicher, dass alles korrekt geladen wird, bevor wir fortfahren. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

fleet_data = {
   "truck_id": ("T-101", "T-102", "T-103", "T-104", "T-105"),
   "driver": ("Ali", "Sara", "Mike", "Omar", "Jen"),
   "avg_speed_kmh": (65, 70, 62, 85, 60),
   "fuel_efficiency_kml": (3.2, 3.1, 3.3, 1.8, 3.4),
   "engine_temp_c": (85, 88, 86, 105, 84),
   "last_maintenance_days": (30, 45, 120, 200, 15)
}
df = pd.DataFrame(fleet_data)
df.to_csv("fleet_logs.csv", index=False)
print(" 'fleet_logs.csv' created.")

Wir generieren den Dummy-Flottendatensatz, den unser Agent später analysieren wird. Wir erstellen einen kleinen, aber realistischen Satz Telemetriefelder, konvertieren ihn in einen DataFrame und speichern ihn als CSV-Datei. Hier legen wir die Kerndatenquelle fest, die die Argumentation und Vorhersagen des Agenten vorantreibt. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

class FleetDataTool(Software):
   identify = "load_fleet_logs"
   description = "Masses car telemetry logs from 'fleet_logs.csv'. Returns the information abstract."
   inputs = {}
   output_type = "string"


   def ahead(self):
       strive:
           df = pd.read_csv("fleet_logs.csv")
           return f"Columns: {checklist(df.columns)}nData Pattern:n{df.to_string()}"
       besides Exception as e:
           return f"Error loading logs: {e}"

Wir definieren das FleetDataTool, das als Brücke zwischen dem Agenten und der zugrunde liegenden Telemetriedatei fungiert. Wir geben dem Agenten die Möglichkeit, die CSV-Datei zu laden und zu prüfen, um deren Struktur zu verstehen. Dieses Software bildet die Grundlage für jede weitere Analyse, die das Modell durchführt. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

print(" Downloading & Loading Native Mannequin (approx 60-90s)...")
mannequin = TransformersModel(
   model_id="Qwen/Qwen2.5-Coder-1.5B-Instruct",
   device_map="auto",
   max_new_tokens=2048
)
print(" Mannequin loaded on GPU.")


agent = CodeAgent(
   instruments=(FleetDataTool()),
   mannequin=mannequin,
   add_base_tools=True
)


print("n Agent is analyzing fleet information... (Examine the 'Agent' output beneath)n")


question = """
1. Load the fleet logs.
2. Discover the truck with the worst gasoline effectivity (lowest 'fuel_efficiency_kml').
3. For that truck, examine whether it is overdue for upkeep (threshold is 90 days).
4. Create a bar chart evaluating the 'fuel_efficiency_kml' of ALL vehicles.
5. Spotlight the worst truck in RED and others in GRAY on the chart.
6. Save the chart as 'maintenance_alert.png'.
"""
response = agent.run(question)


print(f"n FINAL REPORT: {response}")

Wir laden das lokale Qwen2.5-Modell und initialisieren unseren CodeAgent mit dem benutzerdefinierten Software. Anschließend erstellen wir eine detaillierte Abfrage, in der die Argumentationsschritte dargelegt werden, die der Agent befolgen soll, und führen sie durchgängig aus. Hier beobachten wir, wie der Agent völlig autonom denkt, analysiert, berechnet und sogar plottet. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

if os.path.exists("maintenance_alert.png"):
   print("n Displaying Generated Chart:")
   img = plt.imread("maintenance_alert.png")
   plt.determine(figsize=(10, 5))
   plt.imshow(img)
   plt.axis('off')
   plt.present()
else:
   print(" No chart picture discovered. Examine the agent logs above.")

Wir prüfen, ob der Agent das generierte Wartungsdiagramm erfolgreich gespeichert hat und zeigen es an, sofern verfügbar. Wir visualisieren die Ausgabe direkt im Pocket book und können so bestätigen, dass der Agent die Datenanalyse und -darstellung korrekt durchgeführt hat. Dadurch erhalten wir ein sauberes, interpretierbares Ergebnis des gesamten Workflows.

Zusammenfassend haben wir eine intelligente Finish-to-Finish-Pipeline aufgebaut, die es einem lokalen Modell ermöglicht, autonom Daten zu laden, den Flottenzustand zu bewerten, das Fahrzeug mit dem höchsten Risiko zu identifizieren und ein Diagnosediagramm für umsetzbare Erkenntnisse zu erstellen. Wir erleben, wie einfach wir dieses Framework auf reale Datensätze erweitern, komplexere Instruments integrieren oder mehrstufige Argumentationsfunktionen für Anwendungsfälle in den Bereichen Sicherheit, Effizienz oder vorausschauende Wartung hinzufügen können. Schließlich wissen wir zu schätzen, wie SmolAgents uns in die Lage versetzt, praktische Agentensysteme zu erstellen, die echten Code ausführen, über echte Telemetrie Schlüsse ziehen und sofort Erkenntnisse liefern.

Schauen Sie sich das an VOLLSTÄNDIGE CODES hier. 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.

Michal Sutter ist ein Information-Science-Experte mit einem Grasp of Science in Information Science von der Universität Padua. Mit einer soliden Grundlage in statistischer Analyse, maschinellem Lernen und Datentechnik ist Michal hervorragend darin, komplexe Datensätze in umsetzbare Erkenntnisse umzuwandeln.

In diesem Tutorial erstellen wir mithilfe von ein vollständig lokales, API-freies Agenten-Storytelling-System Griptape und ein leichtes Hugging Face-Modell. Wir gehen Schritt für Schritt durch die Erstellung eines Agenten mit Fähigkeiten zur Werkzeugnutzung, die Generierung einer fiktiven Welt, die Gestaltung von Charakteren und die Orchestrierung eines mehrstufigen Workflows, der eine zusammenhängende Kurzgeschichte hervorbringt. Durch die Aufteilung der Implementierung in modulare Snippets können wir jede Komponente klar verstehen, wenn sie zu einer durchgängigen kreativen Pipeline zusammenkommt. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

!pip set up -q "griptape(drivers-prompt-huggingface-pipeline)" "transformers" "speed up" "sentencepiece"


import textwrap
from griptape.constructions import Workflow, Agent
from griptape.duties import PromptTask
from griptape.instruments import CalculatorTool
from griptape.guidelines import Rule, Ruleset
from griptape.drivers.immediate.huggingface_pipeline import HuggingFacePipelinePromptDriver


local_driver = HuggingFacePipelinePromptDriver(
   mannequin="TinyLlama/TinyLlama-1.1B-Chat-v1.0",
   max_tokens=256,
)


def present(title, content material):
   print(f"n{'='*20} {title} {'='*20}")
   print(textwrap.fill(str(content material), width=100))

Wir richten unsere Umgebung ein, indem wir Griptape installieren und einen lokalen Hugging Face-Treiber initialisieren. Wir konfigurieren eine Hilfsfunktion, um die Ausgaben sauber anzuzeigen, sodass wir jeden Schritt des Workflows verfolgen können. Während wir die Grundlage schaffen, stellen wir sicher, dass alles lokal läuft, ohne auf externe APIs angewiesen zu sein. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

math_agent = Agent(
   prompt_driver=local_driver,
   instruments=(CalculatorTool()),
)


math_response = math_agent.run(
   "Compute (37*19)/7 and clarify the steps briefly."
)


present("Agent + CalculatorTool", math_response.output.worth)

Wir erstellen einen mit einem Taschenrechner ausgestatteten Agenten und testen ihn mit einer einfachen mathematischen Eingabeaufforderung. Wir beobachten, wie der Agent die Berechnung an das Instrument delegiert und dann eine Erklärung in natürlicher Sprache formuliert. Indem wir dies ausführen, überprüfen wir, dass unsere lokale Treiber- und Instrument-Integration ordnungsgemäß funktioniert. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

world_task = PromptTask(
   enter="Create a vivid fictional world utilizing these cues: {{ args(0) }}.nDescribe geography, tradition, and conflicts in 3–5 paragraphs.",
   id="world",
   prompt_driver=local_driver,
)


def character_task(task_id, identify):
   return PromptTask(
       enter=(
           "Based mostly on the world beneath, invent an in depth character named {{ identify }}.n"
           "World description:n{{ parent_outputs('world') }}nn"
           "Describe their background, wishes, flaws, and one secret."
       ),
       id=task_id,
       parent_ids=("world"),
       prompt_driver=local_driver,
       context={"identify": identify},
   )


scotty_task = character_task("scotty", "Scotty")
annie_task = character_task("annie", "Annie")

Wir erstellen die Aufgabe zur Weltgenerierung und erstellen dynamisch Aufgaben zur Charaktergenerierung, die von der Ausgabe der Welt abhängen. Wir definieren eine wiederverwendbare Funktion, um Charakteraufgaben zu erstellen, die vom gemeinsamen Kontext abhängig sind. Während wir diese Komponenten zusammensetzen, sehen wir, wie der Workflow durch hierarchische Abhängigkeiten Gestalt annimmt. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

style_ruleset = Ruleset(
   identify="StoryStyle",
   guidelines=(
       Rule("Write in a cinematic, emotionally partaking model."),
       Rule("Keep away from specific gore or graphic violence."),
       Rule("Maintain the story between 400 and 700 phrases."),
   ),
)


story_task = PromptTask(
   enter=(
       "Write an entire brief story utilizing the next components.nn"
       "World:n{{ parent_outputs('world') }}nn"
       "Character 1 (Scotty):n{{ parent_outputs('scotty') }}nn"
       "Character 2 (Annie):n{{ parent_outputs('annie') }}nn"
       "The story should have a transparent starting, center, and finish, with a significant character resolution close to the climax."
   ),
   id="story",
   parent_ids=("world", "scotty", "annie"),
   prompt_driver=local_driver,
   rulesets=(style_ruleset),
)


story_workflow = Workflow(duties=(world_task, scotty_task, annie_task, story_task))
matter = "tidally locked ocean world with floating cities powered by storms"
story_workflow.run(matter)

Wir führen Stilregeln ein und erstellen die abschließende Storytelling-Aufgabe, die Worldbuilding und Charaktere zu einer zusammenhängenden Erzählung zusammenführt. Anschließend stellen wir alle Aufgaben zu einem Workflow zusammen und führen ihn mit einem ausgewählten Thema aus. Dadurch werden wir Zeuge, wie Griptape mehrere Eingabeaufforderungen zu einer strukturierten kreativen Pipeline verknüpft. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

world_text = world_task.output.worth
scotty_text = scotty_task.output.worth
annie_text = annie_task.output.worth
story_text = story_task.output.worth


present("Generated World", world_text)
present("Character: Scotty", scotty_text)
present("Character: Annie", annie_text)
present("Last Story", story_text)


def summarize_story(textual content):
   paragraphs = (p for p in textual content.break up("n") if p.strip())
   size = len(textual content.break up())
   structure_score = min(len(paragraphs), 10)
   return {
       "word_count": size,
       "paragraphs": len(paragraphs),
       "structure_score_0_to_10": structure_score,
   }


metrics = summarize_story(story_text)
present("Story Metrics", metrics)

Wir rufen alle generierten Ausgaben ab und zeigen die Welt, die Charaktere und die endgültige Geschichte an. Wir berechnen auch einfache Metriken zur Bewertung von Struktur und Länge und erhalten so eine schnelle analytische Zusammenfassung. Zum Abschluss stellen wir fest, dass der gesamte Arbeitsablauf messbare und interpretierbare Ergebnisse liefert.

Abschließend zeigen wir, wie einfach wir komplexe Denkschritte, Werkzeuginteraktionen und kreative Generierung mithilfe lokaler Modelle innerhalb des Griptape-Frameworks orchestrieren können. Wir erleben, wie modulare Aufgaben, Regelsätze und Arbeitsabläufe zu einem leistungsstarken Agentensystem verschmelzen, das in der Lage ist, strukturierte narrative Ergebnisse zu erzeugen. Indem wir alles ohne externe APIs ausführen, erhalten wir volle Kontrolle, Reproduzierbarkeit und Flexibilität und öffnen die Tür für fortgeschrittenere Experimente mit lokalen Agent-Pipelines, automatisierten Schreibsystemen und Multitasking-Orchestrierung.

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.

Große Sprachmodelle benötigen riesige menschliche Datensätze. Was passiert additionally, wenn das Modell seinen gesamten Lehrplan selbst erstellen und sich selbst den Umgang mit Werkzeugen beibringen muss? Ein Forscherteam von UNC-Chapel Hill, Salesforce Analysis und der Stanford College stellt „Agent0“ vor, ein vollständig autonomes Framework, das leistungsstarke Agenten ohne externe Daten durch mehrstufige Co-Evolution und nahtlose Instrument-Integration entwickelt

Agent0 zielt auf mathematisches und allgemeines Denken ab. Es zeigt, dass eine sorgfältige Aufgabengenerierung und werkzeugintegrierte Rollouts ein Basismodell über seine ursprünglichen Fähigkeiten hinaus in zehn Benchmarks bringen können.

Zwei Agenten aus einem Basismodell

Agent0 beginnt beispielsweise mit einer Basisrichtlinie π_base Qwen3 4B Foundation oder Qwen3 8B Foundation. Es klont diese Richtlinie in:

• A Lehrplanagent πθ, das Aufgaben generiert,
• ein Testamentsvollstrecker πϕ, das diese Aufgaben mit einem Python-Instrument löst.

Das Coaching erfolgt in Iterationen mit zwei Phasen professional Iteration:

1. Lehrplanentwicklung: Der Lehrplanagent generiert einen Stapel von Aufgaben. Für jede Aufgabe prüft der Ausführende mehrere Antworten. Eine zusammengesetzte Belohnung misst, wie unsicher der Ausführende ist, wie oft er das Instrument nutzt und wie vielfältig die Cost ist. πθ wird mit aktualisiert Gruppenrelative Richtlinienoptimierung (GRPO) diese Belohnung nutzen.
2. Weiterentwicklung des Testamentsvollstreckers: Der geschulte Curriculum-Agent ist eingefroren. Es generiert einen großen Pool an Aufgaben. Agent0 filtert diesen Pool, um nur Aufgaben in der Nähe der Fähigkeitsgrenze des Ausführenden zu behalten, und schult den Ausführenden dann für diese Aufgaben mithilfe eines mehrdeutigkeitsbewussten RL-Ziels namens Ambiguity Dynamic Coverage Optimization (ADPO).

Diese Schleife erzeugt einen Suggestions-Zyklus. Da der Ausführende durch die Verwendung des Code-Interpreters stärker wird, muss der Lehrplan komplexere, werkzeugabhängige Probleme generieren, um seinen Nutzen hoch zu halten.

Wie der Lehrplanagent Aufgaben bewertet?

Die Lehrplanbelohnung kombiniert drei Signale:

Unsicherheitsbelohnung: Für jede generierte Aufgabe x prüft der Ausführende ok Antworten und stimmt mehrheitlich für eine Pseudoantwort ab. Die Selbstkonsistenz p̂(x) ist der Anteil der Antworten, die dieser Mehrheit zustimmen. Die Belohnung ist maximal, wenn p̂ nahe bei 0,5 liegt, und niedrig, wenn die Aufgaben zu einfach oder zu schwer sind. Dies fördert Aufgaben, die für den aktuellen Ausführenden herausfordernd, aber dennoch lösbar sind.

Belohnung für Werkzeugnutzung: Der Executor kann mithilfe von einen Sandbox-Code-Interpreter auslösen python markiert und erhält Ergebnisse, die als markiert sind output. Agent0 zählt die Anzahl der Werkzeugaufrufe in einer Flugbahn und gibt eine skalierte, begrenzte Belohnung aus, wobei die Obergrenze C in Experimenten auf 4 festgelegt ist. Dies begünstigt Aufgaben, die tatsächlich Instrument-Aufrufe erfordern, statt reines Kopfrechnen.

Wiederholungsstrafe: Innerhalb jedes Lehrplanstapels misst Agent0 die paarweise Ähnlichkeit zwischen Aufgaben mithilfe einer BLEU-basierten Distanz. Aufgaben werden geclustert und ein Strafzeitraum erhöht sich mit der Clustergröße. Dadurch wird verhindert, dass der Lehrplan viele Beinahe-Duplikate erzeugt.

Eine zusammengesetzte Belohnung multipliziert eine Formatprüfung mit einer gewichteten Summe aus Unsicherheit und Instrument-Belohnungen abzüglich der Wiederholungsstrafe. Dieser zusammengesetzte Wert wird in GRPO eingespeist, um πθ zu aktualisieren.

Wie der Testamentsvollstrecker aus lauten Selbstbezeichnungen lernt?

Der Testamentsvollstrecker wird ebenfalls mit GRPO geschult, jedoch mit Multiturn-, werkzeugintegrierten Trajektorien und Pseudo-Labels anstelle von Floor-Reality-Antworten.

Aufbau von Grenzdatensätzen: Nach der Lehrplanschulung in einer Iteration generiert der eingefrorene Lehrplan einen großen Kandidatenpool. Für jede Aufgabe berechnet Agent0 die Selbstkonsistenz p̂(x) mit dem aktuellen Ausführenden und behält nur Aufgaben bei, bei denen p̂ in einem informativen Bereich liegt, beispielsweise zwischen 0,3 und 0,8. Dies definiert einen herausfordernden Grenzdatensatz, der triviale oder unmögliche Probleme vermeidet.

Integrierte Rollouts mit mehreren Drehwerkzeugen: Für jede Grenzaufgabe generiert der Ausführende eine Flugbahn, die Folgendes verschachteln kann:

• Token für natürliches Denken,
• python Codesegmente,
• output Werkzeug-Suggestions.

Die Generierung pausiert, wenn ein Instrument-Aufruf erscheint, und führt den Code in einem darauf aufbauenden Sandbox-Interpreter aus VeRL-Instrumentund wird dann je nach Ergebnis fortgesetzt. Die Flugbahn endet, wenn das Modell im Inneren eine endgültige Antwort liefert {boxed ...} Tags.

Eine Mehrheitsentscheidung über die erfassten Trajektorien hinweg definiert ein Pseudo-Label und eine Endbelohnung für jede Trajektorie.

ADPO, mehrdeutigkeitsbewusster RL: Normal-GRPO behandelt alle Proben gleich, was instabil ist, wenn Bezeichnungen aus Mehrheitsabstimmungen über mehrdeutige Aufgaben stammen. ADPO modifiziert GRPO auf zwei Arten unter Verwendung von p̂ als Mehrdeutigkeitssignal.

• Es skaliert den normalisierten Vorteil mit einem Faktor, der mit der Selbstkonsistenz zunimmt, sodass Trajektorien aus Aufgaben mit geringem Vertrauen weniger beitragen.
• Es legt eine dynamische Obergrenze für das Wichtigkeitsverhältnis fest, die von der Selbstkonsistenz abhängt. Die empirische Analyse zeigt, dass das feste obere Clipping hauptsächlich Token mit geringer Wahrscheinlichkeit betrifft. ADPO lockert diese Grenze adaptiv, was die Erkundung unsicherer Aufgaben verbessert, wie durch das visualisiert heraufgestufte Token-Wahrscheinlichkeit Statistiken.

Ergebnisse zum mathematischen und allgemeinen Denken

Darüber hinaus wird Agent0 implementiert VeRL und ausgewertet Qwen3 4B Foundation Und Qwen3 8B Foundation. Es verwendet einen Sandbox-Python-Interpreter als einziges externes Instrument.

Das Forschungsteam bewertet anhand von zehn Benchmarks:

• Mathematische Argumentation: AMC, Minerva, MATH, GSM8K, Olympiad Bench, AIME24, AIME25.
• Allgemeine Begründung: SuperGPQA, MMLU Professional, BBEH.

Sie melden „go@1“ für die meisten Datensätze und „imply@32“ für AMC- und AIME-Aufgaben.

Für Qwen3 8B FoundationAgent0 erreicht:

• Mathe-Durchschnitt 58,2 gegenüber 49,2 für das Basismodell,
• allgemeiner Gesamtdurchschnitt 42,1 gegenüber 34,5 beim Basismodell.

Agent0 verbessert sich auch gegenüber starken datenfreien Baselines wie z R Null, Absoluter Nullpunkt, SPIRAL Und Sokratischer Nullpunktsowohl mit als auch ohne Werkzeug. Beim Qwen3 8B übertrifft er R Zero um 6,4 Prozentpunkte und Absolute Zero um 10,6 Punkte im Gesamtdurchschnitt. Es übertrifft auch Socratic Zero, das auf externen OpenAI-APIs basiert.

Über drei Co-Evolution-Iterationen hinweg steigt die durchschnittliche Mathematikleistung auf Qwen3 8B von 55,1 auf 58,2 und auch das allgemeine Denken verbessert sich professional Iteration. Dies bestätigt eher eine stabile Selbstverbesserung als einen Zusammenbruch.

Qualitative Beispiele zeigen, dass sich Lehrplanaufgaben von grundlegenden Geometriefragen zu komplexen Problemen der Erfüllung von Randbedingungen entwickeln, während die Trajektorien des Ausführenden Begründungstext mit Python-Aufrufen mischen, um zu korrekten Antworten zu gelangen.

Wichtige Erkenntnisse

1. Völlig datenfreie Co-Evolution: Agent0 eliminiert externe Datensätze und menschliche Anmerkungen. Zwei Agenten, ein Curriculum-Agent und ein Executor-Agent, werden von demselben Foundation-LLM initialisiert und entwickeln sich nur über Reinforcement Studying und ein Python-Instrument gemeinsam weiter.
2. Grenzlehrplan aus Selbstunsicherheit: Der Lehrplanagent nutzt die Selbstkonsistenz und die Werkzeugnutzung des Ausführenden, um Aufgaben zu bewerten. Es lernt, Grenzaufgaben zu generieren, die weder trivial noch unmöglich sind und die explizit werkzeugintegriertes Denken erfordern.
3. ADPO stabilisiert RL mit Pseudoetiketten: Der Ausführende ist mit Ambiguity Dynamic Coverage Optimization geschult. ADPO verringert die Gewichtung sehr mehrdeutiger Aufgaben und passt den Clipping-Bereich basierend auf der Selbstkonsistenz an, wodurch Aktualisierungen im GRPO-Stil stabil bleiben, wenn Belohnungen von Pseudo-Labels mit Mehrheitsabstimmung kommen.
4. Kontinuierliche Fortschritte in Mathematik und allgemeinem Denken: Auf Qwen3 8B Base verbessert Agent0 die mathematischen Benchmarks von durchschnittlich 49,2 auf 58,2 und das allgemeine Denken von 34,5 auf 42,1, was relativen Zuwächsen von etwa 18 Prozent bzw. 24 Prozent entspricht.
5. Übertrifft frühere Zero-Knowledge-Frameworks: In zehn Benchmarks übertrifft Agent0 frühere sich selbst entwickelnde Methoden wie R Zero, Absolute Zero, SPIRAL und Socratic Zero, einschließlich derjenigen, die bereits Instruments oder externe APIs verwenden. Dies zeigt, dass das Design der Co-Evolution plus Werkzeugintegration einen sinnvollen Schritt über frühere Einzelrunden-Selbstspielansätze hinaus darstellt.

Redaktionelle Anmerkungen

Agent0 ist ein wichtiger Schritt in Richtung praktisches, datenfreies Verstärkungslernen für werkzeugintegriertes Denken. Es zeigt, dass ein Foundation-LLM sowohl als Curriculum-Agent als auch als Executor-Agent fungieren kann und dass GRPO mit ADPO und dem VeRL-Instrument eine stabile Verbesserung gegenüber Pseudo-Labels mit Mehrheitsabstimmung bewirken kann. Die Methode zeigt auch, dass die werkzeugintegrierte Co-Evolution frühere Zero-Knowledge-Frameworks wie R Zero und Absolute Zero auf starken Qwen3-Basislinien übertreffen kann. Agent0 ist ein starkes Argument dafür, dass sich selbst entwickelnde, in Instruments integrierte LLM-Agenten zu einem realistischen Trainingsparadigma werden.

Schauen Sie sich das an PAPIER Und Repo. 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.

Michal Sutter ist ein Knowledge-Science-Experte mit einem Grasp of Science in Knowledge Science von der Universität Padua. Mit einer soliden Grundlage in statistischer Analyse, maschinellem Lernen und Datentechnik ist Michal hervorragend darin, komplexe Datensätze in umsetzbare Erkenntnisse umzuwandeln.

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

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.

Stealth -Startup Lab0 entsteht mit einer Robotiklösung, die die Lagernoperationen revolutionieren will. Nach zwei Jahren in der Entwicklung hat das Unternehmen Roboglide vorgestellt, ein von Humanoiden inspiriertes Robotersystem für vollständig automatisierte Logistik für eingehende Lager. Die Technologie von Lab0 integriert mehrere Stufen des Prozesses in ein einzelnes, einheitliches und skalierbares System, vom Entladen von Versandbehältern bis hin zur Produktidentifizierung, der Schadenserkennung, des Wiegens, der Sortierung, der Palettisierung und sogar des Verpackens.

Roboglide ist bereits in einem Prime-10-Einzelhändler mit einem Preispunkt-Small-Field eingesetzt. Es nutzt ein Group von Prime -Robotik -Talenten, Nvidias Isaac Lab und Nvidia Omniverse Für physisches KI -Lernen und -Simulation sowie fortschrittliches KI und maschinelles Lernen. Es verwendet einen Simulationsansatz zum ersten Mal, um die AI-betriebene Präzision in der Logistikautomatisierung zu erreichen.

Ein kundenorientierter Ansatz zur Automatisierung

Die Automatisierungsstrategie von Lab0 ist laserorientiert bei der Lösung realer, kundenspezifischer Probleme. Roboglides patentiertes Twin-Arm-Choosing Robotics, Superior Percept0 Imaginative and prescient System und intelligente Entscheidungsfunktionen rationalisieren die Handhabung vielfältiger Bestandsaufnahmen und gleichzeitig die Ineffizienzen erheblich. Diese Innovationen schaffen ein skalierbares Logistikrahmen, das einen neuen Branchenstandard für autonome Logistikdesign, -entwicklung und -integration darstellt. Im Gegensatz zu vielen Automatisierungsanbietern, die „Level Options“ anbieten, verfolgt Lab0 einen ganzheitlichen Ansatz und bietet vollständige Systemlösungen, die sich mit dem vollen Umfang der Kundenherausforderungen befassen. Lab0 erkannte, dass die bestehenden Seh- und Bewegungssysteme außerhalb der Startseite ihre Anforderungen nicht bestand, und entwickelte ihre benutzerdefinierten Systeme, um die erforderliche Geschwindigkeit, Genauigkeit und Zuverlässigkeit zu erreichen.

Der erste Kunde von Lab0, ein 30 -Milliarden -Greenback -Einzelhändler für kleine Kasten und einer der größten Warenimporteure in den USA hat Roboglide bereits als Teil einer breiteren Initiative zur Optimierung von Lagerbetrieb integriert. Die modulare und skalierbare Technologie von LAB0 ermöglicht eine nahtlose Growth über Vertriebsnetzwerke hinweg, ein wesentlicher Vorteil gegenüber herkömmlichen Lösungen für Materialverhandlungen.

Lab0 wurde von David McCalib, einem MIT -Alumnus und Robotik -Pionier, gegründet, der maßgeblich an der Integration der Amazon -Übernahme von Kiva Robotics und der führenden fortschrittlichen Pc Imaginative and prescient -Projekte beteiligt battle. Steve Toebes, CEO von LAB0 und Gründungsinnovator bei Symbotic, bietet jahrzehntelange Erfahrung mit transformativen Robotersystemen. McCalib und Toebes kombinieren tiefe Robotik- und Logistikkompetenz mit einem unerbittlichen Fokus auf Einfachheit, Skalierbarkeit und Kundenerfolg.

„Unsere Arbeit beginnt damit, Kundenbedürfnisse zuzuhören und Technologien zu liefern, die ihre dringendsten Probleme im Maßstab löst“, sagte McCalib. „Alles, was wir bauen, spiegelt ein Engagement für reale Auswirkungen und greifbare Ergebnisse wider.“

Die Imaginative and prescient: Lieferkette Null

Die Initiative „Provide Chain Null“ von Lab0 ist eine mutige Sicht, um Logistik -Ineffizienzen, Abfälle und Entlassungen zu beseitigen. Seine Mission zielt darauf ab, nachhaltige, effiziente und zukunftssichere Operationen in industriellen Umgebungen zu unterstützen, indem die KI-gesteuerte Automatisierung und Echtzeitanalysen kombiniert werden.

„Lab0 ist mehr als ein Robotikunternehmen – es ist eine Bewegung, um die Logistik zu transformieren“, sagte Toebes. „Unser Roboglide -System ist das erste in einer Reihe flexibler, modularer Lösungen, die so ausgelegt sind, dass sie nahtlos zusammenarbeiten, ganze Einrichtungen automatisieren und für unsere Kunden sinnvolle Ergebnisse liefern.“

Als Arbeitskräftemangel, steigende Kosten und komplexe Logistik-Herausforderungen verstärken Lab0 die Notwendigkeit von Innovationen und präsentieren sein industrielles humanoid-inspiriertes System bei Promat 2025 und vor Nvidia GTC 2025. Mit einem standhaften Engagement für autonome Logistik signalisiert Lab0 eine neue Technology von Robotik -Innovationen.

OLMo 2-Modelle sind die vollständig Open-Supply-Sprachmodelle von Ai2. Sie verfügen über dichte autoregressive Architekturen mit optimierten Trainings, Datenmischungen vor dem Coaching und fortschrittlichen Techniken zur Befehlsoptimierung. Durch die Verbesserung der Trainingsstabilität und die Verbesserung der Effizienz professional Token setzt OLMo 2 Maßstäbe in Bezug auf Leistung und Transparenz. Die Einführung von Dolmino Combine 1124, einem speziellen Datenmix für Lehrplanschulungen im Spätstadium, verbessert die Downstream-Fähigkeiten weiter. In Verbindung mit den Finest Practices von Tülu 3 erzielt OLMo 2-Instruct beeindruckende Ergebnisse im Vergleich zu anderen Lama 3.1 Und Qwen 2.5. Erfahren Sie mehr über diese Modelle!

2 OLAMo 2 Livid

OLMo 2 baut auf den Grundlagen seiner Vorgänger auf und bietet vollständig offene Sprachmodelle mit Parametergrößen von 7 Milliarden und 13 Milliarden. Im Gegensatz zu vielen Branchenkollegen gewährleistet OLMo 2 vollständige Transparenz und gibt Trainingsdaten, Code, Rezepte und sogar Zwischenkontrollpunkte frei. Dieses Engagement beschleunigt nicht nur die akademische und industrielle Forschung, sondern fördert auch ein kollaboratives KI-Entwicklungsökosystem.

Diese Modelle konkurrieren stark mit Branchenriesen wie Llama 3.1 und Qwen 2.5 und verbrauchen dabei weniger Rechenressourcen. Ihre Leistung bringt sie an die Pareto-Grenze, wo Effizienz auf Exzellenz trifft, was sie für verschiedene nachgelagerte Anwendungen von unschätzbarem Wert macht.

Alles zum Modell finden Sie in diesem Forschungsbericht – 2 OLAMo 2 Livid.

Hauptmerkmale der OLMo 2-Modelle

Verbesserte Trainingsstabilität

Beim Coaching umfangreicher Sprachmodelle kommt es häufig zu Instabilitäten wie Verlustspitzen. OLMo 2 begegnet diesen Herausforderungen durch:

• Datenkuration: Filtern wiederholter N-Gramm, um Gradienten- und Verlustspitzen zu minimieren.
• Verbesserte Initialisierung: Wechsel zu einem standardisierten Initialisierungsschema, das die Stabilität über Schichten hinweg gewährleistet.
• Regularisierungstechniken: Einbindung von Z-Verlust zur Stabilisierung der Ausgabeprotokolle.

Diese Anpassungen führen zu einem reibungsloseren Trainingsprozess und ermöglichen es den Modellen, größere Datensätze effizienter zu verarbeiten.

Optimierte Datenmischungen

Das Vortraining von OLMo 2 umfasst einen zweistufigen Ansatz:

• Vortrainingsphase: Nutzt eine Mischung hochwertiger Webdaten im Umfang von insgesamt 5 Billionen Token.
• Mittlere Trainingsphase: Führt domänenspezifische Datensätze ein, insbesondere in den Bereichen Mathematik und MINT, um spezielle Fähigkeiten zu stärken. Der Dolmino Combine 1124-Datensatz veranschaulicht diese Strategie und kombiniert aus dem Web stammende und kuratierte Daten für gezielte Leistungsverbesserungen.

Architektonische Fortschritte

OLMo 2 integriert moderne Innovationen zur Verbesserung seiner Transformatorarchitektur, darunter:

• RMSNorm: Eine stabile Normalisierungsmethode für Aktivierungen.
• Neugeordnete Ebenennorm: Normalisierung der Aufmerksamkeits- und Feedforward-Ausgaben und Verbesserung der Stabilität.
• Erhöhte Auflösung der Positionskodierung: Einführung rotierender Positionseinbettungen mit höherer Auflösung für eine bessere Sequenzverarbeitung.

Diese Funktionen steigern gemeinsam die Skalierbarkeit und Effizienz des Modells.

Exzellenz nach dem Coaching

Die Submit-Coaching-Pipeline von OLMo 2, inspiriert vom Tülu 3-Rezept, konzentriert sich auf die Optimierung der Anweisungen und das verstärkende Lernen. Zu den Schlüsselkomponenten gehören:

• Überwachte Feinabstimmung (SFT): Nutzung hochwertiger Eingabeaufforderungen zur Verbesserung der Fähigkeiten zur Befolgung von Anweisungen.
• Reinforcement Studying mit überprüfbaren Belohnungen (RLVR): Optimieren Sie die Leistung bei bestimmten Aufgaben wie Mathematik und sachlichem Denken durch die Belohnung korrekter Ergebnisse.

Dieser Ansatz hat zu OLMo 2-Instruct-Modellen geführt, die sich in Benchmarks wie GSM8K für mathematisches Denken und MMLU für Multitasking-Sprachverständnis auszeichnen.

Effizienz trifft Transparenz

OLMo 2 zeichnet sich durch eine effiziente Nutzung der Rechenressourcen aus. Durch die Reduzierung von FLOPs (Gleitkommaoperationen) während des Trainings wird eine hohe Leistung bei geringerer Umweltbelastung erreicht. Eine detaillierte Berichterstattung über Stromverbrauch und CO2-Emissionen unterstreicht das Engagement des Projekts für Nachhaltigkeit.

Infrastruktur als Forschungskatalysator

Der Erfolg des Projekts wird auch auf die fortschrittliche Infrastruktur von Ai2 zurückgeführt:

• Hochleistungscluster: Nutzung modernster {Hardware}, einschließlich NVIDIA H100-GPUs, in mehreren Rechenzentren.
• Becher-Workload-Administration: Gewährleistung einer nahtlosen Arbeitslastverteilung und -überwachung.

Diese Investitionen in die Infrastruktur haben die Ausbildungsunterbrechungen deutlich reduziert und die Ressourcenauslastung erhöht.

OLMo 2 gegen Qwen 2.5 gegen Llama 3.1 gegen andere

Um die Wirkung weiter zu veranschaulichen, übertreffen die Benchmarks von OLMo 2 bei bestimmten Aufgaben häufig die von Qwen 2.5 und Llama 3.1. Die Einbeziehung von Dolmino Combine 1124 hat die Leistung bei MINT- und mathematikbasierten Benchmarks erheblich verbessert. Darüber hinaus weist OLMo 2 bemerkenswerte Effizienzsteigerungen auf, indem es bis zu 20 % weniger FLOPs verwendet und gleichzeitig vergleichbare oder bessere Ergebnisse erzielt.

Probieren wir OLMo 2 aus

Um auf das Modell zuzugreifen, können Sie besuchen Hier. Sie können es ohne Anmeldung nutzen.

Immediate: Sie haben es eilig zur Arbeit. Sie gießen sich eine Tasse schwarzen Kaffee ein, aber er ist zu heiß. Sie beabsichtigen, eine festgelegte Menge kalter Milch hinzuzufügen, wissen aber, dass der Kaffee auch danach noch einige Minuten abkühlen muss, bevor Sie ihn trinken können.
In diesem Fall kühlt der Kaffee stärker ab:
1) Fügen Sie sofort Milch hinzu und warten Sie dann einige Minuten, bevor Sie trinken.
2) Warten Sie einige Minuten und fügen Sie dann erst kurz vor dem Trinken Milch hinzu.

Ausgabe:

Beobachtung: Die Antwort auf meine Aufforderung ist korrekt. OLMo 2 konnte das Downside verstehen und die richtige Antwort geben. DeepSeek V3 konnte dies in meinem vorherigen Artikel nicht richtig lösen DeepSeek V3 vs. Claude Sonnet 3.5.

Sie können dieses Modell auch lokal verwenden. Befolgen Sie dazu einfach die angegebene Anleitung Hier.

Wichtige Hyperlinks

Abschluss

OLMo 2 zeigt das bemerkenswerte Potenzial von Open-Supply-KI und setzt neue Maßstäbe in Bezug auf Transparenz und Innovation. Durch die Veröffentlichung seines Codes, seiner Daten und Erkenntnisse demokratisiert es den Zugang zu Spitzentechnologie und fördert so Zusammenarbeit und Fortschritt. Mit dem Engagement von Ai2 für Offenheit ermöglicht OLMo 2 Forschern und Entwicklern die freie Innovation, erweitert die Möglichkeiten für gesellschaftliche und industrielle Auswirkungen und treibt gleichzeitig die Zukunft von KI-Anwendungen voran.

Wenn Sie erfahren möchten, wie diese Modelle funktionieren, schauen Sie sich unsere an Generatives KI-Pinnacle-Programm!

Hallo, ich bin Nitika, eine technisch versierte Content material-Erstellerin und Vermarkterin. Kreativität und das Lernen neuer Dinge sind für mich selbstverständlich. Ich habe Erfahrung in der Erstellung ergebnisorientierter Content material-Strategien. Ich kenne mich intestine mit Web optimization-Administration, Key phrase-Operationen, Net-Content material-Schreiben, Kommunikation, Content material-Strategie, Redaktion und Schreiben aus.

MIT-Wissenschaftler haben freigegeben ein leistungsstarkes Open-Supply-KI-Modell namens Boltz-1, das die biomedizinische Forschung und Arzneimittelentwicklung erheblich beschleunigen könnte.

Boltz-1 wurde von einem Forscherteam der MIT Jameel Clinic for Machine Studying in Well being entwickelt und ist das erste vollständig Open-Supply-Modell, das modernste Leistung auf dem Niveau von AlphaFold3 erreicht, dem Modell von Google DeepMind sagt die 3D-Strukturen von Proteinen und anderen biologischen Molekülen voraus.

Die MIT-Absolventen Jeremy Wohlwend und Gabriele Corso waren die Hauptentwickler von Boltz-1, zusammen mit Saro Passaro, einem Forschungspartner der MIT Jameel Clinic, und den MIT-Professoren für Elektrotechnik und Informatik Regina Barzilay und Tommi Jaakkola. Wohlwend und Corso stellten das Modell am 5. Dezember bei einer Veranstaltung im Stata Middle des MIT vor und sagten, ihr oberstes Ziel sei es, die globale Zusammenarbeit zu fördern, Entdeckungen zu beschleunigen und eine robuste Plattform für die Weiterentwicklung der biomolekularen Modellierung bereitzustellen.

„Wir hoffen, dass dies ein Ausgangspunkt für die Neighborhood ist“, sagte Corso. „Es gibt einen Grund, warum wir es Boltz-1 und nicht Boltz nennen. Dies ist nicht das Ende der Fahnenstange. Wir wollen von der Neighborhood so viel Beitrag wie möglich leisten.“

Proteine ​​spielen in nahezu allen biologischen Prozessen eine wesentliche Rolle. Die Kind eines Proteins hängt eng mit seiner Funktion zusammen. Daher ist das Verständnis der Proteinstruktur für die Entwicklung neuer Medikamente oder die Entwicklung neuer Proteine ​​mit spezifischen Funktionalitäten von entscheidender Bedeutung. Doch aufgrund des äußerst komplexen Prozesses, durch den die lange Aminosäurekette eines Proteins in eine dreidimensionale Struktur gefaltet wird, struggle die genaue Vorhersage dieser Struktur jahrzehntelang eine große Herausforderung.

AlphaFold2 von DeepMind, das Demis Hassabis und John Jumper den Nobelpreis für Chemie 2024 einbrachte, nutzt maschinelles Lernen, um schnell 3D-Proteinstrukturen vorherzusagen, die so genau sind, dass sie von denen, die von Wissenschaftlern experimentell abgeleitet wurden, nicht zu unterscheiden sind. Dieses Open-Supply-Modell wurde von akademischen und kommerziellen Forschungsteams auf der ganzen Welt genutzt und hat viele Fortschritte in der Arzneimittelentwicklung vorangetrieben.

AlphaFold3 verbessert seine Vorgänger durch die Integration eines generativen KI-Modells, eines sogenannten Diffusionsmodells, das die mit der Vorhersage extrem komplexer Proteinstrukturen verbundenen Unsicherheiten besser bewältigen kann. Im Gegensatz zu AlphaFold2 ist AlphaFold3 jedoch nicht vollständig Open Supply und steht auch nicht für die kommerzielle Nutzung zur Verfügung, was Anlass gab Kritik aus der wissenschaftlichen Gemeinschaft und startete a globales Rennen eine kommerziell erhältliche Model des Modells zu bauen.

Für ihre Arbeit an Boltz-1 verfolgten die MIT-Forscher zunächst denselben Ansatz wie AlphaFold3, untersuchten jedoch nach der Untersuchung des zugrunde liegenden Diffusionsmodells mögliche Verbesserungen. Sie haben diejenigen integriert, die die Genauigkeit des Modells am meisten steigerten, beispielsweise neue Algorithmen, die die Vorhersageeffizienz verbessern.

Zusammen mit dem Modell selbst haben sie ihre gesamte Pipeline zur Schulung und Feinabstimmung als Open-Supply-Lösung bereitgestellt, damit andere Wissenschaftler auf Boltz-1 aufbauen können.

„Ich bin sehr stolz auf Jeremy, Gabriele, Saro und den Relaxation des Groups der Jameel Clinic, dass sie diese Veröffentlichung möglich gemacht haben. Dieses Projekt hat viele Tage und Nächte Arbeit in Anspruch genommen, mit unerschütterlicher Entschlossenheit, dieses Ziel zu erreichen. Es gibt viele spannende Ideen für weitere Verbesserungen und wir freuen uns darauf, sie in den kommenden Monaten zu teilen“, sagt Barzilay.

Das MIT-Staff brauchte vier Monate Arbeit und viele Experimente, um Boltz-1 zu entwickeln. Eine ihrer größten Herausforderungen bestand darin, die Mehrdeutigkeit und Heterogenität der Proteindatenbank zu überwinden, einer Sammlung aller biomolekularen Strukturen, die Tausende von Biologen in den letzten 70 Jahren gelöst haben.

„Ich habe viele Nächte lang mit diesen Daten gerungen. Vieles davon ist reines Fachwissen, das man sich einfach aneignen muss. Es gibt keine Abkürzungen“, sagt Wohlwend.

Letztendlich zeigen ihre Experimente, dass Boltz-1 bei einer Reihe komplexer Vorhersagen der biomolekularen Struktur die gleiche Genauigkeit wie AlphaFold3 erreicht.

„Was Jeremy, Gabriele und Saro erreicht haben, ist geradezu bemerkenswert. Ihre harte Arbeit und Beharrlichkeit bei diesem Projekt haben die Vorhersage biomolekularer Strukturen für die breitere Gemeinschaft zugänglicher gemacht und werden Fortschritte in den Molekularwissenschaften revolutionieren“, sagt Jaakkola.

Die Forscher planen, die Leistung von Boltz-1 weiter zu verbessern und die Zeit zu verkürzen, die für Vorhersagen benötigt wird. Sie laden Forscher auch ein, Boltz-1 auf ihrem Gerät auszuprobieren GitHub-Repository und vernetzen Sie sich mit anderen Benutzern von Boltz-1 Slack-Kanal.

„Wir glauben, dass es noch viele, viele Jahre dauern wird, diese Modelle zu verbessern. Wir sind sehr daran interessiert, mit anderen zusammenzuarbeiten und zu sehen, was die Neighborhood mit diesem Software macht“, fügt Wohlwend hinzu.

Mathai Mammen, CEO und Präsident von Parabilis Medicines, nennt Boltz-1 ein „bahnbrechendes“ Modell. „Durch die Open-Supply-Bereitstellung dieses Fortschritts demokratisieren die MIT Jameel Clinic und ihre Mitarbeiter den Zugang zu modernsten Werkzeugen der Strukturbiologie“, sagt er. „Diese bahnbrechende Anstrengung wird die Entwicklung lebensverändernder Medikamente beschleunigen. Vielen Dank an das Boltz-1-Staff, das diesen tiefgreifenden Sprung vorangetrieben hat!“

„Boltz-1 wird für mein Labor und die gesamte Gemeinschaft von enormem Nutzen sein“, fügt Jonathan Weissman hinzu, ein MIT-Professor für Biologie und Mitglied des Whitehead Institute for Biomedical Engineering, der nicht an der Studie beteiligt struggle. „Wir werden eine ganze Welle von Entdeckungen erleben, die durch die Demokratisierung dieses mächtigen Werkzeugs ermöglicht werden.“ Weissman fügt hinzu, dass er davon ausgeht, dass der Open-Supply-Charakter von Boltz-1 zu einer Vielzahl kreativer neuer Anwendungen führen wird.

Diese Arbeit wurde auch durch ein Stipendium der US Nationwide Science Basis Expeditions unterstützt; die Jameel Clinic; das DOMANE-Programm (Discovery of Medical Countermeasures Towards New and Rising Threats) der US Protection Risk Discount Company; und das MATCHMAKERS-Projekt, das von der Most cancers Grand Challenges-Partnerschaft unterstützt wird, die von Most cancers Analysis UK und dem US Nationwide Most cancers Institute finanziert wird.

Surreal Cloud ist auf der S3-Plattform von AWS verfügbar, lässt sich nahtlos in die grafische Benutzeroberfläche von Surrealist integrieren und verfügt über Surreal Sidekick, einen neuen persönlichen KI-Assistenten

SurrealDBdie ultimative Datenbank mit mehreren Modellen, kündigte die Einführung von Surreal Cloud an, einem Database-as-a-Service (DBaaS)-Angebot. In der ersten Model haben Unternehmen nun Zugriff auf eine vollständig verwaltete Lösung für Entwickler, die die Leistungsfähigkeit und Flexibilität von SurrealDB nutzen möchten, ohne sich mit der Komplexität der Infrastrukturverwaltung befassen zu müssen. Surreal Cloud definiert das Datenbankerlebnis neu und hilft Unternehmen dabei, ein beispielloses Maß an Skalierbarkeit und Ausfallsicherheit zu erreichen.

„Die Einführung von Surreal Cloud markiert einen wichtigen Meilenstein auf unserem Weg zur Bereitstellung eines leistungsstarken, cloudverwalteten Dienstes. Was vor zwei Jahren aufgrund von Anfragen aus der Group als Warteliste begann, unterstreicht nun die Nachfrage und den Eifer der Entwickler, Surreal Cloud in die Hände zu bekommen“, sagte CEO und Mitbegründer Tobie Morgan Hitchcock. „Das ist erst der Anfang – es wird noch viel mehr Innovation geben. Mit Surreal Cloud geben wir Entwicklern und Unternehmen die Möglichkeit, modern Anwendungen zu erstellen, während wir durch die Verwaltung der zugrunde liegenden Infrastruktur die Final der Datenbankkomplexität verringern.“

Eine Datenbank mit mehreren Modellen verfügt über die Funktionen mehrerer Datenmodelle und Datenbanken, die in einem einzigen Produkt integriert sind, das eine einzige Abfragesprache verwendet. Tatsächlich kann SurrealDB 10 oder mehr Produkte und Dienstleistungen durch seine einzige Datenbank mit mehreren Modellen ersetzen. Dadurch entfällt für Entwickler ein Großteil der Komplexität, sodass sie sich auf das konzentrieren können, was sie am besten können: großartige Anwendungen erstellen. Mit der heutigen Einführung von Surreal Cloud erhalten Entwickler die gleiche Funktionalität in einer vollständig verwalteten S3-gestützten Umgebung, die das beste Preis-Leistungs-Verhältnis für jede Arbeitslast und ein automatisiertes Datenlebenszyklusmanagement bietet, in dem riesige Mengen häufig, selten oder selten aufgerufener Daten gespeichert werden können eine kostengünstige Möglichkeit.

Surreal Cloud sorgt dafür, dass sich Unternehmen keine Sorgen mehr um Infrastrukturbetrieb, Überwachung, Backups oder Kapazitätsplanung machen müssen. Es bietet eine vereinfachte Bereitstellung und gibt Entwicklern die Möglichkeit, sich auf die Entwicklung großartiger Produkte und Anwendungen zu konzentrieren. Surreal Cloud bietet eine versatile und kostengünstige Lösung für die Datenverarbeitung in großem Maßstab, sowohl für transaktionale als auch für analytische Anwendungsfälle. Unternehmen können Rechenlasten auf Daten ausführen, die in kostengünstigem Objektspeicher gespeichert sind, und gleichzeitig Rechenressourcen dynamisch skalieren.

Zu den Funktionen gehören GUI-Integration und KI-gestützte Unterstützung

Surreal Cloud lässt sich nahtlos in Surrealist integrieren, die grafische Benutzeroberfläche für SurrealDB, die Entwicklern eine visuelle Möglichkeit zur Verwaltung ihrer Datenbank bietet. Durch die Bereitstellung einer effizienteren Möglichkeit zur Interaktion mit SurrealDB macht Surrealist die Ausführung von Aufgaben wie das Ausführen von Abfragen, das Durchsuchen von Datensätzen, das Entwerfen von Schemata und das Verwalten von Verbindungen intuitiver. Die benutzerfreundliche Oberfläche bietet robuste Instruments zur Verbesserung der Datenbankverwaltung eines Unternehmens, um eine optimale Leistung sicherzustellen, egal ob es sich um einen Anfänger handelt, der in der Sandbox herumspielt, oder um einen Unternehmensbenutzer, der seine Cloud-Umgebung verwaltet. Wer sowohl SurrealDB als auch Surreal Cloud nutzt, kann beide Produkte über nur eine nahtlose Schnittstelle verwalten. Darüber hinaus enthält Surreal Cloud den neuen Surreal Sidekick, einen persönlichen KI-Assistenten, der Sie bei allen Fragen zum Surrealen unterstützt. Entwickler, die Hilfe beim Erstellen von Anwendungen benötigen, können Surreal Sidekick Fragen stellen. Das Programm durchsucht dann die Bibliothek der frei verfügbaren Dokumentation und antwortet mit einer Antwort.

Weitere wichtige Vorteile von Surreal Cloud sind:

• Skalierbarkeit: Eine skalierbare Architektur ermöglicht es Unternehmen, vom Prototyp auf Unternehmensebene zu wachsen, sodass mit dem Wachstum einer Datenbank auch ihre Anwendungen wachsen und die Ressourcen automatisch skaliert werden, um sich ändernde Arbeitslasten zu bewältigen.
• ACID-kompatibel: Ermöglicht Entwicklern die Ausführung von Transaktionen über mehrere Zeilen und mehrere verschiedene Tabellen hinweg, ohne dass die Ausführungsdauer einer Transaktion begrenzt ist.
• Workload-Isolierung: Ermöglicht die Aufteilung der Workloads für verschiedene Abteilungen oder Projekte innerhalb einer Organisation und stellt gleichzeitig sicher, dass alle Groups auf ein konsistentes, gemeinsames Datenrepository zugreifen. Dadurch entfällt die Notwendigkeit langsamer und kostspieliger ETL-Jobs und redundanter Knowledge Marts.

Surreal Cloud ist jetzt in der Beta-Section verfügbar und bietet Benutzern die Möglichkeit, seine Funktionen zu erkunden, Suggestions auszutauschen und eine aktive Rolle bei der Gestaltung seiner zukünftigen Entwicklung zu spielen.

Melden Sie sich für die kostenlosen insideAI-Information an E-newsletter.

Begleiten Sie uns auf Twitter: https://twitter.com/InsideBigData1

Treten Sie uns auf LinkedIn bei: https://www.linkedin.com/firm/insideainews/

Begleiten Sie uns auf Fb: https://www.fb.com/insideAINEWSNOW

Schauen Sie bei uns vorbei YouTube!