Codebeispiel für die Feinabstimmung des BART: WMT16-Datensatzes durch Huggingface, um neue Tags für die Übersetzung zu trainieren

Wenn Sie eine neue Architektur für Übersetzungsaufgaben testen möchten, z. B. das Trainieren eines neuen Markers für einen benutzerdefinierten Datensatz, ist die Handhabung umständlich. Daher werde ich in diesem Artikel die Methode zum Hinzufügen eines neuen Markers vorstellen Vorverarbeitung Schritte und Einführung in die Feinabstimmung des Modells.

Da Huggingface Hub über viele vorab trainierte Modelle verfügt, ist es einfach, vorab trainierte Tagger zu finden. Es kann jedoch etwas schwierig sein, einen Marker hinzuzufügen. Lassen Sie uns zunächst die Implementierung ausführlich erläutern. Laden Sie den Datensatz und verarbeiten Sie ihn vor.

Datensatz wird geladen

Wir verwenden den WMT16-Datensatz und seinen rumänisch-englischen Teilsatz. Die Funktion „load_dataset()“ lädt alle verfügbaren Datensätze von Huggingface herunter und lädt sie.

import datasets
 
 dataset = datasets.load_dataset("stas/wmt16-en-ro-pre-processed", cache_dir="./wmt16-en_ro")

Der Inhalt des Datensatzes ist in Abbildung 1 oben zu sehen. Wir müssen es „flachen“, damit wir besser auf die Daten zugreifen und sie auf der Festplatte speichern können.

def flatten(batch):
 batch['en'] = batch['translation']['en']
 batch['ro'] = batch['translation']['ro']
 
 return batch
 
 # Map the 'flatten' function
 train = dataset['train'].map( flatten )
 test = dataset['test'].map( flatten )
 validation = dataset['validation'].map( flatten )
 
 # Save to disk
 train.save_to_disk("./dataset/train")
 test.save_to_disk("./dataset/test")
 validation.save_to_disk("./dataset/validation")

Wie Sie in Abbildung 2 unten sehen können, wurde die Dimension „Übersetzung“ aus dem Datensatz gelöscht.

Tagger

Tagger bietet die gesamte Arbeit, die zum Trainieren eines Tokenizers erforderlich ist. Es besteht aus vier Grundkomponenten: (aber nicht alle vier sind notwendig)

Modelle: Wie der Tokenizer jedes Wort aufschlüsselt. Nehmen wir zum Beispiel das Wort „playing“: i) Das BPE-Modell zerlegt es in zwei Token „play“ + „ing“, ii) WordLevel behandelt es als ein Token.

Normalisierer: Einige Transformationen, die am Text vorgenommen werden müssen. Es gibt Filter zum Ändern von Unicode, Kleinbuchstaben oder zum Entfernen von Inhalten.

Pre-Tokenizers: Funktionen, die eine größere Flexibilität beim Bedienen von Text bieten. Zum Beispiel, wie man mit Zahlen arbeitet. Sollte die Zahl 100 als „100“ oder „1“, „0“, „0“ betrachtet werden? zur Modellauswahl vor dem Training. Fügen Sie beispielsweise [BOS]-Token (Satzanfang) oder [EOS]-Token (Satzende) zur BERT-Eingabe hinzu.

Der folgende Code verwendet das BPE-Modell, Kleinbuchstaben-Normalisierer und leere Pre-Tokenizer. Initialisieren Sie dann das Trainerobjekt mit Standardwerten, hauptsächlich einschließlich 1, Vokabulargröße 50265, um mit BARTs englischem Tagger

2 und speziellen Tags wie #🎜 🎜# konsistent zu sein.

und

, 3. Anfängliches Vokabular, eine vordefinierte Liste für jeden Modellstartprozess.

from tokenizers import normalizers, pre_tokenizers, Tokenizer, models, trainers
 
 # Build a tokenizer
 bpe_tokenizer = Tokenizer(models.BPE())
 bpe_tokenizer.normalizer = normalizers.Lowercase()
 bpe_tokenizer.pre_tokenizer = pre_tokenizers.Whitespace()
 
 trainer = trainers.BpeTrainer(
 vocab_size=50265,
 special_tokens=["<s>", "<pad>", "</s>", "<unk>", "<mask>"],
 initial_alphabet=pre_tokenizers.ByteLevel.alphabet(),
 )

Der letzte Schritt bei der Verwendung von Huggingface besteht darin, den Trainer und das BPE-Modell zu verbinden und den Datensatz zu übergeben. Je nach Datenquelle können unterschiedliche Trainingsfunktionen genutzt werden. Wir werden train_from_iterator() verwenden. Der neue Tagger ist jetzt verfügbar.

def batch_iterator():
 batch_length = 1000
 for i in range(0, len(train), batch_length):
 yield train[i : i + batch_length]["ro"]
 
 bpe_tokenizer.train_from_iterator( batch_iterator(), length=len(train), trainer=trainer )
 
 bpe_tokenizer.save("./ro_tokenizer.json")

Zeile 5 des obigen Codes ist erforderlich, um das Füll-Tag für den rumänischen Tagger festzulegen. Da es in Zeile 9 verwendet wird, verwendet der Tokenizer Auffüllung, sodass alle Eingaben die gleiche Größe haben.

Das Folgende ist der Trainingsprozess:

from transformers import AutoTokenizer, PreTrainedTokenizerFast
 
 en_tokenizer = AutoTokenizer.from_pretrained( "facebook/bart-base" );
 ro_tokenizer = PreTrainedTokenizerFast.from_pretrained( "./ro_tokenizer.json" );
 ro_tokenizer.pad_token = en_tokenizer.pad_token
 
 def tokenize_dataset(sample):
 input = en_tokenizer(sample['en'], padding='max_length', max_length=120, truncation=True)
 label = ro_tokenizer(sample['ro'], padding='max_length', max_length=120, truncation=True)
 
 input["decoder_input_ids"] = label["input_ids"]
 input["decoder_attention_mask"] = label["attention_mask"]
 input["labels"] = label["input_ids"]
 
 return input
 
 train_tokenized = train.map(tokenize_dataset, batched=True)
 test_tokenized = test.map(tokenize_dataset, batched=True)
 validation_tokenized = validation.map(tokenize_dataset, batched=True)

Der Prozess ist auch sehr einfach. Laden Sie das Bart-Basismodell (Zeile 4), stellen Sie die Trainingsparameter ein (Zeile 6). und verwenden Sie das Trainer-Objekt „Alles binden“ (Zeile 22) und starten Sie den Prozess (Zeile 29). Die oben genannten Hyperparameter dienen Testzwecken. Wenn Sie also die besten Ergebnisse erzielen möchten, müssen Sie die Hyperparameter festlegen. Wir können sie mit diesen Parametern ausführen.

Inferenz

Der Inferenzprozess ist auch sehr einfach. Laden Sie einfach das fein abgestimmte Modell und verwenden Sie die Methode „generate()“, um es zu konvertieren, aber Sie müssen darauf achten die Quell- (En) und Zielsequenzen (RO) mithilfe geeigneter Tokenizer.

Zusammenfassung

Obwohl die Tokenisierung bei der Verwendung der Verarbeitung natürlicher Sprache (Natural Language Processing, NLP) wie ein grundlegender Vorgang erscheinen mag, ist sie ein entscheidender Schritt, der nicht übersehen werden sollte. Das Aufkommen von HuggingFace erleichtert uns die Verwendung, wodurch wir leicht die Grundprinzipien der Tokenisierung vergessen und uns nur auf vorab trainierte Modelle verlassen können. Wenn wir jedoch selbst ein neues Modell trainieren möchten, ist es wichtig, den Tokenisierungsprozess und seine Auswirkungen auf nachgelagerte Aufgaben zu verstehen. Daher ist es notwendig, mit diesem grundlegenden Vorgang vertraut zu sein und ihn zu beherrschen.

Code dieses Artikels: https://github.com/AlaFalaki/tutorial_notebooks/blob/main/translation/hf_bart_translation.ipynb

Das obige ist der detaillierte Inhalt vonCodebeispiel für die Feinabstimmung des BART: WMT16-Datensatzes durch Huggingface, um neue Tags für die Übersetzung zu trainieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!