Autoren: Augusto Cerqua, Marco Letta, Gabriele Pinto

Lernen (ML) hat eine zentrale Rolle in den Wirtschaftswissenschaften, den Sozialwissenschaften und der unternehmerischen Entscheidungsfindung erlangt. Im öffentlichen Sektor wird ML zunehmend für sogenannte vorhersagepolitische Probleme eingesetzt: Situationen, in denen politische Entscheidungsträger darauf abzielen, Einheiten zu identifizieren, bei denen das größte Risiko für ein negatives Ergebnis besteht, und proaktiv einzugreifen; zum Beispiel die Ausrichtung auf öffentliche Subventionen, die Vorhersage lokaler Rezessionen oder die Antizipation von Migrationsmustern. Im privaten Sektor ergeben sich ähnliche Vorhersageaufgaben, wenn Unternehmen die Kundenabwanderung vorhersagen oder die Kreditrisikobewertung optimieren möchten. In beiden Bereichen führen bessere Vorhersagen zu einer effizienteren Ressourcenallokation und wirksameren Interventionen.

Um diese Ziele zu erreichen, werden ML-Algorithmen zunehmend auf Paneldaten angewendet, die durch wiederholte Beobachtungen derselben Einheiten über mehrere Zeiträume gekennzeichnet sind. Allerdings waren ML-Modelle ursprünglich nicht für die Verwendung mit Paneldaten konzipiert, die unterschiedliche Querschnitts- und Längsabmessungen aufweisen. Wenn ML auf Paneldaten angewendet wird, besteht ein hohes Risiko eines subtilen, aber schwerwiegenden Issues: Datenlecks. Dies geschieht, wenn zum Vorhersagezeitpunkt nicht verfügbare Informationen versehentlich in den Modelltrainingsprozess gelangen und die Vorhersageleistung beeinträchtigen. In unserem Artikel „Über den Missbrauch von maschinellem Lernen mit Paneldaten“ (Cerqua, Letta und Pinto, 2025), kürzlich veröffentlicht in der Oxford Bulletin of Economics and StatisticsWir liefern die erste systematische Bewertung von Datenlecks in ML mit Paneldaten, schlagen klare Richtlinien für Praktiker vor und veranschaulichen die Konsequenzen durch eine empirische Anwendung mit öffentlich verfügbaren US-County-Daten.

Das Leckageproblem

Paneldaten kombinieren zwei Strukturen: eine zeitliche Dimension (über die Zeit beobachtete Einheiten) und eine Querschnittsdimension (mehrere Einheiten, z. B. Regionen oder Unternehmen). Die standardmäßige ML-Praxis, bei der die Stichprobe zufällig in Trainings- und Testsätze aufgeteilt wird, setzt implizit unabhängige und identisch verteilte (iid) Daten voraus. Diese Annahme wird verletzt, wenn standardmäßige ML-Verfahren (z. B. eine zufällige Aufteilung) auf Paneldaten angewendet werden, wodurch zwei Haupttypen von Datenverlusten entstehen:

• Zeitlicher Verlust: Zukünftige Informationen dringen während der Trainingsphase in das Modell ein, wodurch Prognosen unrealistisch genau erscheinen. Darüber hinaus können frühere Informationen in den Testdatensatz gelangen, wodurch rückblickende „Prognosen“ erstellt werden.
• Querschnittsleckage: Dieselben oder sehr ähnliche Einheiten erscheinen sowohl in Trainings- als auch in Testsätzen, was bedeutet, dass das Modell den größten Teil der Querschnittsdimension der Daten bereits „gesehen“ hat.

Abbildung 1 zeigt, wie sich unterschiedliche Aufteilungsstrategien auf das Leckagerisiko auswirken. Eine zufällige Aufteilung auf Zeiteinheitsebene (Panel A) ist am problematischsten, da sie sowohl zeitliche als auch querschnittliche Leckagen mit sich bringt. Alternativen wie die Aufteilung nach Einheiten (Panel B), nach Gruppen (Panel C) oder nach Zeit (Panel D) mildern eine Artwork von Leckage, die andere jedoch nicht. Daher gibt es keine Strategie, die das Drawback vollständig beseitigt: Die geeignete Wahl hängt von der jeweiligen Aufgabe ab (siehe unten), da in manchen Fällen eine Type der Leckage möglicherweise kein wirkliches Drawback darstellt.

Abbildung 1 | Trainings- und Testsätze nach unterschiedlichen Aufteilungsregeln

Zwei Arten von Problemen mit der Vorhersagepolitik

Eine wichtige Erkenntnis der Studie ist, dass Forscher ihr Vorhersageziel im Voraus klar definieren müssen. Wir unterscheiden zwei große Klassen von Vorhersagepolitikproblemen:

1. Querschnittsvorhersage: Die Aufgabe besteht darin, die Ergebnisse verschiedener Einheiten im gleichen Zeitraum abzubilden. Zum Beispiel die Imputierung fehlender Daten zum BIP professional Kopf in verschiedenen Regionen, wenn nur einige Regionen über verlässliche Messungen verfügen. Die beste Aufteilung erfolgt hier auf Einheitenebene: Den Trainings- und Testsätzen werden unterschiedliche Einheiten zugeordnet, wobei alle Zeiträume erhalten bleiben. Dadurch wird die Querschnittsleckage eliminiert, obwohl die zeitliche Leckage bestehen bleibt. Da aber Prognosen nicht das Ziel sind, ist dies kein wirkliches Drawback.

2. Sequentielle Prognosen: Das Ziel besteht darin, zukünftige Ergebnisse auf der Grundlage historischer Daten vorherzusagen – beispielsweise die Vorhersage von Einkommensrückgängen auf Kreisebene ein Jahr im Voraus, um frühzeitige Interventionen auszulösen. Hier ist die korrekte Aufteilung nach Zeit: frühere Zeiträume für die Schulung, spätere Zeiträume für die Prüfung. Dies vermeidet zeitliche Leckagen, jedoch keine Querschnittsleckagen, was kein wirkliches Drawback darstellt, da über die Zeit hinweg dieselben Einheiten vorhergesagt werden.

Der falsche Ansatz ist in beiden Fällen die zufällige Aufteilung nach Zeiteinheiten (Panel A in Abbildung 1), die die Ergebnisse durch beide Arten von Leckagen verunreinigt und zu irreführend hohen Leistungsmetriken führt.

Praktische Richtlinien

Um Praktikern zu helfen, fassen wir eine Reihe von Verhaltensregeln für die Anwendung von ML auf Paneldaten zusammen:

• Wählen Sie die Stichprobenaufteilung basierend auf der Forschungsfrage: einheitenbasiert für Querschnittsprobleme, zeitbasiert für Prognosen.
• Zeitliche Leckagen können nicht nur durch Beobachtungen, sondern auch durch Prädiktoren auftreten. Verwenden Sie für Prognosen nur verzögerte oder zeitinvariante Prädiktoren. Die Verwendung zeitgleicher Variablen (z. B. die Verwendung der Arbeitslosigkeit im Jahr 2014 zur Vorhersage des Einkommens im Jahr 2014) ist konzeptionell falsch und führt zu zeitlichen Datenlecks.
• Passen Sie die Kreuzvalidierung an die Paneldaten an. Zufällige Okay-Faltungs-Lebensläufe, die in den meisten gebrauchsfertigen Softwarepaketen zu finden sind, sind ungeeignet, da sie zukünftige und vergangene Informationen vermischen. Verwenden Sie stattdessen rollierende oder expandierende Fenster für die Prognose oder einen geschichteten CV nach Einheiten/Gruppen für die Querschnittsvorhersage.
• Stellen Sie sicher, dass die Leistung außerhalb der Stichprobe anhand wirklich unsichtbarer Daten getestet wird und nicht anhand von Daten, die bereits während des Trainings aufgetreten sind.

Empirische Anwendung

Um diese Probleme zu veranschaulichen, analysieren wir ein ausgewogenes Panel von 3.058 US-Bezirken von 2000 bis 2019 und konzentrieren uns dabei ausschließlich auf sequentielle Prognosen. Wir betrachten zwei Aufgaben: ein Regressionsproblem – die Vorhersage des Professional-Kopf-Einkommens – und ein Klassifizierungsproblem – die Vorhersage, ob das Einkommen im Folgejahr sinken wird.

Wir führen Hunderte von Modellen, unterschiedliche Cut up-Strategien, die Verwendung gleichzeitiger Prädiktoren, die Einbeziehung verzögerter Ergebnisse und Algorithmen (Random Forest, XGBoost, Logit und OLS) durch. Dieses umfassende Design ermöglicht es uns zu quantifizieren, wie Leckagen die Leistung steigern. Abbildung 2 unten zeigt unsere wichtigsten Ergebnisse.

Panel A von Abbildung 2 zeigt die Prognoseleistung für Klassifizierungsaufgaben. Zufällige Aufteilungen führen zu einer sehr hohen Genauigkeit, aber das ist illusorisch: Das Modell hat bereits während des Trainings ähnliche Daten gesehen.

Panel B zeigt die Prognoseleistung für Regressionsaufgaben. Wiederum lassen zufällige Aufteilungen Modelle viel besser aussehen, als sie wirklich sind, während korrekte zeitbasierte Aufteilungen eine viel geringere, aber realistische Genauigkeit zeigen.

Abbildung 2 | Zeitliche Leckage im Prognoseproblem

Panel A – Klassifizierungsaufgabe

Panel B – Regressionsaufgabe

In der Arbeit zeigen wir auch, dass die Überschätzung der Modellgenauigkeit in Jahren, die von Verteilungsverschiebungen und Strukturbrüchen geprägt sind, wie etwa der Großen Rezession, deutlich ausgeprägter wird, was die Ergebnisse für politische Zwecke besonders irreführend macht.

Warum es wichtig ist

Datenlecks sind mehr als eine technische Falle. es hat Konsequenzen für die reale Welt. Bei Richtlinienanwendungen kann ein Modell, das während der Validierung sehr genau erscheint, nach der Bereitstellung zusammenbrechen, was zu falsch zugewiesenen Ressourcen, verpassten Krisen oder fehlgeleiteter Zielausrichtung führt. Im Geschäftsumfeld kann das gleiche Drawback zu schlechten Investitionsentscheidungen, ineffizienter Kundenansprache oder falschem Vertrauen in Risikobewertungen führen. Die Gefahr ist besonders groß, wenn Modelle des maschinellen Lernens als Frühwarnsysteme dienen sollen, bei denen fehlgeleitetes Vertrauen in überhöhte Leistung zu kostspieligen Ausfällen führen kann.

Im Gegensatz dazu liefern richtig entworfene Modelle, auch wenn sie auf dem Papier weniger genau sind, ehrliche und zuverlässige Vorhersagen, die sinnvolle Entscheidungen treffen können.

Wegbringen

ML hat das Potenzial, die Entscheidungsfindung sowohl in der Politik als auch in der Wirtschaft zu verändern, aber nur, wenn es richtig angewendet wird. Paneldaten bieten vielfältige Möglichkeiten, sind jedoch besonders anfällig für Datenlecks. Um verlässliche Erkenntnisse zu gewinnen, sollten Praktiker ihren ML-Workflow auf das Vorhersageziel ausrichten, sowohl zeitliche als auch querschnittliche Strukturen berücksichtigen und Validierungsstrategien verwenden, die zu optimistische Bewertungen und die Phantasm hoher Genauigkeit verhindern. Wenn diese Grundsätze befolgt werden, vermeiden Modelle die Falle einer überhöhten Leistung und bieten stattdessen Leitlinien, die politischen Entscheidungsträgern wirklich dabei helfen, Ressourcen zuzuweisen, und Unternehmen dabei helfen, fundierte strategische Entscheidungen zu treffen. Angesichts der schnellen Einführung von ML mit Paneldaten sowohl im öffentlichen als auch im privaten Bereich ist die Beseitigung dieser Fallstricke jetzt eine dringende Priorität für die angewandte Forschung.

Referenzen

A. Cerqua, M. Letta und G. Pinto, „Über den (falschen) Einsatz von maschinellem Lernen mit Paneldaten“, Oxford Bulletin of Economics and Statistics (2025): 1–13, https://doi.org/10.1111/obes.70019.

Dieser Artikel beschreibt die Architektur und das Design eines Heimassistent (HA) Integration namens House-Generative-Agent. Dieses Projekt verwendet LangChain Und LangGraph eine erstellen generativer KI-Agent das mit einer HA-Good-House-Umgebung interagiert und Aufgaben darin automatisiert. Der Makler versteht den Kontext Ihres Zuhauses, lernt Ihre Vorlieben kennen und interagiert mit Ihnen und Ihrem Zuhause, um Aktivitäten durchzuführen, die Sie für wertvoll halten. Zu den Hauptfunktionen gehören die Erstellung von Automatisierungen, die Analyse von Bildern und die Verwaltung von Heimatzuständen mithilfe verschiedener LLMs (Massive Language Fashions). Die Architektur umfasst sowohl cloudbasierte als auch Edge-basierte Modelle für optimale Leistung und Kosteneffizienz. Installationsanweisungen, Konfigurationsdetails und Informationen zur Architektur des Projekts und den verschiedenen verwendeten Modellen sind enthalten und können auf der Web site gefunden werden House-Generative-Agent GitHub. Das Projekt ist Open Supply und freut sich über Beiträge.

Dies sind einige der derzeit unterstützten Funktionen:

• Erstellen Sie komplexe House Assistant-Automatisierungen.
• Bildszenenanalyse und -verständnis.
• Heimatzustandsanalyse von Entitäten, Geräten und Bereichen.
• Vollständige Agentenkontrolle über zulässige Einheiten im Haus.
• Kurz- und Langzeitgedächtnis mittels semantischer Suche.
• Automatische Zusammenfassung des Heimatstatus zur Verwaltung der LLM-Kontextlänge.

Dies ist mein persönliches Projekt und ein Beispiel für das, was ich nenne lerngesteuertes Hacken. Das Projekt steht in keinem Zusammenhang mit meiner Arbeit bei Amazon, noch stehe ich in irgendeiner Weise mit den für House Assistant oder LangChain/LangGraph verantwortlichen Organisationen in Verbindung.

Das Erstellen eines Agenten zur Überwachung und Steuerung Ihres Zuhauses kann zu unerwarteten Aktionen führen und möglicherweise Ihr Zuhause und sich selbst aufgrund von LLM-Halluzinationen und Datenschutzbedenken einem Risiko aussetzen, insbesondere wenn Heimzustände und Benutzerinformationen cloudbasierten LLMs ausgesetzt werden. Ich habe vernünftige architektonische und gestalterische Entscheidungen getroffen, um diese Risiken zu mindern, aber sie können nicht vollständig beseitigt werden.

Eine wichtige frühe Entscheidung battle, auf einen Hybrid-Cloud-Edge-Ansatz zu setzen. Dies ermöglicht die Verwendung der ausgefeiltesten verfügbaren Argumentations- und Planungsmodelle, die dazu beitragen sollen, Halluzinationen zu reduzieren. Zur weiteren Minimierung von LLM-Fehlern werden einfachere, stärker aufgabenorientierte Kantenmodelle eingesetzt.

Eine weitere wichtige Entscheidung bestand darin, die Funktionen von LangChain zu nutzen, die es ermöglichen, vertrauliche Informationen vor LLM-Instruments zu verbergen und nur zur Laufzeit bereitzustellen. Die Software-Logik erfordert beispielsweise möglicherweise die Verwendung der ID des Benutzers, der eine Anfrage gestellt hat. Allerdings sollten solche Werte grundsätzlich nicht vom LLM kontrolliert werden. Die Manipulation der Benutzer-ID durch das LLM könnte Sicherheits- und Datenschutzrisiken mit sich bringen. Um dies zu mildern, habe ich das genutzt InjectedToolArg Anmerkung.

Darüber hinaus verursacht die Verwendung großer cloudbasierter LLMs erhebliche Cloud-Kosten, und die für die Ausführung von LLM-Edge-Modellen erforderliche Edge-{Hardware} kann teuer sein. Die kombinierten Betriebs- und Installationskosten dürften für den durchschnittlichen Benutzer derzeit unerschwinglich sein. Es bedarf einer branchenweiten Anstrengung, „LLMs so günstig wie CNNs zu machen“, um heimische Agenten auf den Massenmarkt zu bringen.

Es ist wichtig, sich dieser Risiken bewusst zu sein und zu verstehen, dass wir uns trotz dieser Abhilfemaßnahmen noch im Anfangsstadium dieses Projekts und der Hausmakler im Allgemeinen befinden. Es bleibt noch viel zu tun, um diese Agenten zu wirklich nützlichen und vertrauenswürdigen Assistenten zu machen.

Unten finden Sie eine allgemeine Ansicht der House-Generative-Agent-Architektur.

Die allgemeine Integrationsarchitektur folgt den Finest Practices, wie in beschrieben House Assistant Core und ist konform mit House Assistant Group Retailer (HACS) Veröffentlichungsanforderungen.

Der Agent wird mit LangGraph erstellt und nutzt die HA Gespräch Komponente zur Interaktion mit dem Benutzer. Der Agent verwendet die House Assistant LLM-API, um den Zustand des Hauses abzurufen und die ihm zur Verfügung stehenden nativen HA-Instruments zu verstehen. Alle anderen dem Agenten zur Verfügung stehenden Instruments habe ich mit LangChain implementiert. Der Agent verwendet mehrere LLMs, ein großes und sehr genaues Primärmodell für Excessive-Stage-Argumentation, kleinere spezialisierte Hilfsmodelle für die Kamerabildanalyse, eine Primärmodell-Kontextzusammenfassung und eine Einbettungsgenerierung für die langfristige semantische Suche. Das Primärmodell ist cloudbasiert und die Hilfsmodelle sind Edge-basiert und laufen unter dem Ollama Framework auf einem Laptop zu Hause installieren.

Nachfolgend sind die derzeit verwendeten Modelle zusammengefasst.

LangGraph-basierter Agent

LangGraph unterstützt den Konversationsagenten und ermöglicht es Ihnen, so schnell wie möglich zustandsbehaftete Multi-Akteur-Anwendungen unter Verwendung von LLMs zu erstellen. Es erweitert die Fähigkeiten von LangChain und bietet die Möglichkeit, zyklische Diagramme zu erstellen und zu verwalten, die für die Entwicklung komplexer Agentenlaufzeiten unerlässlich sind. Ein Diagramm modelliert den Agenten-Workflow, wie im Bild unten dargestellt.

Der Agenten-Workflow verfügt über fünf Knoten, wobei jedes Python-Modul den Standing des Agenten ändert, eine gemeinsame Datenstruktur. Die Kanten zwischen den Knoten stellen die zulässigen Übergänge zwischen ihnen dar, wobei durchgezogene Linien bedingungslos und gestrichelte Linien bedingt sind. Knoten erledigen die Arbeit und Kanten sagen, was als nächstes zu tun ist.

Der __Start__ Und __Ende__ Knoten informieren den Graphen darüber, wo er beginnen und enden soll. Der Agent Der Knoten führt das primäre LLM aus, und wenn er sich für die Verwendung eines Instruments entscheidet, wird das Aktion Der Knoten führt das Software aus und gibt dann die Kontrolle an den zurück Agent. Der summary_and_trim Der Knoten verarbeitet den Kontext des LLM, um das Wachstum zu verwalten und gleichzeitig die Genauigkeit beizubehalten Agent verfügt über kein Software zum Anrufen und die Anzahl der Nachrichten erfüllt die unten genannten Bedingungen.

LLM-Kontextmanagement

Sie müssen die Kontextlänge von LLMs sorgfältig verwalten, um Kosten, Genauigkeit und Latenz auszugleichen und das Auslösen von Ratenbegrenzungen wie der Token-pro-Minute-Beschränkung von OpenAI zu vermeiden. Das System steuert die Kontextlänge des Primärmodells auf zwei Arten: Es kürzt die Nachrichten im Kontext, wenn sie einen maximalen Parameter überschreiten, und der Kontext wird zusammengefasst, sobald die Anzahl der Nachrichten einen anderen Parameter überschreitet. Diese Parameter sind in konfigurierbar const.py; Ihre Beschreibung finden Sie weiter unten.

• CONTEXT_MAX_MESSAGES | Nachrichten, die vor dem Löschen im Kontext bleiben | Commonplace = 100
• CONTEXT_SUMMARIZE_THRESHOLD | Nachrichten im Kontext vor der Zusammenfassungsgenerierung | Commonplace = 20

Der summary_and_trim Der Knoten im Diagramm schneidet die Nachrichten erst nach der Inhaltszusammenfassung ab. Sie können den diesem Knoten zugeordneten Python-Code im folgenden Snippet sehen.

async def _summarize_and_trim(
state: State, config: RunnableConfig, *, retailer: BaseStore
) -> dict(str, listing(AnyMessage)):
"""Coroutine to summarize and trim message historical past."""
abstract = state.get("abstract", "")
if abstract:
summary_message = SUMMARY_PROMPT_TEMPLATE.format(abstract=abstract)
else:
summary_message = SUMMARY_INITIAL_PROMPT
messages = (
(SystemMessage(content material=SUMMARY_SYSTEM_PROMPT)) +
state("messages") +
(HumanMessage(content material=summary_message))
)
mannequin = config("configurable")("vlm_model")
choices = config("configurable")("choices")
model_with_config = mannequin.with_config(
config={
"mannequin": choices.get(
CONF_VLM,
RECOMMENDED_VLM,
),
"temperature": choices.get(
CONF_SUMMARIZATION_MODEL_TEMPERATURE,
RECOMMENDED_SUMMARIZATION_MODEL_TEMPERATURE,
),
"top_p": choices.get(
CONF_SUMMARIZATION_MODEL_TOP_P,
RECOMMENDED_SUMMARIZATION_MODEL_TOP_P,
),
"num_predict": VLM_NUM_PREDICT,
}
)
LOGGER.debug("Abstract messages: %s", messages)
response = await model_with_config.ainvoke(messages)
# Trim message historical past to handle context window size.
trimmed_messages = trim_messages(
messages=state("messages"),
token_counter=len,
max_tokens=CONTEXT_MAX_MESSAGES,
technique="final",
start_on="human",
include_system=True,
)
messages_to_remove = (m for m in state("messages") if m not in trimmed_messages)
LOGGER.debug("Messages to take away: %s", messages_to_remove)
remove_messages = (RemoveMessage(id=m.id) for m in messages_to_remove)
return {"abstract": response.content material, "messages": remove_messages}

Latenz

Die Latenz zwischen Benutzeranfragen oder dem zeitnahen Handeln des Agenten im Namen des Benutzers ist für Sie von entscheidender Bedeutung und muss beim Entwurf berücksichtigt werden. Ich habe mehrere Techniken verwendet, um die Latenz zu reduzieren, einschließlich der Verwendung spezieller, kleinerer Hilfs-LLMs, die am Edge ausgeführt werden, und der Erleichterung des Zwischenspeicherns von Eingabeaufforderungen für primäre Modelle, indem ich die Eingabeaufforderungen so strukturiert habe, dass sie statische Inhalte wie Anweisungen und Beispiele im Voraus und variable Inhalte wie benutzerspezifisch bereitstellen Informationen am Ende. Diese Techniken reduzieren auch die Nutzungskosten des Primärmodells erheblich.

Unten sehen Sie die typische Latenzleistung.

• HA-Absichten (z. B. ein Licht einschalten) | < 1 Sekunde
• Kamerabild analysieren (erste Anfrage) | < 3 Sekunden
• Automatisierung hinzufügen | < 1 Sekunde
• Speicheroperationen | < 1 Sekunde

Werkzeuge

Der Agent kann HA-Instruments wie in angegeben verwenden LLM-API und andere im LangChain-Framework integrierte Instruments, wie in definiert instruments.py. Darüber hinaus können Sie die LLM-API auch mit eigenen Instruments erweitern. Der Code gibt dem primären LLM die Liste der Instruments, die er aufrufen kann, zusammen mit Anweisungen zu deren Verwendung in seiner Systemmeldung und im Dokumentstring der Python-Funktionsdefinition des Instruments. Ein Beispiel für Docstring-Anweisungen finden Sie im Code-Snippet unten für get_and_analyze_camera_image Werkzeug.

@device(parse_docstring=False)
async def get_and_analyze_camera_image( # noqa: D417
camera_name: str,
detection_keywords: listing(str) | None = None,
*,
# Cover these arguments from the mannequin.
config: Annotated(RunnableConfig, InjectedToolArg()),
) -> str:
"""
Get a digital camera picture and carry out scene evaluation on it.
Args:
camera_name: Title of the digital camera for scene evaluation.
detection_keywords: Particular objects to search for in picture, if any.
For instance, If consumer says "examine the entrance porch digital camera for
containers and canines", detection_keywords could be ("containers", "canines").
"""
hass = config("configurable")("hass")
vlm_model = config("configurable")("vlm_model")
choices = config("configurable")("choices")
picture = await _get_camera_image(hass, camera_name)
return await _analyze_image(vlm_model, choices, picture, detection_keywords)

Wenn sich der Agent für die Verwendung eines Instruments entscheidet, wird der LangGraph-Knoten verwendet Aktion wird eingegeben und der Code des Knotens führt das Software aus. Der Knoten verwendet einen einfachen Fehlerwiederherstellungsmechanismus, der den Agenten auffordert, im Falle eines Fehlers erneut zu versuchen, das Software mit korrigierten Parametern aufzurufen. Der folgende Codeausschnitt zeigt den damit verbundenen Python-Code Aktion Knoten.

async def _call_tools(
state: State, config: RunnableConfig, *, retailer: BaseStore
) -> dict(str, listing(ToolMessage)):
"""Coroutine to name House Assistant or langchain LLM instruments."""
# Software calls would be the final message in state.
tool_calls = state("messages")(-1).tool_calls
langchain_tools = config("configurable")("langchain_tools")
ha_llm_api = config("configurable")("ha_llm_api")
tool_responses: listing(ToolMessage) = ()
for tool_call in tool_calls:
tool_name = tool_call("identify")
tool_args = tool_call("args")
LOGGER.debug(
"Software name: %s(%s)", tool_name, tool_args
)
def _handle_tool_error(err:str, identify:str, tid:str) -> ToolMessage:
return ToolMessage(
content material=TOOL_CALL_ERROR_TEMPLATE.format(error=err),
identify=identify,
tool_call_id=tid,
standing="error",
)
# A langchain device was known as.
if tool_name in langchain_tools:
lc_tool = langchain_tools(tool_name.decrease())
# Present hidden args to device at runtime.
tool_call_copy = copy.deepcopy(tool_call)
tool_call_copy("args").replace(
{
"retailer": retailer,
"config": config,
}
)
strive:
tool_response = await lc_tool.ainvoke(tool_call_copy)
besides (HomeAssistantError, ValidationError) as e:
tool_response = _handle_tool_error(repr(e), tool_name, tool_call("id"))
# A House Assistant device was known as.
else:
tool_input = llm.ToolInput(
tool_name=tool_name,
tool_args=tool_args,
)
strive:
response = await ha_llm_api.async_call_tool(tool_input)
tool_response = ToolMessage(
content material=json.dumps(response),
tool_call_id=tool_call("id"),
identify=tool_name,
)
besides (HomeAssistantError, vol.Invalid) as e:
tool_response = _handle_tool_error(repr(e), tool_name, tool_call("id"))
LOGGER.debug("Software response: %s", tool_response)
tool_responses.append(tool_response)
return {"messages": tool_responses}

Die LLM-API weist den Agenten an, Instruments immer über HA aufzurufen Integrierte Absichten beim Steuern von House Assistant und zum Verwenden der Absichten „HassTurnOn“ zum Sperren und „HassTurnOff“ zum Entsperren einer Sperre. Eine Absicht beschreibt die Absicht eines Benutzers, die durch Benutzeraktionen generiert wird.

Unten sehen Sie die Liste der LangChain-Instruments, die der Agent verwenden kann.

• get_and_analyze_camera_image | Führen Sie eine Szenenanalyse für das Bild einer Kamera durch
• upsert_memory | einen Speicher hinzufügen oder aktualisieren
• add_automation | Erstellen und registrieren Sie eine HA-Automatisierung
• get_entity_history | Fragen Sie die HA-Datenbank nach dem Entitätsverlauf ab

{Hardware}

Ich habe die HA-Set up auf einem Raspberry Pi 5 mit SSD-Speicher, Zigbee und LAN-Konnektivität erstellt. Ich habe die Edge-Modelle unter Ollama auf einem Ubuntu-basierten Server mit einer AMD 64-Bit-CPU mit 3,4 GHz, einer Nvidia 3090-GPU und 64 GB System-RAM bereitgestellt. Der Server befindet sich im selben LAN wie der Raspberry Pi.

Ich verwende dieses Projekt seit einigen Wochen zu Hause und finde es nützlich, aber in einigen Bereichen, an denen ich arbeiten werde, frustrierend. Nachfolgend finden Sie eine Liste der Vor- und Nachteile meiner Erfahrungen mit dem Agenten.

Vorteile

• Die Kamerabild-Szenenanalyse ist sehr nützlich und flexibel, da Sie quick alles abfragen können und sich nicht wie bei einem herkömmlichen ML-Ansatz um den richtigen Klassifikator kümmern müssen.
• Automatisierungen sind sehr einfach einzurichten und können recht komplex sein. Es ist überwältigend, wie intestine das primäre LLM bei der Generierung von HA-konformem YAML ist.
• Die Latenz ist in den meisten Fällen durchaus akzeptabel.
• Mit LangChain und LangGraph ist es sehr einfach, zusätzliche LLM-Instruments und Diagrammzustände hinzuzufügen.

Nachteile

• Die Kamerabildanalyse scheint weniger genau als herkömmliche ML-Ansätze. Beispielsweise ist es für das Modell sehr schwierig, Pakete zu erkennen, die teilweise verdeckt sind.
• Die Kosten für die Primärmodellierung sind hoch. Der Betrieb eines einzelnen Paketdetektors alle 30 Minuten kostet etwa 2,50 US-Greenback professional Tag.
• Die Verwendung strukturierter Modellausgaben für die Hilfs-LLMs, die die nachgelagerte LLM-Verarbeitung erleichtern würden, verringert die Genauigkeit erheblich.
• Der Agent muss proaktiver sein. Durch das Hinzufügen eines Planungsschritts zum Agentendiagramm wird dieses Drawback hoffentlich behoben.

Hier sind einige Beispiele dafür, was Sie mit der House-Generative-Agent (HGA)-Integration tun können, wie durch Screenshots des Help-Dialogs veranschaulicht, die ich während der Interaktionen mit meiner HA-Set up gemacht habe.

• Erstellen Sie eine Automatisierung, die regelmäßig ausgeführt wird.

Der folgende Ausschnitt zeigt, dass der Agent YAML basierend auf dem, was er generiert und als HA-Automatisierung registriert hat, fließend beherrscht.

alias: Verify Litter Field Waste Drawer
triggers:
- minutes: /30
set off: time_pattern
circumstances:
- situation: numeric_state
entity_id: sensor.litter_robot_4_waste_drawer
above: 90
actions:
- knowledge:
message: The Litter Field waste drawer is greater than 90% full!
motion: notify.notify

• Überprüfen Sie mehrere Kameras (Video vom Autor).

https://github.com/user-attachments/property/230baae5-8702-4375-a3f0-ffa981ee66a3

• Fassen Sie den Heimatstaat zusammen (Video des Autors).

https://github.com/user-attachments/property/96f834a8-58cc-4bd9-a899-4604c1103a98

• Langzeitgedächtnis mit semantischer Suche.

Zunächst einmal brauchen wir Daten.

Ich habe Daten zu allen Gesetzen heruntergeladen, über die abgestimmt wurde, und wie jedes Mitglied des Kongresses von 2023 bis 2024 bis zum 18. Mai abgestimmt hat. Alle Daten sind beim brasilianischen C verfügbarDas offene Datenportal von ongress. Anschließend habe ich zwei verschiedene Pandas-Datenrahmen erstellt, einen mit allen Gesetzen, über die abgestimmt wurde, und einen anderen mit der Artwork und Weise, wie jedes Kongressmitglied bei jeder Abstimmung abgestimmt hat.

votacoes = pd.concat((pd.read_csv('votacoes-2023.csv', header=0, sep=';'),  pd.read_csv('votacoes-2024.csv', header=0, sep=';')))
votacoes_votos_dep = pd.concat((pd.read_csv('votacoesVotos-2023.csv', sep=';', quoting=1) ,  pd.read_csv('votacoesVotos-2024.csv', sep=';', on_bad_lines='warn', quoting=1, encoding='utf-8')))

Zum Votacoes Datenrahmen, ich habe nur die Einträge mit ausgewählt idOrgao von 180, was bedeutet, dass sie in der Hauptkammer des Kongresses gewählt wurden. Wir haben additionally die Daten für die Stimmen der meisten Kongressmitglieder. Dann habe ich die Liste der verwendet votacoes_Ids um die zu filtern votacoes_votos_dep Datenrahmen.

plen = votacoes(votacoes('idOrgao') == 180)
votacoes_ids = plen('id').distinctive()
votacoes_votos_dep = votacoes_votos_dep(votacoes_votos_dep('idVotacao').isin(votacoes_ids))

Nun, im votacoes_votos_dep, Bei jeder Abstimmung handelt es sich um eine Zeile mit dem Namen des Kongressmitglieds und der Abstimmungssitzungs-ID, um zu identifizieren, auf wen und worauf sich die Abstimmung bezieht. Deshalb habe ich eine Pivot-Tabelle erstellt, in der jede Zeile ein Kongressmitglied darstellt und jede Spalte sich auf eine Stimme bezieht. Dabei habe ich „Ja“ als 1 und „Nein“ als 0 kodiert und alle Stimmen gelöscht, bei denen mehr als 280 Abgeordnete nicht abgestimmt haben.

votacoes_votos_dep('voto_numerico') = votacoes_votos_dep('voto').map({'Sim': 1, 'Não':0})
votes_pivot = votacoes_votos_dep.pivot_table(index='deputado_nome', columns='idVotacao', values='voto_numerico').dropna(axis=1, thresh=280)

Bevor ich die Ähnlichkeitsmatrix berechnete, habe ich alle verbleibenden NAs mit 0,5 gefüllt, um die Positionierung des Kongressmitglieds nicht zu beeinträchtigen. Schließlich berechnen wir die Ähnlichkeit zwischen den Vektoren jedes Stellvertreters mithilfe der Kosinusähnlichkeit und speichern sie in einem Datenrahmen.

from sklearn.metrics.pairwise import cosine_similarity
similarity_matrix = cosine_similarity(votes_pivot)
similarity_df = pd.DataFrame(similarity_matrix, index=votes_pivot.index, columns=votes_pivot.index)

Nutzen Sie nun die Informationen über die Abstimmungsähnlichkeiten zwischen Kongressabgeordneten, um mithilfe von N ein Netzwerk aufzubauenetworkx. Ein Knoten repräsentiert jedes Mitglied.

import networkx as nx
names = similarity_df.columns
# Create the graph as earlier than
G = nx.Graph()
for i, title in enumerate(names):
G.add_node(title)

Dann stellen die Kanten, die zwei Knoten verbinden, eine Ähnlichkeit von mindestens 75 % des Abstimmungsverhaltens der beiden Kongressabgeordneten dar. Um der Tatsache Rechnung zu tragen, dass einige Kongressabgeordnete Dutzende von Kollegen mit einem hohen Grad an Ähnlichkeit haben, habe ich nur die ersten 25 Kongressabgeordneten mit der höchsten Ähnlichkeit ausgewählt, um ihnen einen Vorteil zu verschaffen.

threshold = 0.75
for i in vary(len(similarity_matrix)):
for j in vary(i + 1, len(similarity_matrix)):
if similarity_matrix(i)(j) > threshold:
# G.add_edge(names(i), names(j), weight=similarity_matrix(i)(j))
counter(names(i)).append((names(j), similarity_matrix(i)(j)))
for supply, goal in counter.gadgets():
selected_targets = sorted(goal, key=lambda x: x(1), reverse=True)(:26)
for goal, weight in selected_targets:
G.add_edge(supply, goal, weight=weight)

Um das Netzwerk zu visualisieren, müssen Sie die Place jedes Knotens in der Ebene bestimmen. Ich habe mich für das Federlayout entschieden, bei dem die Kanten als Federn verwendet werden, die Knoten zusammenhalten und gleichzeitig versuchen, sie zu trennen. Das Hinzufügen eines Startwerts ermöglicht die Reproduzierbarkeit, da es sich um einen zufälligen Prozess handelt.

pos = nx.spring_layout(G, ok=0.1,  iterations=50, seed=29)

Abschließend zeichnen wir das Netzwerk mithilfe einer Go-Figur auf und fügen die Kanten und Knoten basierend auf ihrer Place einzeln hinzu.

# Create Edges
edge_x = ()
edge_y = ()
for edge in G.edges():
x0, y0 = pos(edge(0))
x1, y1 = pos(edge(1))
edge_x.lengthen((x0, x1, None))
edge_y.lengthen((y0, y1, None))
# Add edges as a scatter plot
edge_trace = go.Scatter(x=edge_x, y=edge_y, line=dict(width=0.5, shade='#888'), hoverinfo='none', mode='traces')
# Create Nodes
node_x = ()
node_y = ()
for node in G.nodes():
x, y = pos(node)
node_x.append(x)
node_y.append(y)
# Add nodes as a scatter plot
node_trace = go.Scatter(x=node_x, y=node_y, mode='markers+textual content', hoverinfo='textual content', marker=dict(showscale=True, colorscale='YlGnBu', dimension=10, shade=(), line_width=2))
# Add textual content to the nodes
node_trace.textual content = listing(G.nodes())
# Create a determine
fig = go.Determine(knowledge=(edge_trace, node_trace),
structure=go.Format(showlegend=False, hovermode='closest', margin=dict(b=0,l=0,r=0,t=0), xaxis=dict(showgrid=False, zeroline=False, showticklabels=False), yaxis=dict(showgrid=False, zeroline=False, showticklabels=False)))
fig.present()

Ergebnis:

Nun, es ist ein guter Anfang. Es sind verschiedene Cluster von Kongressabgeordneten zu sehen, was darauf hindeutet, dass die politische Ausrichtung und die Bündnisse im Kongress genau erfasst werden. Aber es ist ein Chaos, und es ist unmöglich, wirklich zu erkennen, was vor sich geht.

Um die Visualisierung zu verbessern, habe ich dafür gesorgt, dass der Title nur dann angezeigt wird, wenn Sie mit der Maus über den Knoten fahren. Außerdem habe ich die Knoten entsprechend den auf der Web site des Kongresses verfügbaren politischen Parteien und Koalitionen eingefärbt und ihre Größe danach bestimmt, mit wie vielen Kanten sie verbunden sind.

Es ist viel besser. Wir haben drei Cluster mit einigen Knoten dazwischen und jeweils einigen größeren. Außerdem gibt es in jedem Cluster einen Großteil einer bestimmten Farbe. Nun, lassen Sie es uns genauer analysieren.