Beginnen wir mit einem Beispiel und sehen uns an, was hinter den Kulissen passiert, wenn wir den Code aus Kapitel 1 ausführen:
from transformers import pipeline
classifier = pipeline("sentiment-analysis")
classifier(
[
"I've been waiting for a HuggingFace course my whole life.",
"I hate this so much!",
]
)
dabei erhalten wir:
[{'label': 'POSITIVE', 'score': 0.9598047137260437},
{'label': 'NEGATIVE', 'score': 0.9994558095932007}]
Wie wir in Kapitel 1 gesehen haben, fasst diese Pipeline drei Schritte zusammen: Die Vorverarbeitung des Textes, das Senden der Eingaben durch das Modell und die Nachbearbeitung:
Im folgenden gehen wir auf jeden dieser Schritte ein.
Wie andere neuronale Netze können Transformer-Modelle Rohtext nicht direkt verarbeiten. Daher besteht der erste Schritt unserer Pipeline darin, die Texteingaben in Zahlen umzuwandeln, die das Modell verstehen kann. Dazu verwenden wir einen Tokenizer, der verantwortlich ist für:
Die gesamte Vorverarbeitung muss auf genau dieselbe Weise erfolgen wie beim Vortrainieren des Modells, daher müssen wir diese Informationen zuerst vom Model Hub herunterladen. Dazu verwenden wir die from_pretrained()
Methode der Klasse AutoTokenizer
. Unter Angabe des Checkpoint-Namens unseres Modells werden die Daten des Modell-Tokenizers automatisch abgerufen und zwischengespeichert (und werden daher nur bei der ersten Ausführung des unten stehenden Codes heruntergeladen).
Da der Standard-Checkpoint der sentiment-analysis
Pipeline distilbert-base-uncased-finetuned-sst-2-english
ist (du findest die Modellkarte hier), führen wir Folgendes aus:
from transformers import AutoTokenizer
checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
Sobald wir den Tokenizer geladen haben, können wir unsere Sätze direkt an ihn übergeben und erhalten ein Dictionary zurück, das wir in unser Modell einspeisen können! Dann ist es nur noch Nötig die Liste der Eingabe-IDs in Tensoren umzuwandeln.
Du kannst 🤗 Transformers verwenden, ohne dir dabei Gedanken darüber zu machen, welches ML-Framework als Backend verwendet wird; bei manchen Modellen kann es PyTorch oder TensorFlow sein, bei anderen Flax. Transformer-Modelle akzeptieren jedoch nur Tensoren als Eingabe. Wenn du zum ersten Mal von Tensoren hörst, kannst du dir stattdessen NumPy-Arrays vorstellen. Ein NumPy-Array kann ein Skalar (0D), ein Vektor (1D), eine Matrix (2D) sein oder noch mehrere Dimensionen haben. Es handelt sich im Endeffekt um einen Tensor. Die Tensoren anderer ML-Frameworks verhalten sich ähnlich und sind normalerweise so einfach zu instanziieren wie NumPy-Arrays.
Um anzugeben welche Art von Tensoren wir zurückbekommen wollen (PyTorch, TensorFlow oder einfach NumPy), verwenden wir das Argument return_tensors
:
raw_inputs = [
"I've been waiting for a HuggingFace course my whole life.",
"I hate this so much!",
]
inputs = tokenizer(raw_inputs, padding=True, truncation=True, return_tensors="pt")
print(inputs)
Die Konzepte Padding und Truncation musst du zum jetzigen Zeitpunkt noch nicht begreifen; wir werden dir diese später erklären. Am wichtigsten ist es für dich zu verstehen, dass du einen einzelnen Satz oder eine Liste von Sätzen übergeben kannst, sowie die Art der Tensoren, die du zurückerhalten möchtest. Solltest du keinen Typ angeben, erhältst du als Ergebnis eine Liste von Listen.
So sehen die Ergebnisse als PyTorch-Tensoren aus:
{
'input_ids': tensor([
[ 101, 1045, 1005, 2310, 2042, 3403, 2005, 1037, 17662, 12172, 2607, 2026, 2878, 2166, 1012, 102],
[ 101, 1045, 5223, 2023, 2061, 2172, 999, 102, 0, 0, 0, 0, 0, 0, 0, 0]
]),
'attention_mask': tensor([
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0]
])
}
Die Ausgabe selbst ist ein Dictionary bestehend aus den zwei Schlüsseln input_ids
und attention_mask
. input_ids
enthält zwei Zeilen mit Integers (eine für jeden Satz), mit denen sich die Tokens in jedem Satz eindeutig identifizieren lassen. Wir werden später in diesem Kapitel erklären, um was es sich bei attention_mask
handelt.
Wir können unser vortrainiertes Modell auf die selbe Weise herunterladen, wie wir es mit unserem Tokenizer getan haben. 🤗 Transformers verfügt über eine AutoModel
Klasse, bei der es auch eine from_pretrained()
Methode gibt:
from transformers import AutoModel
checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
model = AutoModel.from_pretrained(checkpoint)
In diesem Code-Snippet haben wir denselben Checkpoint heruntergeladen, den wir zuvor in unserer Pipeline verwendet haben (er sollte daher bereits gecached sein) und damit ein Modell instanziiert.
Diese Architektur enthält nur das Transformer-Basismodul: Bei einer Eingabe gibt es das aus, was wir Hidden States oder auch Features nennen. Für jede Modelleingabe erhalten wir ein hochdimensionalen Vektor, der das kontextuelle Verständnis dieser Eingabe durch das Transformer-Modell darstellt.
Mache dir keine Sorgen, wenn das noch keinen Sinn für dich ergibt. Wir werden alles später erklären.
Auch wenn diese Hidden States für sich genommen nützlich sein können, sind sie in der Regel Eingaben für einen anderen Teil des Modells, den sogenannten Kopf. In Kapitel 1 hätten die verschiedenen Aufgaben mit derselben Architektur ausgeführt werden können, aber jeder dieser Aufgaben ist ein anderer Kopf zugeordnet.
Der vom Transformer-Modul ausgegebene Vektor ist normalerweise groß. Er hat im Allgemeinen drei Dimensionen:
Wegen des letzten Wertes wird sie als “hochdimensional” bezeichnet. Die Dimension der Hidden size kann sehr groß sein (768 ist bei kleineren Modellen üblich, und bei größeren Modellen kann sie bis zu 3072 sein).
Wir können dies sehen, wenn wir die vorverarbeiteten Eingaben in unser Modell einspeisen:
outputs = model(**inputs)
print(outputs.last_hidden_state.shape)
torch.Size([2, 16, 768])
Beachte, dass sich die Ausgaben von 🤗 Transformers-Modellen wie nameduples
oder Dictionaries verhalten. Du kannst auf die Elemente über Attribute zugreifen (wie wir es getan haben) oder über Schlüssel (outputs["last_hidden_state"]
), oder sogar über den Index (outputs[0]
), wenn du genau weißt, wonach du suchst.
Die Modell-Köpfe nehmen den hochdimensionalen Vektor der Hidden States als Eingabe und projizieren sie auf eine andere Dimension. Sie bestehen in der Regel aus einer oder mehreren linearen Ebenen:
Die Ausgabe des Transformer-Modells wird direkt an den Modell-Kopf zur Verarbeitung weitergeleitet.
In diesem Diagramm wird das Modell durch seine Embedding-Ebene und die nachfolgenden Ebenen dargestellt. Die Embedding-Ebene wandelt jede Eingabe-ID in der tokenisierten Eingabe in einen Vektor um, der das zugehörige Token darstellt. Die nachfolgenden Ebenen manipulieren diese Vektoren mit Hilfe des Attention-Mechanismus, um die endgültige Darstellung der Sätze zu erzeugen.
Es gibt viele verschiedene Architekturen in 🤗 Transformers, die jeweils auf eine bestimmte Aufgabe zugeschnitten sind. Um nur einige davon zu nennen:
*Model
(retrieve the hidden states)*ForCausalLM
*ForMaskedLM
*ForMultipleChoice
*ForQuestionAnswering
*ForSequenceClassification
*ForTokenClassification
Für unser Beispiel benötigen wir ein Modell mit einem Sequenzklassifizierungskopf (um die Sätze als positiv oder negativ klassifizieren zu können). Wir werden also nicht die Klasse AutoModel
verwenden, sondern AutoModelForSequenceClassification
:
from transformers import AutoModelForSequenceClassification
checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
model = AutoModelForSequenceClassification.from_pretrained(checkpoint)
outputs = model(**inputs)
Wenn wir nun die Form unserer Eingaben betrachten, ist die Dimensionalität deutlich geringer: Der Modell-Kopf nimmt als Eingabe die hochdimensionalen Vektoren, die wir zuvor gesehen haben, und gibt Vektoren aus, die zwei Werte enthalten (einen pro Label):
print(outputs.logits.shape)
torch.Size([2, 2])
Da wir nur zwei Sätze und zwei Bezeichnungen haben, hat das Ergebnis unseres Modells die Form 2 x 2.
Die Werte, die wir als Ausgabe unseres Modells erhalten, ergeben auf den ersten Blick nicht unbedingt einen Sinn. Schauen wir uns das mal an:
print(outputs.logits)
tensor([[-1.5607, 1.6123],
[ 4.1692, -3.3464]], grad_fn=<AddmmBackward>)
Unser Modell gibt [-1.5607, 1.6123]
für den ersten Satz und [ 4.1692, -3.3464]
für den zweiten Satz aus. Dabei handelt es sich nicht um Wahrscheinlichkeiten, sondern um Logits, d. h. die rohen, nicht normierten Werte, die von der letzten Ebene des Modells ausgegeben werden. Um diese in Wahrscheinlichkeiten umzuwandeln, muss auf sie die SoftMax Funktion angewendet werden (alle 🤗 Transformers-Modelle geben die Logits aus, da die Verlustfunktion für das Training im Allgemeinen die letzte Aktivierungsfunktion, wie SoftMax, mit der eigentlichen Verlustfunktion, wie Kreuzentropie, kombiniert):
import torch
predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
print(predictions)
tensor([[4.0195e-02, 9.5980e-01],
[9.9946e-01, 5.4418e-04]], grad_fn=<SoftmaxBackward>)
Jetzt können wir sehen, dass das Modell [0.0402, 0.9598]
für den ersten Satz und [0.9995, 0.0005]
für den zweiten Satz vorausgesagt hat. Dabei handelt es sich um Wahrscheinlichkeitswerte.
Um das dazugehörige Label für jede Position zu erhalten, können wir uns das Attribut id2label
der Modellkonfiguration ansehen (mehr dazu im nächsten Abschnitt):
model.config.id2label
{0: 'NEGATIVE', 1: 'POSITIVE'}
Wir können nun feststellen, dass das Modell Folgendes vorausgesagt hat:
Wir haben die drei Schritte der Pipeline erfolgreich reproduziert: Die Vorverarbeitung mit Tokenizern, das Senden der Eingaben durch das Modell und die Nachverarbeitung! Jetzt werden wir uns etwas Zeit nehmen, um in jeden dieser Schritte noch tiefer einzutauchen.
✏️ Probiere es selbst aus! Wähle zwei (oder mehr) deiner eigenen Texte und lasse sie durch die sentiment-analysis
Pipeline laufen. Dann wiederhole die Schritte, die wir dir hier gezeigt haben und prüfe, ob du die gleichen Ergebnisse erhältst!