In diesem Abschnitt werden wir uns die Erstellung und Verwendung eines Modells genauer ansehen. Wir werden die Klasse AutoModel
verwenden, die praktisch ist, wenn du ein beliebiges Modell von einem Checkpoint aus instanziieren willst.
Die Klasse AutoModel
und alle ihre verwandten Klassen sind eigentlich einfache Wrapper für die Vielzahl der in der Bibliothek verfügbaren Modelle. Es ist ein smarter Wrapper, da er automatisch die passende Modellarchitektur für deinen Checkpoint erkennen kann und dann ein Modell mit dieser Architektur instanziiert.
Wenn du jedoch den Typ des Modells kennst, das du verwenden möchtest, kannst du die Klasse der Architektur direkt verwenden. Schauen wir uns an, wie das mit einem BERT-Modell funktioniert.
Das erste, was wir tun müssen, um ein BERT-Modell zu initialisieren, ist das Laden eines Konfigurationsobjekts:
from transformers import BertConfig, BertModel
# Building the config
config = BertConfig()
# Building the model from the config
model = BertModel(config)
Die Konfiguration enthält viele Attribute, die zur Erstellung des Modells verwendet werden:
print(config)
BertConfig {
[...]
"hidden_size": 768,
"intermediate_size": 3072,
"max_position_embeddings": 512,
"num_attention_heads": 12,
"num_hidden_layers": 12,
[...]
}
Du hast zwar noch nicht gesehen, was all diese Attribute bewirken, aber du solltest einige von ihnen erkennen: Das Attribut hidden_size
definiert die Größe des Vektors hidden_states
, und num_hidden_layers
definiert die Anzahl der Ebenen, die das Transformer-Modell hat.
Bei der Erstellung eines Modells aus der Standardkonfiguration wird es mit Zufallswerten initialisiert:
from transformers import BertConfig, BertModel
config = BertConfig()
model = BertModel(config)
# Model is randomly initialized!
Das Modell kann in diesem Zustand verwendet werden, aber es wird Unsinn ausgeben; es muss erst trainiert werden. Wir könnten das Modell von Grund auf für die vorliegende Aufgabe trainieren, aber wie du in Kapitel 1 gesehen hast, würde dies viel Zeit und eine Menge Daten erfordern, und es hätte nicht unerhebliche Auswirkungen auf die Umwelt. Um unnötigen und doppelten Aufwand zu vermeiden, ist es unerlässlich, bereits trainierte Modelle gemeinsam zu nutzen und wiederzuverwenden.
Das Laden eines bereits trainierten Transformer-Modells ist einfach - wir können dies mit der Methode from_pretrained()
tun:
from transformers import BertModel
model = BertModel.from_pretrained("bert-base-cased")
Wie du bereits gesehen hast, können wir BertModel
durch die entsprechende Klasse AutoModel
ersetzen. Wir werden dies von nun an tun, da dies zu Checkpoint-spezifischem Code führt; wenn dein Code für einen Checkpoint funktioniert, sollte er nahtlos mit einem anderen funktionieren. Dies gilt selbst dann, wenn die Architektur unterschiedlich ist, solange der Checkpoint für eine ähnliche Aufgabe trainiert wurde (z.B. für eine Sentiment-Analyse).
Im obigen Codebeispiel haben wir BertConfig
nicht verwendet und stattdessen ein trainiertes Modell über die Kennung bert-base-cased
geladen. Dies ist ein Modell-Checkpoint, der von den Autoren von BERT selbst trainiert wurde; du kannst mehr Details darüber in seiner model card finden.
Dieses Modell wird nun mit allen Gewichten des Checkpoints initialisiert. Es kann direkt für die Inferenz für die Aufgaben verwendet werden, auf die es trainiert wurde, und es kann auch auf eine neue Aufgabe feingetunt werden. Indem wir mit vortrainierten Gewichten trainieren und nicht von Grund auf neu, können wir schnell gute Ergebnisse erzielen.
Die Gewichte wurden heruntergeladen und im Cache gespeichert (so dass sie bei zukünftigen Aufrufen der Methode from_pretrained()
nicht erneut heruntergeladen werden), der standardmäßig auf ~/.cache/huggingface/transformers liegt. Du kannst deinen Cache-Ordner anpassen, indem du die Umgebungsvariable HF_HOME
setzt.
Die zum Laden des Modells verwendete Kennung kann die eines beliebigen Modells im Model Hub sein, solange es mit der BERT-Architektur kompatibel ist. Die gesamte Liste der verfügbaren BERT-Checkpoints findest du hier.
Das Speichern eines Modells ist so einfach wie das Laden eines Modells - wir verwenden die Methode save_pretrained()
, die analog zur Methode from_pretrained()
ist:
model.save_pretrained("directory_on_my_computer")
Dadurch werden zwei Dateien auf Ihrer Festplatte gespeichert:
ls directory_on_my_computer
config.json pytorch_model.bin
Wenn du einen Blick auf die Datei config.json wirfst, wirst du die Attribute erkennen, die zum Aufbau der Modellarchitektur erforderlich sind. Diese Datei enthält auch einige Metadaten, z. B. woher der Checkpoint stammt und welche 🤗 Transformers-Version du beim letzten Speichern des Checkpoints verwendet hast.
Die Datei pytorch_model.bin wird als State Dictionary bezeichnet; sie enthält alle Gewichte deines Modells. Die beiden Dateien gehen Hand in Hand; die Konfiguration ist notwendig, um die Architektur deines Modells zu kennen, während die Modellgewichte die Parameter deines Modells sind.
Nachdem du nun weißt, wie man ein Modell lädt und speichert, lass uns versuchen, damit einige Vorhersagen zu machen. Transformer-Modelle können nur Zahlen verarbeiten - Zahlen, die der Tokenizer erzeugt. Doch bevor wir uns mit Tokenizern befassen, sollten wir uns ansehen, welche Eingaben das Modell akzeptiert.
Tokenizer können sich um die Umwandlung der Eingaben in die Tensoren des entsprechenden Frameworks kümmern, aber damit du besser verstehst, was vor sich geht, werfen wir einen kurzen Blick darauf, was getan werden muss, bevor die Eingaben an das Modell gesendet werden.
Nehmen wir an, wir haben ein paar Sequenzen:
sequences = ["Hello!", "Cool.", "Nice!"]
Der Tokenizer wandelt diese in Vokabularindizes um, die üblicherweise als Input IDs bezeichnet werden. Jede Sequenz ist nun eine Liste von Zahlen! Die resultierende Ausgabe ist:
encoded_sequences = [
[101, 7592, 999, 102],
[101, 4658, 1012, 102],
[101, 3835, 999, 102],
]
Dies ist eine Liste von kodierten Sequenzen: eine Liste von Listen. Tensoren akzeptieren nur rechteckige Formen (ähnlich wie bei Matrizen). Dieses “Array” hat bereits eine rechteckige Form, so dass die Umwandlung in einen Tensor einfach ist:
import torch
model_inputs = torch.tensor(encoded_sequences)
Die Verwendung der Tensoren mit dem Modell ist extrem einfach - wir rufen das Modell einfach mit den Eingaben auf:
output = model(model_inputs)
Obwohl das Modell viele verschiedene Argumente akzeptiert, sind nur die Eingabe-IDs erforderlich. Wir werden später erklären, was die anderen Argumente bewirken und wann sie erforderlich sind, aber zunächst müssen wir einen genaueren Blick auf die Tokenizer werfen, die die Eingaben erstellen, die ein Transformer-Modell verstehen kann.