Vorbereiten von Daten für die Optimierung von Hugging Face-Modellen
In diesem Artikel wird gezeigt, wie Sie Ihre Daten für die Optimierung großer Open Source-Sprachmodelle mit Hugging Face Transformers und Hugging Face Datasets vorbereiten.
Anforderungen
- Databricks Runtime für Machine Learning 13.0 oder höher. Die Beispiele in diesem Leitfaden verwenden Hugging Face Datasets, die in Databricks Runtime 13.0 ML und höher enthalten sind.
Laden von Daten aus Hugging Face
Hugging Face Datasets ist eine Hugging Face-Bibliothek für den Zugriff auf und die Freigabe von Datasets für Audioaufgaben, Aufgaben für maschinelles Sehen und NLP-Aufgaben (Natural Language Processing, linguistische Datenverarbeitung). Mit datasets von Hugging Face können Sie Daten aus verschiedenen Quellen laden. Die datasets-Bibliothek verfügt über Hilfsprogramme zum Lesen von Datasets aus dem Hugging Face-Hub. Es gibt viele Datasets, die über den Hugging Face-Hub mithilfe der load_dataset-Funktion heruntergeladen und gelesen werden können. Weitere Informationen zum Laden von Daten mit Hugging Face Datasets finden Sie in der Hugging Face-Dokumentation.
from datasets import load_dataset
dataset = load_dataset("imdb")
Einige Datasets im Hugging Face-Hub stellen die Größe der Daten bereit, die heruntergeladen und generiert werden, wenn load_dataset aufgerufen wird. Sie können load_dataset_builder verwenden, um die Größen zu ermitteln, bevor Sie das Dataset mit load_dataset herunterladen.
from datasets import load_dataset_builder
from psutil._common import bytes2human
def print_dataset_size_if_provided(*args, **kwargs):
dataset_builder = load_dataset_builder(*args, **kwargs)
if dataset_builder.info.download_size and dataset_builder.info.dataset_size:
print(f'download_size={bytes2human(dataset_builder.info.download_size)}, dataset_size={bytes2human(dataset_builder.info.dataset_size)}')
else:
print('Dataset size is not provided by uploader')
print_dataset_size_if_provided("imdb")
Informationen zum Herunterladen und Vorbereiten von Datasets in Azure Databricks für unterschiedliche Datengrößen finden Sie im Notebook mit bewährten Methoden zum Herunterladen von Datasets aus Hugging Face.
Formatieren Ihrer Trainings- und Auswertungsdaten
Um Ihre eigenen Daten für die Modelloptimierung zu verwenden, müssen Sie zunächst Ihre Trainings- und Auswertungsdaten in Spark-DataFrames formatieren. Laden Sie dann die DataFrames mithilfe der Hugging Face-Bibliothek datasets.
Formatieren Sie zunächst Ihre Trainingsdaten in einer Tabelle, die den Erwartungen des Trainers entspricht. Für die Textklassifizierung ist dies eine Tabelle mit zwei Spalten: einer Textspalte und einer Spalte mit Bezeichnungen.
Für die Optimierung müssen Sie ein Modell bereitstellen. Die Hugging Face Transformer-Bibliothek AutoClasses erleichtert das Laden von Modellen und Konfigurationseinstellungen, einschließlich einer Vielzahl von Auto Models für die linguistische Datenverarbeitung.
Beispielsweise stellt transformers Hugging Face AutoModelForSequenceClassification als Modellladeprogramm für die Textklassifizierung bereit, das ganzzahlige IDs als Kategoriebezeichnungen erwartet. Wenn Sie jedoch über einen DataFrame mit Zeichenfolgenbezeichnungen verfügen, müssen Sie beim Erstellen des Modells auch Zuordnungen zwischen ganzzahligen Bezeichnungen und Zeichenfolgenbezeichnungen angeben. Sie können diese Informationen wie folgt abrufen:
labels = df.select(df.label).groupBy(df.label).count().collect()
id2label = {index: row.label for (index, row) in enumerate(labels)}
label2id = {row.label: index for (index, row) in enumerate(labels)}
Erstellen Sie dann die ganzzahligen IDs als Bezeichnungsspalte mit einer Pandas-UDF:
from pyspark.sql.functions import pandas_udf
import pandas as pd
@pandas_udf('integer')
def replace_labels_with_ids(labels: pd.Series) -> pd.Series:
return labels.apply(lambda x: label2id[x])
df_id_labels = df.select(replace_labels_with_ids(df.label).alias('label'), df.text)
Laden eines Hugging Face-Datasets aus einem Spark-DataFrame
Hugging Face datasets unterstützt das Laden aus Spark-DataFrames mithilfe von datasets.Dataset.from_spark. Weitere Informationen zur Methode from_spark() finden Sie in der Dokumentation zu Hugging Face.
Wenn Sie beispielsweise über die DataFrames train_df und test_df verfügen, können Sie für beide Datasets mit dem folgenden Code erstellen:
import datasets
train_dataset = datasets.Dataset.from_spark(train_df, cache_dir="/dbfs/cache/train")
test_dataset = datasets.Dataset.from_spark(test_df, cache_dir="/dbfs/cache/test")
Dataset.from_spark speichert das Dataset zwischen. In diesem Beispiel wird das Modelltraining für den Treiber beschrieben, sodass diesem Daten zur Verfügung gestellt werden müssen. Da die Cachematerialisierung mithilfe von Spark parallelisiert wird, muss das bereitgestellte Cacheverzeichnis (cache_dir) für alle Worker zugänglich sein. Damit diese Einschränkungen eingehalten werden können, muss cache_dir ein Databricks File System-Stammvolume (DBFS) oder Bereitstellungspunkt sein.
Auf das DBFS-Stammvolume kann von allen Benutzer*innen des Arbeitsbereichs zugegriffen werden, und es sollte nur für Daten ohne Zugriffsbeschränkungen verwendet werden. Wenn für Ihre Daten Zugriffssteuerungen erforderlich sind, verwenden Sie einen Bereitstellungspunkt anstelle des DBFS-Stamms.
Wenn Ihr Dataset groß ist, kann es lange dauern, es in DBFS zu schreiben. Um den Prozess zu beschleunigen, können Sie den Parameter working_dir verwenden, damit Hugging Face datasets das Dataset an einen temporären Speicherort auf dem Datenträger schreibt und es dann in DBFS verschiebt. So verwenden Sie beispielsweise das SSD als temporären Speicherort
import datasets
dataset = datasets.Dataset.from_spark(
train_df,
cache_dir="/dbfs/cache/train",
working_dir="/local_disk0/tmp/train",
)
Zwischenspeichern für Datasets
Der Cache ist eine der Möglichkeiten, wie datasets die Effizienz verbessert. Er speichert alle heruntergeladenen und verarbeiteten Datasets. Wenn Benutzer*innen die Zwischendatasets verwenden müssen, werden sie also direkt aus dem Cache neu geladen.
Das Standardcacheverzeichnis von Datasets ist ~/.cache/huggingface/datasets. Wenn ein Cluster beendet wird, gehen auch die Cachedaten verloren. Um die Cachedatei bei der Clusterbeendigung beizubehalten, empfiehlt Databricks, den Cachespeicherort durch Festlegen der Umgebungsvariablen HF_DATASETS_CACHE in DBFS zu ändern:
import os
os.environ["HF_DATASETS_CACHE"] = "/dbfs/place/you/want/to/save"
Feinabstimmen eines Modells
Wenn Ihre Daten bereit sind, können Sie sie verwenden, um ein Hugging Face-Modell zu optimieren.
Notebook: Herunterladen von Datasets aus Hugging Face
Dieses Beispiel-Notebook enthält empfohlene bewährte Methoden für die Verwendung der Hugging Face-Funktion load_dataset zum Herunterladen und Vorbereiten von Datasets in Azure Databricks für verschiedene Datengrößen.