In Teilen dieser Serie haben wir uns mit Graph Faltungsnetzwerken (GCNs) und Graph Achtungsnetzwerken (GATs) befasst. Beide Architekturen funktionieren intestine, haben aber auch einige Einschränkungen! Ein großes ist, dass für große Graphen die Berechnung der Knotendarstellungen mit GCNs und GATs sehr langsam werden. Eine weitere Einschränkung besteht darin, dass GCNs und GATs, wenn sich die Graphenstruktur ändert, nicht verallgemeinert werden können. Wenn additionally Knoten zum Diagramm hinzugefügt werden, können ein GCN oder GAT keine Vorhersagen dafür treffen. Zum Glück können diese Probleme gelöst werden!

In diesem Beitrag werde ich erklären Graphsage und wie es häufige Probleme von GCNs und Gats löst. Wir trainieren Graphsage und verwenden sie für Diagrammvorhersagen, um die Leistung mit GCNs und GATs zu vergleichen.

Neu in Gnns? Sie können mit beginnen mit Submit 1 über GCNs (Enthält auch das anfängliche Setup zum Ausführen der Code -Beispiele) und Submit 2 über Gats.

---

Zwei wichtige Probleme mit GCNs und Gats

Ich habe es in der Einführung in Kürze angesprochen, aber lassen Sie uns ein bisschen tiefer tauchen. Was sind die Probleme mit den vorherigen GNN -Modellen?

Downside 1. Sie verallgemeinern nicht

GCNs und GATs haben Probleme mit der Verallgemeinerung auf unsichtbare Grafiken. Die Grafikstruktur muss mit den Trainingsdaten übereinstimmen. Dies ist bekannt als als transduktives Lernenwo das Modell trainiert und Vorhersagen in derselben festen Grafik macht. Es ist tatsächlich zu bestimmten Graph -Topologien übernommen. In Wirklichkeit ändern sich die Grafiken: Knoten und Kanten können hinzugefügt oder entfernt werden, und dies geschieht oft in Szenarien in realer Welt. Wir möchten induktiv Lernen).

Downside 2. Sie haben Skalierbarkeitsprobleme

Das Coaching von GCNs und GATS in groß angelegten Grafiken ist rechnerisch teuer. GCNs erfordern eine wiederholte Nachbaraggregation, die exponentiell mit der Graphengröße wächst, während GATs (Multihead-) Aufmerksamkeitsmechanismen mit zunehmenden Knoten schlecht skalieren.
In großen Produktionsempfehlungssystemen mit großen Grafiken mit Millionen von Benutzern und Produkten sind GCNs und GATS unpraktisch und langsam.

Schauen wir uns die Graphsage an, um diese Probleme zu beheben.

Graphsage (Probe und Aggregat)

Graphsage macht das Coaching viel schneller und skalierbar. Dies geschieht durch Probenahme nur eine Untergruppe von Nachbarn. Für tremendous große Grafiken ist es rechnerisch unmöglich, alle Nachbarn eines Knotens zu verarbeiten (außer wenn Sie unbegrenzt Zeit haben, was wir alle nicht…), wie bei traditionellen GCNs. Ein weiterer wichtiger Schritt der Graphsage ist Kombinieren Sie die Merkmale der abgetasteten Nachbarn mit einer Aggregationsfunktion.
Wir werden alle Schritte der Graphsage unten durchlaufen.

1. Probenahme Nachbarn

Bei tabellarischen Daten ist die Stichprobe einfach. Es ist etwas, was Sie in jedem gemeinsamen Projekt für maschinelles Lernen bei der Erstellung von Zug-, Check- und Validierungssätzen machen. Mit Diagrammen können Sie keine zufälligen Knoten auswählen. Dies kann zu getrennten Graphen, Knoten ohne Nachbarn usw. führen:

Was du dürfen Mit Diagrammen wählt eine zufällige Untergruppe von Nachbarn mit fester Größe aus. In einem sozialen Netzwerk können Sie beispielsweise 3 Freunde für jeden Benutzer (anstelle aller Freunde) probieren:

2. Gesamtinformationen

Nach der Auswahl der Nachbarn aus dem vorherigen Teil kombiniert Graphsage ihre Funktionen zu einer einzigen Darstellung. Es gibt mehrere Möglichkeiten, dies zu tun (mehrere Aggregationsfunktionen). Die am häufigsten und die im Papier erklärten Typen sind mittlere AggregationAnwesend LstmUnd Pooling.

Mit der mittleren Aggregation wird der Durchschnitt über alle Merkmale der abgetasteten Nachbarn berechnet (sehr einfach und oft effektiv). In einer Formel:

LSTM -Aggregation verwendet eine Lstm (Artwork des neuronalen Netzwerks), um Nachbarfunktionen nacheinander zu verarbeiten. Es kann komplexere Beziehungen aufnehmen und ist mächtiger als die mittlere Aggregation.

Die dritte Artwork, die Poolaggregation, wendet eine nichtlineare Funktion an, um wichtige Merkmale zu extrahieren (denken Sie an Max-Pooling In einem neuronalen Netzwerk, in dem Sie auch den Maximalwert einiger Werte nehmen).

3.. Aktualisieren der Knotendarstellung

Nach der Probenahme und Aggregation der Knoten kombiniert seine früheren Funktionen mit den aggregierten Nachbarnfunktionen. Knoten werden von ihren Nachbarn lernen, aber auch ihre eigene Identität behalten, genau wie zuvor mit GCNs und Gats. Informationen können effektiv über den Diagramm fließen.

Dies ist die Formel für diesen Schritt:

Die Aggregation von Schritt 2 erfolgt über alle Nachbarn, und dann wird die Merkmalsdarstellung des Knotens verkettet. Dieser Vektor wird mit der Gewichtsmatrix multipliziert und durch die Nichtlinearität (z. B. Relu) geleitet. Als letzter Schritt kann die Normalisierung angewendet werden.

4. Wiederholen Sie für mehrere Schichten

Die ersten drei Schritte können mehrmals wiederholt werden. In diesem Fall können Informationen von entfernten Nachbarn fließen. Im Bild unten sehen Sie einen Knoten mit drei in der ersten Schicht ausgewählten Nachbarn (direkte Nachbarn) und zwei in der zweiten Schicht ausgewählte Nachbarn (Nachbarn der Nachbarn).

Zusammenfassend lässt sich sagen, dass die wichtigsten Stärken von Graphsage ihre Skalierbarkeit sind (die Abtastung macht es für large Grafiken effizient). Flexibilität können Sie es verwenden für Induktives Lernen (Funktioniert intestine, wenn es zur Vorhersage von unsichtbaren Knoten und Grafiken verwendet wird); Die Aggregation hilft bei der Verallgemeinerung, da sie laute Merkmale glättet. und die Mehrschichten erlauben das Modell, aus fernen Knoten zu lernen.

Cool! Und das Beste, Graphsage wird in implementiert PygSo können wir es leicht in Pytorch verwenden.

Vorhersage mit Graphsage

In den vorherigen Beiträgen haben wir einen MLP, GCN und GAT auf dem implementiert Cora Datensatz (CC BY-SA). Um Ihren Geist ein wenig zu aktualisieren, ist Cora ein Datensatz mit wissenschaftlichen Veröffentlichungen, in denen Sie das Thema jedes Papiers mit insgesamt sieben Klassen vorhersagen müssen. Dieser Datensatz ist relativ gering und ist daher möglicherweise nicht der beste Satz für das Testen von Graphsage. Wir werden dies trotzdem tun, nur um vergleichen zu können. Mal sehen, wie intestine Graphsage funktioniert.

Interessante Teile des Codes, die ich gerne mit Graphsage hervorhebt:

• Der NeighborLoader Dadurch wird die Auswahl der Nachbarn für jede Schicht ausgeführt:

from torch_geometric.loader import NeighborLoader

# 10 neighbors sampled within the first layer, 10 within the second layer
num_neighbors = (10, 10)

# pattern information from the prepare set
train_loader = NeighborLoader(
    information,
    num_neighbors=num_neighbors,
    batch_size=batch_size,
    input_nodes=information.train_mask,
)

• Der Aggregationstyp ist in der implementiert SAGEConv Schicht. Der Normal ist implySie können dies an ändern max oder lstm:

from torch_geometric.nn import SAGEConv

SAGEConv(in_c, out_c, aggr='imply')

• Ein weiterer wichtiger Unterschied besteht darin, dass Graphsage in Mini -Chargen und GCN und GAT auf dem vollständigen Datensatz trainiert wird. Dies berührt die Essenz von Graphsage, da die Nachbarabtastung von Graphsage es ermöglicht, in Mini -Chargen zu trainieren, benötigen wir nicht mehr den vollständigen Diagramm. GCNs und GATs benötigen das komplette Diagramm für die korrekte Merkmalsausbreitung und Berechnung der Aufmerksamkeitswerte. Deshalb trainieren wir GCNs und GATS im vollständigen Diagramm.
• Der Relaxation des Codes ist ähnlich wie zuvor, außer dass wir eine Klasse haben, in der alle verschiedenen Modelle basierend auf dem instanziiert werden model_type (GCN, Gat oder Salbei). Dies erleichtert es einfach, kleine Änderungen zu vergleichen oder vorzunehmen.

Dies ist das vollständige Skript. Wir trainieren 100 Epochen und wiederholen das Experiment 10 Mal, um die durchschnittliche Genauigkeit und Standardabweichung für jedes Modell zu berechnen:

import torch
import torch.nn.purposeful as F
from torch_geometric.nn import SAGEConv, GCNConv, GATConv
from torch_geometric.datasets import Planetoid
from torch_geometric.loader import NeighborLoader

# dataset_name could be 'Cora', 'CiteSeer', 'PubMed'
dataset_name = 'Cora'
hidden_dim = 64
num_layers = 2
num_neighbors = (10, 10)
batch_size = 128
num_epochs = 100
model_types = ('GCN', 'GAT', 'SAGE')

dataset = Planetoid(root='information', identify=dataset_name)
information = dataset(0)
machine = torch.machine('cuda' if torch.cuda.is_available() else 'cpu')
information = information.to(machine)

class GNN(torch.nn.Module):
    def __init__(self, in_channels, hidden_channels, out_channels, num_layers, model_type='SAGE', gat_heads=8):
        tremendous().__init__()
        self.convs = torch.nn.ModuleList()
        self.model_type = model_type
        self.gat_heads = gat_heads

        def get_conv(in_c, out_c, is_final=False):
            if model_type == 'GCN':
                return GCNConv(in_c, out_c)
            elif model_type == 'GAT':
                heads = 1 if is_final else gat_heads
                concat = False if is_final else True
                return GATConv(in_c, out_c, heads=heads, concat=concat)
            else:
                return SAGEConv(in_c, out_c, aggr='imply')

        if model_type == 'GAT':
            self.convs.append(get_conv(in_channels, hidden_channels))
            in_dim = hidden_channels * gat_heads
            for _ in vary(num_layers - 2):
                self.convs.append(get_conv(in_dim, hidden_channels))
                in_dim = hidden_channels * gat_heads
            self.convs.append(get_conv(in_dim, out_channels, is_final=True))
        else:
            self.convs.append(get_conv(in_channels, hidden_channels))
            for _ in vary(num_layers - 2):
                self.convs.append(get_conv(hidden_channels, hidden_channels))
            self.convs.append(get_conv(hidden_channels, out_channels))

    def ahead(self, x, edge_index):
        for conv in self.convs(:-1):
            x = F.relu(conv(x, edge_index))
        x = self.convs(-1)(x, edge_index)
        return x

@torch.no_grad()
def check(mannequin):
    mannequin.eval()
    out = mannequin(information.x, information.edge_index)
    pred = out.argmax(dim=1)
    accs = ()
    for masks in (information.train_mask, information.val_mask, information.test_mask):
        accs.append(int((pred(masks) == information.y(masks)).sum()) / int(masks.sum()))
    return accs

outcomes = {}

for model_type in model_types:
    print(f'Coaching {model_type}')
    outcomes(model_type) = ()

    for i in vary(10):
        mannequin = GNN(dataset.num_features, hidden_dim, dataset.num_classes, num_layers, model_type, gat_heads=8).to(machine)
        optimizer = torch.optim.Adam(mannequin.parameters(), lr=0.01, weight_decay=5e-4)

        if model_type == 'SAGE':
            train_loader = NeighborLoader(
                information,
                num_neighbors=num_neighbors,
                batch_size=batch_size,
                input_nodes=information.train_mask,
            )

            def prepare():
                mannequin.prepare()
                total_loss = 0
                for batch in train_loader:
                    batch = batch.to(machine)
                    optimizer.zero_grad()
                    out = mannequin(batch.x, batch.edge_index)
                    loss = F.cross_entropy(out, batch.y(:out.dimension(0)))
                    loss.backward()
                    optimizer.step()
                    total_loss += loss.merchandise()
                return total_loss / len(train_loader)

        else:
            def prepare():
                mannequin.prepare()
                optimizer.zero_grad()
                out = mannequin(information.x, information.edge_index)
                loss = F.cross_entropy(out(information.train_mask), information.y(information.train_mask))
                loss.backward()
                optimizer.step()
                return loss.merchandise()

        best_val_acc = 0
        best_test_acc = 0
        for epoch in vary(1, num_epochs + 1):
            loss = prepare()
            train_acc, val_acc, test_acc = check(mannequin)
            if val_acc > best_val_acc:
                best_val_acc = val_acc
                best_test_acc = test_acc
            if epoch % 10 == 0:
                print(f'Epoch {epoch:02d} | Loss: {loss:.4f} | Practice: {train_acc:.4f} | Val: {val_acc:.4f} | Check: {test_acc:.4f}')

        outcomes(model_type).append((best_val_acc, best_test_acc))

for model_name, model_results in outcomes.gadgets():
    model_results = torch.tensor(model_results)
    print(f'{model_name} Val Accuracy: {model_results(:, 0).imply():.3f} ± {model_results(:, 0).std():.3f}')
    print(f'{model_name} Check Accuracy: {model_results(:, 1).imply():.3f} ± {model_results(:, 1).std():.3f}')

Und hier sind die Ergebnisse:

GCN Val Accuracy: 0.791 ± 0.007
GCN Check Accuracy: 0.806 ± 0.006
GAT Val Accuracy: 0.790 ± 0.007
GAT Check Accuracy: 0.800 ± 0.004
SAGE Val Accuracy: 0.899 ± 0.005
SAGE Check Accuracy: 0.907 ± 0.004

Beeindruckende Verbesserung! Auch in diesem kleinen Datensatz übertrifft Graphsage Gat und GCN leicht! Ich wiederholte diesen Check für CiteSeer- und PubMed -Datensätze, und Graphsage kam immer am besten heraus.

Was ich hier gerne bemerkte, ist, dass GCN immer noch sehr nützlich ist, es ist eine der effektivsten Basislinien (wenn die Grafikstruktur dies zulässt). Außerdem habe ich nicht viel Hyperparameter-Tuning durchgeführt, sondern nur einige Standardwerte (wie 8 Köpfe für die Multi-Head-Aufmerksamkeit). In größeren, komplexeren und lauteren Graphen werden die Vorteile von Graphsage klarer als in diesem Beispiel. Wir haben keine Leistungstests durchgeführt, da für diese kleinen Graphen nicht schneller als GCN.

---

Abschluss

Graphsage bringt uns sehr nette Verbesserungen und Vorteile im Vergleich zu GATS und GCNs. Induktives Lernen ist möglich, Graphsage kann sich recht intestine ändern. Und wir haben es in diesem Beitrag nicht getestet, aber die Nachbar -Probenahme ermöglicht es, Characteristic -Darstellungen für größere Grafiken mit guter Leistung zu erstellen.

Verwandt

Optimierung von Verbindungen: Mathematische Optimierung innerhalb der Grafiken

Graph Neural Networks Teil 1. Graph Faltungsnetzwerke erläutert

Graph Neural Networks Teil 2. Diagramm -Aufmerksamkeitsnetzwerke vs. GCNs

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.