print("n" + "="*70 + "n4. Variable-length packed batch — no padding wasten" + "="*70)
seqlens = (37, 120, 8, 200)
whole = sum(seqlens)
H, Ok = 8, 64
q = torch.randn(1, whole, H, Ok, machine=machine, dtype=torch.float16)
okay = torch.randn(1, whole, H, Ok, machine=machine, dtype=torch.float16)
v = torch.randn(1, whole, H, Ok, machine=machine, dtype=torch.float16)
attempt:
   bias = ab.BlockDiagonalMask.from_seqlens(seqlens)
   out_packed = xops.memory_efficient_attention(q, okay, v, attn_bias=bias)
   s0 = seqlens(0)
   ref0 = vanilla_attention(q(:, :s0), okay(:, :s0), v(:, :s0)).half()
   print("packed form         :", tuple(out_packed.form), "(all", whole, "tokens, no pad)")
   print("segment-0 max diff   : {:.2e}".format((out_packed(:, :s0) - ref0).abs().max().merchandise()))
   cbias = ab.BlockDiagonalCausalMask.from_seqlens(seqlens)
   _ = xops.memory_efficient_attention(q, okay, v, attn_bias=cbias)
   print("-> additionally did a packed CAUSAL move. That is how vLLM-style engines")
   print("   batch requests of various lengths with zero padding overhead.")
   splits = bias.cut up(out_packed)
   print("recovered segments   :", (tuple(t.form) for t in splits))
besides Exception as e:
   print("BlockDiagonalMask path skipped on this model/backend:", repr(e))
print("n" + "="*70 + "n5. Grouped-query consideration (5-D BMGHK format)n" + "="*70)
B, M, Ok = 2, 256, 64
n_q_heads, n_kv_heads = 8, 2
G, Hq = n_kv_heads, n_q_heads // n_kv_heads
attempt:
   qg = torch.randn(B, M, G, Hq, Ok, machine=machine, dtype=torch.float16)
   kg = torch.randn(B, M, G, 1,  Ok, machine=machine, dtype=torch.float16)
   vg = torch.randn(B, M, G, 1,  Ok, machine=machine, dtype=torch.float16)
   out_gqa = xops.memory_efficient_attention(qg, kg, vg)
   print("GQA output form     :", tuple(out_gqa.form), "= (B, M, G, Hq, Ok)")
   print(f"-> {n_q_heads} question heads, solely {n_kv_heads} KV heads: smaller KV-cache,")
   print("   which is strictly what Llama-/Mistral-class fashions use at inference.")
besides Exception as e:
   print("GQA 5-D path skipped on this model/backend:", repr(e))

Bild vom Herausgeber

# Einführung

Dank große Sprachmodelle (LLMs) verfügen wir heutzutage über beeindruckende, unglaublich nützliche Anwendungen wie Zwillinge, ChatGPTUnd Claudeum nur einige zu nennen. Allerdings wissen nur wenige Menschen, dass die zugrunde liegende Architektur hinter einem LLM als a bezeichnet wird Transformator. Diese Architektur ist sorgfältig darauf ausgelegt, auf eine ganz besondere und etwas besondere Weise zu „denken“ – additionally Daten zu verarbeiten, die die menschliche Sprache beschreiben. Sind Sie daran interessiert, ein umfassendes Verständnis darüber zu erlangen, was im Inneren dieser sogenannten Transformatoren passiert?

Dieser Artikel beschreibt in einem sanften, verständlichen und eher untechnischen Ton, wie Transformatormodelle, die hinter LLMs sitzen, Eingabeinformationen wie Benutzeraufforderungen analysieren und wie sie Wort für Wort (oder, etwas technischer gesagt, Token für Token) kohärenten, aussagekräftigen und relevanten Ausgabetext generieren.

# Erste Schritte: Sprache für Maschinen verständlich machen

Das erste Schlüsselkonzept, das es zu begreifen gilt, ist Folgendes KI-Modelle verstehen die menschliche Sprache nicht wirklich; Sie verstehen nur Zahlen und operieren mit ihnen, und Transformatoren hinter LLMs bilden da keine Ausnahme. Daher ist es notwendig, die menschliche Sprache – additionally den Textual content – in eine Kind umzuwandeln, die der Transformator vollständig verstehen kann, bevor er ihn tiefgreifend verarbeiten kann.

Anders ausgedrückt: Die ersten Schritte vor dem Eintritt in den Kern und die innersten Schichten des Transformators konzentrieren sich in erster Linie darauf, diesen Rohtext in eine numerische Darstellung umzuwandeln, die die wichtigsten Eigenschaften und Merkmale des Originaltexts unter der Haube beibehält. Sehen wir uns diese drei Schritte an.

Sprache für Maschinen verständlich machen (zum Vergrößern anklicken)

// Tokenisierung

Der Tokenizer ist der erste Akteur, der die Szene betritt. Er arbeitet mit dem Transformatormodell zusammen und ist dafür verantwortlich, den Rohtext in kleine Stücke, sogenannte Token, zu zerlegen. Abhängig vom verwendeten Tokenizer können diese Token in den meisten Fällen Wörtern entsprechen, manchmal können Token jedoch auch Teile von Wörtern oder Satzzeichen sein. Darüber hinaus verfügt jedes Token in einer Sprache über eine eindeutige numerische Kennung. Dies ist der Fall, wenn Textual content nicht mehr zu Textual content, sondern zu Zahlen wird: alles auf Token-Ebene, wie in diesem Beispiel gezeigt, in dem ein einfacher Tokenizer einen Textual content mit fünf Wörtern in fünf Token-Bezeichner umwandelt, eine professional Wort:

Tokenisierung von Textual content in Token-Identifikatoren

// Token-Einbettungen

Als nächstes wird jede Token-ID in einen ( d )-dimensionalen Vektor umgewandelt, der eine Liste von Zahlen der Größe ( d ) ist. Diese vollständige Darstellung eines Tokens als Einbettung ist wie eine Beschreibung der Gesamtbedeutung dieses Tokens, sei es ein Wort, ein Teil davon oder ein Satzzeichen. Der Zauber liegt darin, dass Token mit ähnlichen Bedeutungskonzepten verbunden sind Königin Und Kaiserinwerden ähnliche Einbettungsvektoren haben.

// Positionskodierung

Bisher enthielt eine Token-Einbettung Informationen in Kind einer Zahlensammlung, diese Informationen beziehen sich jedoch immer noch isoliert auf einen einzelnen Token. Bei einem „Stück Sprache“ wie einer Textsequenz ist es jedoch nicht nur wichtig, die darin enthaltenen Wörter oder Token zu kennen, sondern auch deren Place im Textual content, zu dem sie gehören. Bei der Positionskodierung handelt es sich um einen Prozess, der mithilfe mathematischer Funktionen in jedes Token einige zusätzliche Informationen über seine Place in der ursprünglichen Textsequenz einbettet.

# Die Transformation durch den Kern des Transformer-Modells

Nachdem nun die numerische Darstellung jedes Tokens Informationen über seine Place in der Textsequenz enthält, ist es an der Zeit, die erste Ebene des Hauptteils des Transformatormodells zu betreten. Der Transformator ist eine sehr tiefe Architektur mit vielen gestapelten Komponenten, die im gesamten System repliziert werden. Es gibt zwei Arten von Transformatorschichten – die Encoderschicht und die Decoderschicht –, aber der Einfachheit halber werden wir in diesem Artikel keine differenzierte Unterscheidung zwischen ihnen vornehmen. Beachten Sie zunächst, dass es in einem Transformator zwei Arten von Schichten gibt, auch wenn beide viele Gemeinsamkeiten haben.

Die Transformation durch den Kern des Transformatormodells (zum Vergrößern anklicken)

// Mehrköpfige Aufmerksamkeit

Dies ist der erste große Teilprozess, der innerhalb einer Transformatorschicht stattfindet, und möglicherweise das wirkungsvollste und markanteste Merkmal von Transformatormodellen im Vergleich zu anderen Arten von KI-Systemen. Die mehrköpfige Aufmerksamkeit ist ein Mechanismus, der es einem Token ermöglicht, die anderen Token in der Sequenz zu beobachten oder „auf sie zu achten“. Es sammelt und integriert nützliche Kontextinformationen in seine eigene Token-Darstellung, insbesondere sprachliche Aspekte wie grammatikalische Beziehungen, langfristige Abhängigkeiten zwischen Wörtern, die im Textual content nicht unbedingt nebeneinander liegen, oder semantische Ähnlichkeiten. Zusammenfassend lässt sich sagen, dass dank dieses Mechanismus verschiedene Aspekte der Relevanz und Beziehungen zwischen Teilen des Originaltextes erfolgreich erfasst werden. Nachdem eine Token-Darstellung diese Komponente durchlaufen hat, erhält sie am Ende eine reichhaltigere, kontextbewusstere Darstellung über sich selbst und den Textual content, zu dem sie gehört.

Einige Transformer-Architekturen, die für bestimmte Aufgaben wie die Übersetzung von Textual content von einer Sprache in eine andere entwickelt wurden, analysieren über diesen Mechanismus auch mögliche Abhängigkeiten zwischen Token und betrachten dabei sowohl den Eingabetext als auch den bisher generierten Ausgabetext (übersetzt), wie unten gezeigt:

Mehrköpfige Aufmerksamkeit bei Übersetzungstransformatoren

// Feed-Ahead-Subschicht für neuronale Netze

Vereinfacht ausgedrückt besteht die zweite gemeinsame Stufe innerhalb jeder replizierten Schicht des Transformators nach dem Durchlaufen der Aufmerksamkeit aus einer Reihe verketteter neuronaler Netzwerkschichten, die unsere angereicherten Token-Darstellungen weiter verarbeiten und dabei helfen, zusätzliche Muster zu erlernen. Dieser Prozess gleicht einer weiteren Schärfung dieser Darstellungen sowie der Identifizierung und Verstärkung relevanter Merkmale und Muster. Letztendlich sind diese Schichten der Mechanismus, mit dem nach und nach ein allgemeines, zunehmend abstraktes Verständnis des gesamten verarbeiteten Textes erlernt wird.

Der Prozess des Durchlaufens mehrköpfiger Aufmerksamkeits- und Feed-Ahead-Unterschichten wird in dieser Reihenfolge mehrmals wiederholt: so oft wie die Anzahl der replizierten Transformatorschichten, die wir haben.

// Endziel: Das nächste Wort vorhersagen

Nach mehrmaliger abwechselnder Wiederholung der beiden vorherigen Schritte hätten die symbolischen Darstellungen, die aus dem ursprünglichen Textual content stammten, es dem Modell ermöglichen sollen, ein sehr tiefes Verständnis zu erlangen und komplexe und subtile Zusammenhänge zu erkennen. An diesem Punkt erreichen wir die letzte Komponente des Transformatorstapels: eine spezielle Schicht, die die endgültige Darstellung in eine Wahrscheinlichkeit für jedes mögliche Token im Vokabular umwandelt. Das heißt, wir berechnen – basierend auf allen dabei gewonnenen Informationen – eine Wahrscheinlichkeit dafür, dass jedes Wort in der Zielsprache das nächste Wort ist, das das Transformatormodell (oder das LLM) ausgeben sollte. Das Modell wählt schließlich das Token oder Wort mit der höchsten Wahrscheinlichkeit als nächstes aus, das es als Teil der Ausgabe für den Endbenutzer generiert. Der gesamte Prozess wiederholt sich für jedes Wort, das als Teil der Modellantwort generiert werden soll.

# Zusammenfassung

Dieser Artikel bietet einen sanften und konzeptionellen Rundgang durch die Reise textbasierter Informationen, wenn sie durch die charakteristische Modellarchitektur hinter LLMs fließen: den Transformator. Nachdem Sie dies gelesen haben, haben Sie hoffentlich ein besseres Verständnis dafür gewonnen, was in Modellen wie denen hinter ChatGPT vor sich geht.

Iván Palomares Carrascosa ist ein führender Autor, Redner und Berater in den Bereichen KI, maschinelles Lernen, Deep Studying und LLMs. Er schult und leitet andere darin, KI in der realen Welt zu nutzen.

Der LLM Graph Transformer arbeitet in zwei unterschiedlichen Modi, die jeweils darauf ausgelegt sind, mithilfe eines LLM in unterschiedlichen Szenarien Diagramme aus Dokumenten zu generieren.

1. Werkzeugbasierter Modus (Customary): Wenn das LLM strukturierte Ausgaben oder Funktionsaufrufe unterstützt, nutzt dieser Modus die LLM ist integriert with_structured_outputWerkzeuge zu benutzen. Die Device-Spezifikation definiert das Ausgabeformat und stellt sicher, dass Entitäten und Beziehungen auf strukturierte, vordefinierte Weise extrahiert werden. Dies ist auf der linken Seite des Bildes dargestellt, wo Code für die Klassen Node und Relationship angezeigt wird.
2. Aufforderungsbasierter Modus (Fallback): In Situationen, in denen das LLM keine Instruments oder Funktionsaufrufe unterstützt, greift der LLM Graph Transformer auf einen rein auf Eingabeaufforderungen basierenden Ansatz zurück. In diesem Modus wird das Ausgabeformat mithilfe von Few-Shot-Prompts definiert, wodurch der LLM angeleitet wird, Entitäten und Beziehungen auf textbasierte Weise zu extrahieren. Die Ergebnisse werden dann durch eine benutzerdefinierte Funktion analysiert, die die Ausgabe des LLM in ein JSON-Format konvertiert. Dieser JSON wird zum Auffüllen von Knoten und Beziehungen verwendet, genau wie im Device-basierten Modus, aber hier wird das LLM vollständig durch Eingabeaufforderungen und nicht durch strukturierte Instruments gesteuert. Dies wird auf der rechten Seite des Bildes angezeigt, wo eine Beispielaufforderung und die resultierende JSON-Ausgabe bereitgestellt werden.

Diese beiden Modi stellen sicher, dass der LLM Graph Transformer an verschiedene LLMs anpassbar ist, sodass er Diagramme entweder direkt mithilfe von Instruments oder durch Parsen der Ausgabe einer textbasierten Eingabeaufforderung erstellen kann.

Beachten Sie, dass Sie die aufforderungsbasierte Extraktion auch bei Modellen verwenden können, die Instruments/Funktionen unterstützen, indem Sie das Attribut festlegen ignore_tools_usage=True.

Werkzeugbasierte Extraktion

Wir haben uns zunächst für einen Device-basierten Ansatz zur Extraktion entschieden, da dadurch der Bedarf an umfangreichen Immediate-Engineering- und benutzerdefinierten Parsing-Funktionen minimiert wurde. In LangChain ist die with_structured_output Mit der Methode können Sie Informationen mithilfe von Instruments oder Funktionen extrahieren, wobei die Ausgabe entweder über eine JSON-Struktur oder ein Pydantic-Objekt definiert wird. Persönlich finde ich Pydantic-Objekte klarer, deshalb haben wir uns dafür entschieden.

Wir beginnen mit der Definition von a Node Klasse.

class Node(BaseNode):
id: str = Area(..., description="Identify or human-readable distinctive identifier")
label: str = Area(..., description=f"Out there choices are {enum_values}")
properties: Elective(Record(Property))

Jeder Knoten hat eine idA labelund non-compulsory properties. Der Kürze halber habe ich hier keine vollständigen Beschreibungen eingefügt. Die Beschreibung von IDs als für Menschen lesbare eindeutige Kennungen ist wichtig, da einige LLMs dazu neigen, ID-Eigenschaften auf traditionellere Weise wie Zufallszeichenfolgen oder inkrementelle Ganzzahlen zu verstehen. Stattdessen möchten wir, dass der Identify von Entitäten als ID-Eigenschaft verwendet wird. Wir schränken auch die verfügbaren Etikettentypen ein, indem wir sie einfach im auflisten labelBeschreibung. Darüber hinaus unterstützen LLMs wie OpenAI eine enum Parameter, den wir auch verwenden.

Als nächstes werfen wir einen Blick auf die Relationship Klasse

class Relationship(BaseRelationship):
source_node_id: str
source_node_label: str = Area(..., description=f"Out there choices are {enum_values}")
target_node_id: str
target_node_label: str = Area(..., description=f"Out there choices are {enum_values}")
sort: str = Area(..., description=f"Out there choices are {enum_values}")
properties: Elective(Record(Property))

Dies ist die zweite Iteration des Relationship Klasse. Anfangs haben wir eine verschachtelte Methode verwendet Node Objekt für die Quell- und Zielknoten, aber wir stellten schnell fest, dass verschachtelte Objekte die Genauigkeit und Qualität des Extraktionsprozesses beeinträchtigten. Deshalb haben wir beschlossen, die Quell- und Zielknoten in separate Felder zusammenzufassen – zum Beispiel: source_node_id Und source_node_labelzusammen mit target_node_id Und target_node_label. Darüber hinaus definieren wir die zulässigen Werte in den Beschreibungen für Knotenbezeichnungen und Beziehungstypen, um sicherzustellen, dass die LLMs dem angegebenen Diagrammschema entsprechen.

Der werkzeugbasierte Extraktionsansatz ermöglicht es uns, Eigenschaften sowohl für Knoten als auch für Beziehungen zu definieren. Nachfolgend finden Sie die Klasse, mit der wir sie definiert haben.

class Property(BaseModel):
"""A single property consisting of key and worth"""
key: str = Area(..., description=f"Out there choices are {enum_values}")
worth: str

Jede Property ist als Schlüssel-Wert-Paar definiert. Obwohl dieser Ansatz flexibel ist, hat er seine Grenzen. Wir können beispielsweise nicht für jede Eigenschaft eine eindeutige Beschreibung bereitstellen oder bestimmte Eigenschaften als obligatorisch und andere non-compulsory festlegen, sodass alle Eigenschaften als non-compulsory definiert sind. Darüber hinaus werden Eigenschaften nicht für jeden Knoten oder Beziehungstyp einzeln definiert, sondern werden stattdessen von allen gemeinsam genutzt.

Wir haben auch eine implementiert detaillierte Systemaufforderung um die Extraktion zu leiten. Meiner Erfahrung nach haben jedoch die Funktions- und Argumentbeschreibungen tendenziell eine größere Auswirkung als die Systemmeldung.

Leider gibt es derzeit keine einfache Möglichkeit, Funktions- oder Argumentbeschreibungen in LLM Graph Transformer anzupassen.

Immediate-basierte Extraktion

Da nur wenige kommerzielle LLMs und LLaMA 3 native Instruments unterstützen, haben wir einen Fallback für Modelle ohne Device-Unterstützung implementiert. Sie können auch einstellen ignore_tool_usage=True um zu einem auf Eingabeaufforderungen basierenden Ansatz zu wechseln, auch wenn ein Modell verwendet wird, das Instruments unterstützt.

Die meisten Immediate-Engineering-Beispiele und Beispiele für den Immediate-basierten Ansatz wurden von beigesteuert Geraldus Wilsen.

Beim Immediate-basierten Ansatz müssen wir die Ausgabestruktur direkt im Immediate definieren. Sie finden die ganze Eingabeaufforderung hier. In diesem Blogbeitrag geben wir lediglich einen allgemeinen Überblick. Wir beginnen mit der Definition der Systemeingabeaufforderung.

You're a top-tier algorithm designed for extracting info in structured codecs to construct a information graph. Your process is to determine the entities and relations specified within the consumer immediate from a given textual content and produce the output in JSON format. This output must be a listing of JSON objects, with every object containing the next keys:
- **"head"**: The textual content of the extracted entity, which should match one of many sorts specified within the consumer immediate.
- **"head_type"**: The kind of the extracted head entity, chosen from the desired record of sorts.
- **"relation"**: The kind of relation between the "head" and the "tail," chosen from the record of allowed relations.
- **"tail"**: The textual content of the entity representing the tail of the relation.
- **"tail_type"**: The kind of the tail entity, additionally chosen from the supplied record of sorts.
Extract as many entities and relationships as potential. 
**Entity Consistency**: Guarantee consistency in entity illustration. If an entity, like "John Doe," seems a number of occasions within the textual content below completely different names or pronouns (e.g., "Joe," "he"), use probably the most full identifier persistently. This consistency is important for making a coherent and simply comprehensible information graph.
**Essential Notes**:
- Don't add any additional explanations or textual content.

Beim auf Eingabeaufforderungen basierenden Ansatz besteht ein wesentlicher Unterschied darin, dass wir den LLM bitten, nur Beziehungen und keine einzelnen Knoten zu extrahieren. Das heißt, wir werden keine haben isolierte Knotenanders als beim werkzeugbasierten Ansatz. Da Modelle ohne native Toolunterstützung in der Regel eine schlechtere Leistung erbringen, erlauben wir außerdem keine Extraktion von Eigenschaften – weder für Knoten noch für Beziehungen –, um die Extraktionsausgabe einfacher zu halten.

Als Nächstes fügen wir dem Modell einige wenige Beispiele hinzu.

examples = (
{
"textual content": (
"Adam is a software program engineer in Microsoft since 2009, "
"and final 12 months he received an award because the Finest Expertise"
),
"head": "Adam",
"head_type": "Individual",
"relation": "WORKS_FOR",
"tail": "Microsoft",
"tail_type": "Firm",
},
{
"textual content": (
"Adam is a software program engineer in Microsoft since 2009, "
"and final 12 months he received an award because the Finest Expertise"
),
"head": "Adam",
"head_type": "Individual",
"relation": "HAS_AWARD",
"tail": "Finest Expertise",
"tail_type": "Award",
},
...
)

Bei diesem Ansatz gibt es derzeit keine Unterstützung für das Hinzufügen benutzerdefinierter Beispiele für wenige Aufnahmen oder zusätzlicher Anweisungen. Die einzige Möglichkeit zur Anpassung besteht darin, die gesamte Eingabeaufforderung über zu ändern immediateAttribut. Wir denken aktiv darüber nach, die Anpassungsmöglichkeiten zu erweitern.

Als Nächstes werfen wir einen Blick auf die Definition des Diagrammschemas.

Wenn Sie den LLM Graph Transformer zur Informationsextraktion verwenden, ist die Definition eines Diagrammschemas von entscheidender Bedeutung, um das Modell bei der Erstellung aussagekräftiger und strukturierter Wissensdarstellungen zu unterstützen. Ein wohldefiniertes Diagrammschema gibt die zu extrahierenden Knoten- und Beziehungstypen sowie alle damit verbundenen Attribute an. Dieses Schema dient als Blaupause und stellt sicher, dass das LLM relevante Informationen konsistent auf eine Weise extrahiert, die mit der gewünschten Struktur des Wissensgraphen übereinstimmt.

In diesem Blogbeitrag verwenden wir den ersten Absatz von Wikipedia-Seite von Marie Curie zum Testen mit einem zusätzlichen Satz am Ende über Robin Williams.

from langchain_core.paperwork import Doc
textual content = """
Marie Curie, 7 November 1867 – 4 July 1934, was a Polish and naturalised-French physicist and chemist who performed pioneering analysis on radioactivity.
She was the primary lady to win a Nobel Prize, the primary particular person to win a Nobel Prize twice, and the one particular person to win a Nobel Prize in two scientific fields.
Her husband, Pierre Curie, was a co-winner of her first Nobel Prize, making them the first-ever married couple to win the Nobel Prize and launching the Curie household legacy of 5 Nobel Prizes.
She was, in 1906, the primary lady to grow to be a professor on the College of Paris.
Additionally, Robin Williams.
"""
paperwork = (Doc(page_content=textual content))

Wir werden in allen Beispielen auch GPT-4o verwenden.

from langchain_openai import ChatOpenAI
import getpass
import os
os.environ("OPENAI_API_KEY") = getpass.getpass("OpenAI api key")
llm = ChatOpenAI(mannequin='gpt-4o')

Lassen Sie uns zunächst untersuchen, wie der Extraktionsprozess funktioniert, ohne ein Diagrammschema zu definieren.

from langchain_experimental.graph_transformers import LLMGraphTransformer
no_schema = LLMGraphTransformer(llm=llm)

Jetzt können wir die Dokumente mit dem bearbeiten aconvert_to_graph_documents Funktion, die asynchron ist. Die Verwendung von Async mit LLM-Extraktion wird empfohlen, da dadurch die parallele Verarbeitung mehrerer Dokumente ermöglicht wird. Dieser Ansatz kann Wartezeiten erheblich verkürzen und den Durchsatz verbessern, insbesondere bei der Bearbeitung mehrerer Dokumente.

knowledge = await no_schema.aconvert_to_graph_documents(paperwork)

Die Antwort des LLM Graph Transformer ist ein Diagrammdokument mit der folgenden Struktur:

(
GraphDocument(
nodes=(
Node(id="Marie Curie", sort="Individual", properties={}),
Node(id="Pierre Curie", sort="Individual", properties={}),
Node(id="Nobel Prize", sort="Award", properties={}),
Node(id="College Of Paris", sort="Group", properties={}),
Node(id="Robin Williams", sort="Individual", properties={}),
),
relationships=(
Relationship(
supply=Node(id="Marie Curie", sort="Individual", properties={}),
goal=Node(id="Nobel Prize", sort="Award", properties={}),
sort="WON",
properties={},
),
Relationship(
supply=Node(id="Marie Curie", sort="Individual", properties={}),
goal=Node(id="Nobel Prize", sort="Award", properties={}),
sort="WON",
properties={},
),
Relationship(
supply=Node(id="Marie Curie", sort="Individual", properties={}),
goal=Node(
id="College Of Paris", sort="Group", properties={}
),
sort="PROFESSOR",
properties={},
),
Relationship(
supply=Node(id="Pierre Curie", sort="Individual", properties={}),
goal=Node(id="Nobel Prize", sort="Award", properties={}),
sort="WON",
properties={},
),
),
supply=Doc(
metadata={"id": "de3c93515e135ac0e47ca82a4f9b82d8"},
page_content="nMarie Curie, 7 November 1867 – 4 July 1934, was a Polish and naturalised-French physicist and chemist who performed pioneering analysis on radioactivity.nShe was the primary lady to win a Nobel Prize, the primary particular person to win a Nobel Prize twice, and the one particular person to win a Nobel Prize in two scientific fields.nHer husband, Pierre Curie, was a co-winner of her first Nobel Prize, making them the first-ever married couple to win the Nobel Prize and launching the Curie household legacy of 5 Nobel Prizes.nShe was, in 1906, the primary lady to grow to be a professor on the College of Paris.nAlso, Robin Williams!n",
),
)
)

Das Diagrammdokument beschreibt extrahiert nodes Und relationships . Zusätzlich wird das Quelldokument der Extraktion unter hinzugefügt supply Schlüssel.

Wir können den Neo4j-Browser verwenden, um die Ausgaben zu visualisieren und so ein klareres und intuitiveres Verständnis der Daten zu ermöglichen.

Es ist schwierig, multimodales LLM zu entwerfen.

Die hochmodernen multimodalen LLMs basieren in erster Linie auf bestehenden LLM-Architekturen, wobei Modifikationen speziell auf unterschiedliche Eingabequellen abzielen, und hier liegt die Schwierigkeit. Das Neueste Nvidia-Papier unterteilt die häufig verwendeten multimodalen Architekturen in zwei Kategorien:

• Decoderbasiert;
• kreuzaufmerksamkeitsbasiert.

Einer meiner vorheriger mittlerer Artikelwird besprochen das neueste Papier von Metaverwenden Decoder-basierte Architekturdas ein Eingabebild mithilfe eines VAE-Encoders in einen latenten Vektor umwandelt, um das Downside zu beheben, dass der Bildraum kontinuierlich ist und sich vom diskreten Textraum unterscheidet.

Allerdings ist das Downside mit auf Aufmerksamkeit basierende Architektur ist anders. Beispielsweise im multimodalen LLM-Modell FlamingoDas entscheidende Downside besteht darin, die Imaginative and prescient-Einbettung von einem generischen Imaginative and prescient-Modell mit unterschiedlichen zeitlichen und räumlichen Dimensionen in die Queraufmerksamkeitsschicht umzuwandeln, um sie an die Spracheingabedimension anzupassen.

In diesem Beitrag werde ich mich eingehend mit dem einzigartigen Design von Flamingo und dem Imaginative and prescient-Encoder, dem Perceiver Resampler, befassen, um zu erklären, wie dieses Downside gelöst wurde. Darüber hinaus werde ich den Ursprung des Perceiver Resamplers untersuchen – den Induced Set Consideration Block von Transformator einstellenwas noch mehr inspirierte Das Perceiver-Modell von DeepMind zum Lernen latenter Einbettungen fester Länge aus generischen Eingabedaten.

Die Veröffentlichung mehrerer leistungsstarker Open-Supply-Grundmodelle in Verbindung mit Fortschritten bei der Feinabstimmung haben ein neues Paradigma im maschinellen Lernen und in der künstlichen Intelligenz hervorgebracht. Im Zentrum dieser Revolution steht die Transformatormodell.

Während hochpräzise domänenspezifische Modelle früher für alle außer den finanzkräftigsten Unternehmen unerreichbar waren, ermöglicht das grundlegende Modellparadigma heute sogar den bescheidenen Ressourcen von Studenten oder unabhängigen Forschern, Ergebnisse zu erzielen, die mit den modernsten proprietären Modellen mithalten können.

Dieser Artikel untersucht die Anwendung von Metas Section Something Mannequin (SAM) auf die Fernerkundungsaufgabe der Flusspixelsegmentierung. Wenn Sie direkt in den Code einsteigen möchten, ist die Quelldatei für dieses Projekt verfügbar unter GitHub und die Daten sind auf Umarmendes Gesichtobwohl es ratsam ist, zuerst den gesamten Artikel zu lesen.

Der erste Schritt besteht darin, einen geeigneten Datensatz zu finden oder zu erstellen. Basierend auf vorhandener Literatur enthält ein guter Feinabstimmungsdatensatz für SAM mindestens 200–800 Bilder. Eine wichtige Lektion der letzten zehn Jahre der Weiterentwicklung des Deep Studying ist, dass mehr Daten immer besser sind. Mit einem größeren Feinabstimmungsdatensatz kann man additionally nichts falsch machen. Das Ziel grundlegender Modelle besteht jedoch darin, dass auch relativ kleine Datensätze für eine starke Leistung ausreichen.

Außerdem ist ein HuggingFace-Konto erforderlich. hier erstellt. Mit HuggingFace können wir unseren Datensatz jederzeit und von jedem Gerät aus problemlos speichern und abrufen, was die Zusammenarbeit und Reproduzierbarkeit erleichtert.

Die letzte Voraussetzung ist ein Gerät mit einer GPU, auf dem wir den Trainingsworkflow ausführen können. Eine Nvidia T4 GPU, die kostenlos erhältlich ist über Google Colabist leistungsstark genug, um den größten SAM-Modell-Checkpoint (sam-vit-huge) für 50 Epochen in weniger als 12 Stunden anhand von 1000 Bildern zu trainieren.

Um zu vermeiden, dass der Fortschritt aufgrund von Nutzungsbeschränkungen bei gehosteten Laufzeiten verloren geht, können Sie Google Drive einbinden und jeden Modellprüfpunkt dort speichern. Alternativ können Sie eine Verbindung zu einem Virtuelle GCP-Maschine um Beschränkungen vollständig zu umgehen. Wenn Sie GCP noch nie zuvor verwendet haben, haben Sie Anspruch auf ein kostenloses Guthaben von 300 US-Greenback, das ausreicht, um das Modell mindestens ein Dutzend Mal zu trainieren.

Bevor wir mit dem Coaching beginnen, müssen wir die Architektur von SAM verstehen. Das Modell enthält drei Komponenten: einen Bildencoder aus einem minimal modifizierten maskierter Autoencoderein flexibler Immediate-Encoder, der verschiedene Immediate-Typen verarbeiten kann, und ein schneller und leichter Masken-Decoder. Eine Motivation hinter dem Design ist es, eine schnelle Segmentierung in Echtzeit auf Edge-Geräten (z. B. im Browser) zu ermöglichen, da die Bildeinbettung nur einmal berechnet werden muss und der Masken-Decoder in ca. 50 ms auf der CPU ausgeführt werden kann.

Theoretisch hat der Bildencoder bereits gelernt, wie man ein Bild optimum einbettet, indem er Formen, Kanten und andere allgemeine visuelle Merkmale erkennt. Ebenso ist der Immediate-Encoder theoretisch bereits in der Lage, Prompts optimum zu kodieren. Der Maskendecoder ist der Teil der Modellarchitektur, der diese Bild- und Immediate-Einbettungen übernimmt und tatsächlich die Maske erstellt, indem er die Bild- und Immediate-Einbettungen bearbeitet.

Ein Ansatz besteht daher darin, die mit den Bild- und Eingabeaufforderungs-Encodern verbundenen Modellparameter während des Trainings einzufrieren und nur die Masken-Decodergewichte zu aktualisieren. Dieser Ansatz hat den Vorteil, dass sowohl überwachte als auch unbeaufsichtigte nachgelagerte Aufgaben möglich sind, da Kontrollpunkt- und Begrenzungsrahmen-Eingabeaufforderungen sowohl automatisierbar als auch von Menschen verwendbar sind.

Ein alternativer Ansatz besteht darin, den Immediate-Encoder zu überladen, den Bild-Encoder und den Masken-Decoder einzufrieren und einfach den ursprünglichen SAM-Masken-Encoder nicht zu verwenden. Beispielsweise verwendet die AutoSAM-Architektur ein auf Harmonic Dense Web basierendes Netzwerk, um Immediate-Einbettungen basierend auf dem Bild selbst zu erzeugen. In diesem Tutorial behandeln wir den ersten Ansatz, bei dem die Bild- und Immediate-Encoder eingefroren und nur der Masken-Decoder trainiert werden. Code für diesen alternativen Ansatz finden Sie jedoch im AutoSAM GitHub Und Papier.

Der nächste Schritt besteht darin, zu bestimmen, welche Artwork von Eingabeaufforderungen das Modell während der Inferenzzeit erhält, damit wir diese Artwork von Eingabeaufforderung zur Trainingszeit bereitstellen können. Persönlich würde ich angesichts der unvorhersehbaren/inkonsistenten Natur der Verarbeitung natürlicher Sprache die Verwendung von Texteingabeaufforderungen für eine ernsthafte Pc-Imaginative and prescient-Pipeline nicht empfehlen. Es bleiben Punkte und Begrenzungsrahmen, wobei die Wahl letztendlich von der besonderen Natur Ihres spezifischen Datensatzes abhängt, obwohl in der Literatur festgestellt wurde, dass Begrenzungsrahmen Kontrollpunkte ziemlich konsistent übertreffen.

Die Gründe hierfür sind nicht ganz klar, es könnte jedoch einer der folgenden Faktoren oder eine Kombination davon sein:

• Gute Kontrollpunkte sind zum Zeitpunkt der Inferenz (wenn die Floor-Reality-Maske unbekannt ist) schwieriger auszuwählen als Begrenzungsrahmen.
• Der Raum der möglichen Punktaufforderungen ist um Größenordnungen größer als der Raum der möglichen Begrenzungsrahmenaufforderungen und wurde daher nicht so gründlich trainiert.
• Die ursprünglichen SAM-Autoren konzentrierten sich auf die Zero-Shot- und Few-Shot-Fähigkeiten des Modells (gezählt als menschliche Interaktionen), sodass der Schwerpunkt beim Vortraining möglicherweise mehr auf Begrenzungsrahmen lag.

Unabhängig davon ist die Flusssegmentierung tatsächlich ein seltener Fall, in dem Punkteingabeaufforderungen tatsächlich besser abschneiden als Begrenzungsrahmen (wenn auch nur geringfügig, selbst bei einer äußerst günstigen Domäne). Da sich in jedem Bild eines Flusses das Gewässer von einem Ende des Bildes zum anderen erstreckt, bedeckt ein umgebender Begrenzungsrahmen quick immer den größten Teil des Bildes. Daher können die Eingabeaufforderungen für Begrenzungsrahmen für sehr unterschiedliche Flussabschnitte äußerst ähnlich aussehen, was theoretisch bedeutet, dass Begrenzungsrahmen dem Modell deutlich weniger Informationen liefern als Kontrollpunkte und daher zu einer schlechteren Leistung führen.

Beachten Sie, dass in der obigen Abbildung die jeweiligen Begrenzungsrahmen nahezu identisch sind, obwohl die tatsächlichen Segmentierungsmasken für die beiden Flussabschnitte völlig unterschiedlich sind, während ihre Punktaufforderungen sich (relativ) stärker unterscheiden.

Der andere wichtige zu berücksichtigende Faktor ist, wie einfach Eingabeaufforderungen zum Zeitpunkt der Inferenz generiert werden können. Wenn Sie davon ausgehen, dass ein Mensch in die Schleife eingebunden ist, sind sowohl Begrenzungsrahmen als auch Kontrollpunkte zum Zeitpunkt der Inferenz relativ einfach zu erfassen. Wenn Sie jedoch eine vollständig automatisierte Pipeline haben möchten, wird die Beantwortung dieser Fragen komplizierter.

Unabhängig davon, ob Kontrollpunkte oder Begrenzungsrahmen verwendet werden, umfasst das Generieren der Eingabeaufforderung normalerweise zunächst die Schätzung einer groben Maske für das Objekt von Interesse. Begrenzungsrahmen können dann einfach die kleinste Field sein, die die grobe Maske umschließt, während Kontrollpunkte aus der groben Maske abgetastet werden müssen. Dies bedeutet, dass Begrenzungsrahmen einfacher zu erhalten sind, wenn die Grundmaske unbekannt ist, da die geschätzte Maske für das Objekt von Interesse nur ungefähr der Größe und Place des tatsächlichen Objekts entsprechen muss, während die geschätzte Maske für Kontrollpunkte genauer mit den Konturen des Objekts übereinstimmen müsste.

Wenn wir für die Flusssegmentierung sowohl auf RGB als auch auf NIR zugreifen können, können wir Schwellenwertmethoden für Spektralindizes verwenden, um unsere grobe Maske zu erhalten. Wenn wir nur auf RGB zugreifen können, können wir das Bild in HSV konvertieren und alle Pixel innerhalb eines bestimmten Farbton-, Sättigungs- und Wertebereichs mit Schwellenwerten versehen. Dann können wir verbundene Komponenten unterhalb einer bestimmten Größenschwelle entfernen und verwenden erosion aus skimage.morphology um sicherzustellen, dass die einzigen 1 Pixel in unserer Maske diejenigen sind, die sich in Richtung der Mitte der großen blauen Flecken befinden.

Um unser Modell zu trainieren, benötigen wir einen Datenlader, der alle unsere Trainingsdaten enthält, die wir für jede Trainingsepoche durchlaufen können. Wenn wir unseren Datensatz von HuggingFace laden, nimmt er die Type eines datasets.Dataset Klasse. Wenn der Datensatz privat ist, installieren Sie zuerst die HuggingFace CLI und melden Sie sich mit !huggingface-cli login.

from datasets import load_dataset, load_from_disk, Dataset
hf_dataset_name = "stodoran/elwha-segmentation-v1"
training_data = load_dataset(hf_dataset_name, break up="prepare")
validation_data = load_dataset(hf_dataset_name, break up="validation")

Wir müssen dann unsere eigene benutzerdefinierte Dataset-Klasse codieren, die nicht nur ein Bild und ein Label für jeden Index zurückgibt, sondern auch die Eingabeaufforderung. Unten sehen Sie eine Implementierung, die sowohl Kontrollpunkt- als auch Begrenzungsrahmen-Eingabeaufforderungen verarbeiten kann. Zur Initialisierung wird ein HuggingFace benötigt. datasets.Dataset Instanz und eine SAM-Prozessorinstanz.

from torch.utils.information import Dataset
class PromptType:
CONTROL_POINTS = "pts"
BOUNDING_BOX = "bbox"
class SAMDataset(Dataset):
def __init__(
self, 
dataset, 
processor, 
prompt_type = PromptType.CONTROL_POINTS,
num_positive = 3,
num_negative = 0,
erode = True,
multi_mask = "imply",
perturbation = 10,
image_size = (1024, 1024),
mask_size = (256, 256),
):
# Asign all values to self
...
def __len__(self):
return len(self.dataset)
def __getitem__(self, idx):
datapoint = self.dataset(idx)
input_image = cv2.resize(np.array(datapoint("picture")), self.image_size)
ground_truth_mask = cv2.resize(np.array(datapoint("label")), self.mask_size)
if self.prompt_type == PromptType.CONTROL_POINTS:
inputs = self._getitem_ctrlpts(input_image, ground_truth_mask)
elif self.prompt_type == PromptType.BOUNDING_BOX:
inputs = self._getitem_bbox(input_image, ground_truth_mask)
inputs("ground_truth_mask") = ground_truth_mask
return inputs

Wir müssen auch definieren, SAMDataset._getitem_ctrlpts Und SAMDataset._getitem_bbox Funktionen, obwohl, wenn Sie nur planen, einen Eingabeaufforderungstyp zu verwenden, dann können Sie den Code umgestalten, um nur diesen Typ direkt zu verarbeiten in SAMDataset.__getitem__ und entfernen Sie die Hilfsfunktion.

class SAMDataset(Dataset):
...
def _getitem_ctrlpts(self, input_image, ground_truth_mask):
# Get management factors immediate. See the GitHub for the supply
# of this operate, or change with your individual level choice algorithm.
input_points, input_labels = generate_input_points(
num_positive=self.num_positive,
num_negative=self.num_negative,
masks=ground_truth_mask,
dynamic_distance=True,
erode=self.erode,
)
input_points = input_points.astype(float).tolist()
input_labels = input_labels.tolist()
input_labels = ((x) for x in input_labels)
# Put together the picture and immediate for the mannequin.
inputs = self.processor(
input_image,
input_points=input_points,
input_labels=input_labels,
return_tensors="pt"
)
# Take away batch dimension which the processor provides by default.
inputs = {ok: v.squeeze(0) for ok, v in inputs.gadgets()}
inputs("input_labels") = inputs("input_labels").squeeze(1)
return inputs
def _getitem_bbox(self, input_image, ground_truth_mask):
# Get bounding field immediate.
bbox = get_input_bbox(ground_truth_mask, perturbation=self.perturbation)
# Put together the picture and immediate for the mannequin.
inputs = self.processor(input_image, input_boxes=((bbox)), return_tensors="pt")
inputs = {ok: v.squeeze(0) for ok, v in inputs.gadgets()} # Take away batch dimension which the processor provides by default.
return inputs

Wenn wir alles zusammenfassen, können wir eine Funktion erstellen, die einen PyTorch-Datenlader erstellt und zurückgibt, wenn der HuggingFace-Datensatz aufgeteilt wird. Das Schreiben von Funktionen, die Datenlader zurückgeben, anstatt nur Zellen mit demselben Code auszuführen, ist nicht nur eine gute Praxis zum Schreiben von flexiblem und wartbarem Code, sondern auch notwendig, wenn Sie planen, HuggingFace Beschleunigen um verteiltes Coaching durchzuführen.

from transformers import SamProcessor
from torch.utils.information import DataLoader
def get_dataloader(
hf_dataset,
model_size = "base",  # Certainly one of "base", "giant", or "large" 
batch_size = 8, 
prompt_type = PromptType.CONTROL_POINTS,
num_positive = 3,
num_negative = 0,
erode = True,
multi_mask = "imply",
perturbation = 10,
image_size = (256, 256),
mask_size = (256, 256),
):
processor = SamProcessor.from_pretrained(f"fb/sam-vit-{model_size}")
sam_dataset = SAMDataset(
dataset=hf_dataset, 
processor=processor, 
prompt_type=prompt_type,
num_positive=num_positive,
num_negative=num_negative,
erode=erode,
multi_mask=multi_mask,
perturbation=perturbation,
image_size=image_size,
mask_size=mask_size,
)
dataloader = DataLoader(sam_dataset, batch_size=batch_size, shuffle=True)
return dataloader

Danach besteht das Coaching lediglich darin, das Modell zu laden, die Bild- und Eingabeaufforderungs-Encoder einzufrieren und für die gewünschte Anzahl von Iterationen zu trainieren.

mannequin = SamModel.from_pretrained(f"fb/sam-vit-{model_size}")
optimizer = AdamW(mannequin.mask_decoder.parameters(), lr=learning_rate, weight_decay=weight_decay)
# Prepare solely the decoder.
for identify, param in mannequin.named_parameters():
if identify.startswith("vision_encoder") or identify.startswith("prompt_encoder"):
param.requires_grad_(False)

Unten sehen Sie die grundlegende Gliederung des Trainingsschleifencodes. Beachten Sie, dass die forward_pass, calculate loss, evaluate_modelUnd save_model_checkpoint Funktionen wurden der Kürze halber weggelassen, aber Implementierungen sind auf GitHub verfügbar. Der Vorwärtspasscode unterscheidet sich je nach Eingabeaufforderungstyp leicht, und die Verlustberechnung erfordert ebenfalls einen Sonderfall basierend auf dem Eingabeaufforderungstyp. Bei der Verwendung von Punkteingabeaufforderungen gibt SAM für jeden einzelnen Eingabepunkt eine vorhergesagte Maske zurück. Um additionally eine einzelne Maske zu erhalten, die mit der Grundwahrheit verglichen werden kann, müssen entweder die vorhergesagten Masken gemittelt oder die beste vorhergesagte Maske ausgewählt werden (identifiziert basierend auf den vorhergesagten IoU-Werten von SAM).

train_losses = ()
validation_losses = ()
epoch_loop = tqdm(whole=num_epochs, place=epoch, go away=False)
batch_loop = tqdm(whole=len(train_dataloader), place=0, go away=True)
whereas epoch < num_epochs:
epoch_losses = ()
batch_loop.n = 0  # Loop Reset
for idx, batch in enumerate(train_dataloader):
# Ahead Cross
batch = {ok: v.to(accelerator.system) for ok, v in batch.gadgets()}
outputs = forward_pass(mannequin, batch, prompt_type)
# Compute Loss
ground_truth_masks = batch("ground_truth_mask").float()
train_loss = calculate_loss(outputs, ground_truth_masks, prompt_type, loss_fn, multi_mask="greatest")
epoch_losses.append(train_loss)
# Backward Cross & Optimizer Step
optimizer.zero_grad()
accelerator.backward(train_loss)
optimizer.step()
lr_scheduler.step()
batch_loop.set_description(f"Prepare Loss: {train_loss.merchandise():.4f}")
batch_loop.replace(1)
validation_loss = evaluate_model(mannequin, validation_dataloader, accelerator.system, loss_fn)
train_losses.append(torch.imply(torch.Tensor(epoch_losses)))
validation_losses.append(validation_loss)
if validation_loss < best_loss:
save_model_checkpoint(
accelerator,
best_checkpoint_path,
mannequin,
optimizer,
lr_scheduler,
epoch,
train_history,
validation_loss,
train_losses,
validation_losses,
loss_config,
model_descriptor=model_descriptor,
)
best_loss = validation_loss
epoch_loop.set_description(f"Finest Loss: {best_loss:.4f}")
epoch_loop.replace(1)
epoch += 1

Für das Elwha-River-Projekt wurde im besten Fall das Modell „sam-vit-base“ mithilfe eines Datensatzes von über 1.000 Segmentierungsmasken unter Verwendung einer GCP-Instanz in weniger als 12 Stunden trainiert.

Im Vergleich zum Foundation-SAM verbesserte sich die Leistung durch die Feinabstimmung drastisch, wobei die Medianmaske von unbrauchbar zu hochpräzise wurde.

Wichtig zu beachten ist, dass der Trainingsdatensatz mit 1.000 Flussbildern nicht perfekt conflict und die Segmentierungsbezeichnungen hinsichtlich der Anzahl korrekt klassifizierter Pixel stark variierten. Daher wurden die oben gezeigten Metriken anhand eines pixelgenauen Datensatzes mit 225 Flussbildern berechnet.

Ein interessantes beobachtetes Verhalten conflict, dass das Modell lernte, aus den unvollkommenen Trainingsdaten zu verallgemeinern. Bei der Auswertung von Datenpunkten, bei denen das Trainingsbeispiel offensichtliche Fehlklassifizierungen enthielt, können wir beobachten, dass die Vorhersage des Modells den Fehler vermeidet. Beachten Sie, dass die Bilder in der oberen Reihe, die Trainingsbeispiele zeigen, Masken enthalten, die den Fluss nicht bis zum Ufer füllen, während die untere Reihe, die Modellvorhersagen zeigt, die Flussgrenzen enger segmentiert.