Feinabstimmung von Whisper-Modellen auf Amazon SageMaker mit LoRA | Amazon Web Services

Whisper ist ein ASR-Modell (Automatic Speech Recognition), das mithilfe von 680,000 Stunden überwachter Daten aus dem Internet trainiert wurde und eine Reihe von Sprachen und Aufgaben umfasst. Eine seiner Einschränkungen ist die geringe Leistung bei Sprachen mit geringen Ressourcen wie der Marathi-Sprache und den dravidischen Sprachen, die durch Feinabstimmung behoben werden können. Die Feinabstimmung eines Whisper-Modells ist jedoch sowohl im Hinblick auf die Rechenressourcen als auch auf den Speicherbedarf zu einer erheblichen Herausforderung geworden. Fünf bis zehn Durchläufe der vollständigen Feinabstimmung für Whisper-Modelle erfordern etwa 100 Stunden A100-GPU (40 GB SXM4) (variiert je nach Modellgröße und Modellparametern), und jeder feinabgestimmte Prüfpunkt erfordert etwa 7 GB Speicherplatz. Diese Kombination aus hohem Rechen- und Speicherbedarf kann insbesondere in Umgebungen mit begrenzten Ressourcen erhebliche Hürden darstellen und es oft außerordentlich schwierig machen, aussagekräftige Ergebnisse zu erzielen.

Low-Rank-Adaption, auch bekannt als LoRAverfolgt einen einzigartigen Ansatz zur Modellfeinabstimmung. Es hält die vorab trainierten Modellgewichte in einem statischen Zustand und führt trainierbare Rangzerlegungsmatrizen in jede Schicht der Transformer-Struktur ein. Diese Methode kann die Anzahl der trainierbaren Parameter, die für nachgelagerte Aufgaben benötigt werden, um das 10,000-fache verringern und den GPU-Speicherbedarf um das Dreifache reduzieren. In Bezug auf die Modellqualität hat sich gezeigt, dass LoRA die Leistung herkömmlicher Feinabstimmungsmethoden erreicht oder sogar übertrifft, obwohl mit weniger trainierbaren Parametern gearbeitet wird (siehe Ergebnisse des Originals). LoRA-Papier). Es bietet auch den Vorteil eines erhöhten Trainingsdurchsatzes. im Gegensatz zu den Adapter Methoden führt LoRA nicht zu zusätzlicher Latenz während der Inferenz, wodurch die Effizienz des Modells während der Bereitstellungsphase erhalten bleibt. Die Feinabstimmung von Whisper mithilfe von LoRA hat vielversprechende Ergebnisse gezeigt. Nehmen Sie zum Beispiel Whisper-Large-v2: Das Ausführen von 3 Epochen mit einem 12-stündigen gemeinsamen Sprachdatensatz auf einer 8-GB-Speicher-GPU dauert 6–8 Stunden, was fünfmal schneller ist als die vollständige Feinabstimmung bei vergleichbarer Leistung.

Amazon Sage Maker ist eine ideale Plattform, um die LoRA-Feinabstimmung von Whisper zu implementieren. Mit Amazon SageMaker können Sie Modelle für maschinelles Lernen für jeden Anwendungsfall mit vollständig verwalteter Infrastruktur, Tools und Workflows erstellen, trainieren und bereitstellen. Zu den weiteren Vorteilen des Modelltrainings können niedrigere Trainingskosten mit Managed Spot Training, verteilte Trainingsbibliotheken zur Aufteilung von Modellen und Trainingsdatensätzen auf AWS-GPU-Instanzen usw. gehören mehr. Die trainierten SageMaker-Modelle können problemlos zur Inferenz direkt auf SageMaker eingesetzt werden. In diesem Beitrag präsentieren wir eine Schritt-für-Schritt-Anleitung zur Implementierung der LoRA-Feinabstimmung in SageMaker. Der zu dieser Implementierung gehörige Quellcode ist auf zu finden GitHub.

Bereiten Sie den Datensatz für die Feinabstimmung vor

Für die Feinabstimmungsaufgabe verwenden wir die ressourcenarme Sprache Marathi. Verwendung der Hugging Face-Datensätze In der Bibliothek können Sie den Common Voice-Datensatz herunterladen und in Trainings- und Testdatensätze aufteilen. Siehe den folgenden Code:

from datasets import load_dataset, DatasetDict language = "Marathi"
language_abbr = "mr"
task = "transcribe"
dataset_name = "mozilla-foundation/common_voice_11_0" common_voice = DatasetDict()
common_voice["train"] = load_dataset(dataset_name, language_abbr, split="train+validation", use_auth_token=True)
common_voice["test"] = load_dataset(dataset_name, language_abbr, split="test", use_auth_token=True)

Für das Whisper-Spracherkennungsmodell sind Audioeingaben erforderlich 16-kHz-Mono-16-Bit-WAV-Dateien mit Vorzeichen. Da der Common Voice-Datensatz eine Abtastrate von 48 KB hat, müssen Sie die Audiodateien zunächst herunterskalieren. Anschließend müssen Sie den Feature-Extraktor von Whisper auf das Audio anwenden, um Log-Mel-Spektrogramm-Features zu extrahieren, und den Tokenizer von Whisper auf die eingerahmten Features anwenden, um jeden Satz im Transkript in eine Token-ID umzuwandeln. Siehe den folgenden Code:

from transformers import WhisperFeatureExtractor
from transformers import WhisperTokenizer feature_extractor = WhisperFeatureExtractor.from_pretrained(model_name_or_path)
tokenizer = WhisperTokenizer.from_pretrained(model_name_or_path, language=language, task=task) def prepare_dataset(batch):
# load and resample audio data from 48 to 16kHz
audio = batch["audio"] # compute log-Mel input features from input audio array
batch["input_features"] = feature_extractor(audio["array"], sampling_rate=audio["sampling_rate"]).input_features[0] # encode target text to label ids
batch["labels"] = tokenizer(batch["sentence"]).input_ids
return batch #apply the data preparation function to all of our fine-tuning dataset samples using dataset's .map method.
common_voice = common_voice.map(prepare_dataset, remove_columns=common_voice.column_names["train"], num_proc=2)
common_voice.save_to_disk("marathi-common-voice-processed")
!aws s3 cp --recursive "marathi-common-voice-processed" s3://<Your-S3-Bucket>

Nachdem Sie alle Trainingsbeispiele verarbeitet haben, laden Sie die verarbeiteten Daten auf Amazon S3 hoch, damit Sie sie bei der Verwendung der verarbeiteten Trainingsdaten in der Feinabstimmungsphase verwenden können FastFile So mounten Sie die S3-Datei direkt, anstatt sie auf die lokale Festplatte zu kopieren:

from sagemaker.inputs import TrainingInput
training_input_path=s3uri
training = TrainingInput(
s3_data_type='S3Prefix', # Available Options: S3Prefix | ManifestFile | AugmentedManifestFile
s3_data=training_input_path,
distribution='FullyReplicated', # Available Options: FullyReplicated | ShardedByS3Key
input_mode='FastFile'
)

Trainiere das Modell

Zur Demonstration verwenden wir whisper-large-v2 als vorab trainiertes Modell (whisper v3 ist jetzt verfügbar), das über die Hugging Face-Transformer-Bibliothek importiert werden kann. Sie können verwenden 8-Bit-Quantisierung um die Trainingseffizienz weiter zu verbessern. Die 8-Bit-Quantisierung bietet eine Speicheroptimierung durch Rundung von Gleitkommazahlen auf 8-Bit-Ganzzahlen. Es handelt sich um eine häufig verwendete Technik zur Modellkomprimierung, um die Einsparungen durch reduzierten Speicher zu erzielen, ohne die Präzision bei der Inferenz zu stark zu beeinträchtigen.

Um das vorab trainierte Modell im quantisierten 8-Bit-Format zu laden, fügen wir beim Instanziieren des Modells einfach das Argument „load_in_8bit=True“ hinzu, wie im folgenden Code gezeigt. Dadurch werden die auf 8 Bit quantisierten Modellgewichte geladen, wodurch der Speicherbedarf reduziert wird.

from transformers import WhisperForConditionalGeneration model = WhisperForConditionalGeneration.from_pretrained(model_name_or_path, load_in_8bit=True, device_map="auto")

Wir verwenden die LoRA-Implementierung von Hugging Face's peft Paket. Die Feinabstimmung eines Modells mithilfe von LoRA erfolgt in vier Schritten:

1. Instanziieren Sie ein Basismodell (wie wir es im letzten Schritt getan haben).
2. Erstellen Sie eine Konfiguration (LoraConfig), wo LoRA-spezifische Parameter definiert sind.
3. Wickeln Sie das Basismodell mit ein get_peft_model() um eine trainierbare zu bekommen PeftModel.
4. Trainiere die PeftModel als Basismodell.

Siehe folgenden Code:

from peft import LoraConfig, get_peft_model config = LoraConfig(r=32, lora_alpha=64, target_modules=["q_proj", "v_proj"], lora_dropout=0.05, bias="none")
model = get_peft_model(model, config) training_args = Seq2SeqTrainingArguments(
output_dir=args.model_dir,
per_device_train_batch_size=int(args.train_batch_size),
gradient_accumulation_steps=1,
learning_rate=float(args.learning_rate),
warmup_steps=args.warmup_steps,
num_train_epochs=args.num_train_epochs,
evaluation_strategy="epoch",
fp16=True,
per_device_eval_batch_size=args.eval_batch_size,
generation_max_length=128,
logging_steps=25,
remove_unused_columns=False,
label_names=["labels"],
)
trainer = Seq2SeqTrainer(
args=training_args,
model=model,
train_dataset=train_dataset["train"],
eval_dataset=train_dataset.get("test", train_dataset["test"]),
data_collator=data_collator,
tokenizer=processor.feature_extractor,
)

Um a SageMaker-Schulung Job, wir bringen unseren eigenen Docker-Container mit. Sie können das Docker-Image herunterladen von GitHub, wo ffmpeg4 und git-lfs zusammen mit anderen Python-Anforderungen gepackt sind. Weitere Informationen zum Anpassen Ihres eigenen Docker-Containers für die Arbeit mit SageMaker finden Sie unter Anpassung Ihres eigenen Trainingscontainers. Dann können Sie den Hugging Face Estimator verwenden und einen SageMaker-Schulungsauftrag starten:

OUTPUT_PATH= f's3://{BUCKET}/{PREFIX}/{TRAINING_JOB_NAME}/output/' huggingface_estimator = HuggingFace(entry_point='train.sh',
source_dir='./src',
output_path= OUTPUT_PATH,
instance_type=instance_type,
instance_count=1,
# transformers_version='4.17.0',
# pytorch_version='1.10.2',
py_version='py310',
image_uri=<ECR-PATH>,
role=ROLE,
metric_definitions = metric_definitions,
volume_size=200,
distribution=distribution,
keep_alive_period_in_seconds=1800,
environment=environment,
) huggingface_estimator.fit(job_name=TRAINING_JOB_NAME, wait=False)

Die Implementierung von LoRA ermöglichte es uns, die große Feinabstimmungsaufgabe „Whisper“ auf einer einzelnen GPU-Instanz (z. B. ml.g5.2xlarge) auszuführen. Im Vergleich dazu erfordert die vollständige Feinabstimmungsaufgabe Whisper Large mehrere GPUs (z. B. ml.p4d.24xlarge) und eine viel längere Trainingszeit. Genauer gesagt hat unser Experiment gezeigt, dass die vollständige Feinabstimmungsaufgabe im Vergleich zum LoRA-Ansatz 24-mal mehr GPU-Stunden erfordert.

Bewerten Sie die Modellleistung

Um die Leistung des fein abgestimmten Whisper-Modells zu bewerten, berechnen wir die Wortfehlerrate (WER) anhand eines durchgehaltenen Testsatzes. WER misst den Unterschied zwischen dem vorhergesagten Transkript und dem Ground-Truth-Transkript. Ein niedrigerer WER weist auf eine bessere Leistung hin. Sie können das folgende Skript für das vorab trainierte Modell und das fein abgestimmte Modell ausführen und deren WER-Unterschiede vergleichen:

metric = evaluate.load("wer") eval_dataloader = DataLoader(common_voice["test"], batch_size=8, collate_fn=data_collator) model.eval()
for step, batch in enumerate(tqdm(eval_dataloader)):
with torch.cuda.amp.autocast():
with torch.no_grad():
generated_tokens = (
model.generate(
input_features=batch["input_features"].to("cuda"),
decoder_input_ids=batch["labels"][:, :4].to("cuda"),
max_new_tokens=255,
)
.cpu()
.numpy()
)
labels = batch["labels"].cpu().numpy()
labels = np.where(labels != -100, labels, tokenizer.pad_token_id)
decoded_preds = tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)
decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True)
metric.add_batch(
predictions=decoded_preds,
references=decoded_labels,
)
del generated_tokens, labels, batch
gc.collect()
wer = 100 * metric.compute()
print(f"{wer=}")

Zusammenfassung

In diesem Beitrag haben wir die Feinabstimmung von Whisper demonstriert, einem hochmodernen Spracherkennungsmodell. Insbesondere haben wir PEFT LoRA von Hugging Face verwendet und die 8-Bit-Quantisierung für ein effizientes Training aktiviert. Wir haben auch gezeigt, wie der Trainingsjob auf SageMaker ausgeführt wird.

Obwohl dies ein wichtiger erster Schritt ist, gibt es mehrere Möglichkeiten, wie Sie auf dieser Arbeit aufbauen können, um das Flüstermodell weiter zu verbessern. Erwägen Sie in Zukunft die Verwendung des verteilten SageMaker-Trainings, um das Training auf einen viel größeren Datensatz zu skalieren. Dadurch kann das Modell auf vielfältigeren und umfassenderen Daten trainiert werden, wodurch die Genauigkeit verbessert wird. Sie können auch die Latenz bei der Bereitstellung des Whisper-Modells optimieren, um eine Spracherkennung in Echtzeit zu ermöglichen. Darüber hinaus könnten Sie die Arbeit erweitern, um längere Audiotranskriptionen zu verarbeiten, was Änderungen an der Modellarchitektur und den Trainingsschemata erfordert.

Wissen

Die Autoren danken Paras Mehra, John Sol und Evandro Franco für ihr aufschlussreiches Feedback und die Rezension des Beitrags.

Über die Autoren

Juni Shi ist Senior Solutions Architect bei Amazon Web Services (AWS). Seine aktuellen Schwerpunkte sind KI/ML-Infrastruktur und -Anwendungen. Er verfügt über mehr als ein Jahrzehnt Erfahrung in der FinTech-Branche als Softwareentwickler.

Dr. Changsha Ma ist KI/ML-Spezialist bei AWS. Sie ist Technologin mit einem Doktortitel in Informatik, einem Master-Abschluss in Pädagogischer Psychologie und jahrelanger Erfahrung in Datenwissenschaft und unabhängiger Beratung im Bereich KI/ML. Ihre Leidenschaft gilt der Erforschung methodischer Ansätze für maschinelle und menschliche Intelligenz. Außerhalb der Arbeit geht sie gerne wandern, kocht, geht auf Nahrungssuche und verbringt Zeit mit Freunden und Familien.

• SEO-gestützte Content- und PR-Distribution. Holen Sie sich noch heute Verstärkung.
• PlatoData.Network Vertikale generative KI. Motiviere dich selbst. Hier zugreifen.
• PlatoAiStream. Web3-Intelligenz. Wissen verstärkt. Hier zugreifen.
• PlatoESG. Kohlenstoff, CleanTech, Energie, Umwelt, Solar, Abfallwirtschaft. Hier zugreifen.
• PlatoHealth. Informationen zu Biotechnologie und klinischen Studien. Hier zugreifen.
• Quelle: https://aws.amazon.com/blogs/machine-learning/fine-tune-whisper-models-on-amazon-sagemaker-with-lora/