Préparer des données pour le réglage des modèles Hugging Face
Vous pouvez préparer vos données pour l’ajustement (« fine-tuning »)des grands modèles de langage open source à l’aide de Hugging Face Transformers et Hugging Face Datasets.
Spécifications
- Databricks Runtime pour le Machine Learning 13.0 ou versions ultérieures. Les exemples de ce guide utilisent des jeux de données Hugging Face inclus dans Databricks Runtime 13.0 ML et versions ultérieures.
Charger des données depuis Hugging Face
Hugging Face Datasets est une bibliothèque de Hugging Face permettant d’accéder et de partager des jeux de données pour les tâches audio, de vision par ordinateur et de traitement en langage naturel (NLP). Avec Hugging Face datasets, vous pouvez charger des données à partir de différents emplacements. La bibliothèque datasets dispose d’utilitaires pour lire des jeux de données à partir de Hugging Face Hub. Il existe de nombreux jeux de données téléchargeables et lisibles à partir de Hugging Face Hub à l’aide de la fonction load_dataset. Pour plus d’informations sur le chargement de données avec Hugging Face Datasets, consultez la documentation de Hugging Face.
from datasets import load_dataset
dataset = load_dataset("imdb")
Certains jeux de données dans Hugging Face Hub fournissent les tailles de données qui sont téléchargées et générées lorsque load_dataset est appelé. Vous pouvez utiliser load_dataset_builder pour connaître les tailles avant de télécharger le jeu de données avec load_dataset.
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")
Pour obtenir des conseils sur le téléchargement et la préparation de jeux de données sur Azure Databricks pour différentes tailles de données, consultez le notebook Télécharger des jeux de données à partir de Hugging Face.
Mettre en forme vos données d’entraînement et d’évaluation
Pour utiliser vos propres données pour le réglage précis du modèle, vous devez d’abord mettre en forme vos données d’entraînement et d’évaluation dans des dataframes Spark. Ensuite, chargez les DataFrames à l’aide de la bibliothèque Hugging Face datasets.
Commencez par mettre en forme vos données d’entraînement dans une table répondant aux attentes du formateur. Pour la classification de texte, il s’agit d’un tableau avec deux colonnes : une colonne de texte et une colonne d’étiquettes.
Pour effectuer un réglage précis, vous devez fournir un modèle. La bibliothèque Hugging Face Transformer AutoClasses facilite le chargement des modèles et des paramètres de configuration, y compris une large gamme de Auto Models pour le traitement en langage naturel.
Par exemple, Hugging Face transformers fournit AutoModelForSequenceClassification comme chargeur de modèle pour la classification de texte, qui attend des ID entiers comme étiquettes de catégorie. Toutefois, si vous avez un DataFrame avec des étiquettes de chaîne, vous devez également spécifier des mappages entre les étiquettes entières et les étiquettes de chaîne lors de la création du modèle. Vous pouvez collecter ces informations comme suit :
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)}
Ensuite, créez les ID entiers en tant que colonne d’étiquette avec une fonction UDF Pandas :
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)
Charger un jeu de données Hugging Face à partir d’un DataFrame Spark
Hugging Face datasets prend en charge le chargement à partir de DataFrames Spark à l’aide de datasets.Dataset.from_spark. Consultez la documentation Hugging Face pour en savoir plus sur la méthode from_spark().
Par exemple, si vous avez train_dfet test_df des DataFrames, vous pouvez créer des jeux de données pour chacun avec le code suivant :
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 met en cache le jeu de données. Cet exemple décrit l’entraînement du modèle sur le pilote, de sorte que les données doivent être mises à sa disposition. En outre, étant donné que la matérialisation du cache est parallélisée à l’aide de Spark, le cache_dir fourni doit être accessible à tous les workers. Pour satisfaire ces contraintes, cache_dir doit être un volume principal Databricks File System (DBFS) ou un point de montage.
Le volume racine DBFS est accessible à tous les utilisateurs de l’espace de travail et ne doit être utilisé que pour les données sans restrictions d’accès. Si vos données nécessitent des contrôles d’accès, utilisez un point de montage au lieu de la racine DBFS.
Si votre jeu de données est volumineux, son écriture dans DBFS peut prendre beaucoup de temps. Pour accélérer le processus, vous pouvez utiliser le paramètre working_dir, pour que Hugging Face datasets écrive le jeu de données dans un emplacement temporaire sur le disque, puis le déplace vers DBFS. Par exemple, pour utiliser le disque SSD comme emplacement temporaire :
import datasets
dataset = datasets.Dataset.from_spark(
train_df,
cache_dir="/dbfs/cache/train",
working_dir="/local_disk0/tmp/train",
)
Mise en cache pour les jeux de données
Le cache est l’un des moyens datasets d’améliorer l’efficacité. Comme il stocke tous les jeux de données téléchargés et traités, lorsque l’utilisateur a besoin d’utiliser les jeux de données intermédiaires, ils sont rechargés directement à partir du cache.
Le répertoire de cache par défaut des jeux de données est ~/.cache/huggingface/datasets. Lorsqu’un cluster est arrêté, les données du cache sont également perdues. Pour conserver le fichier de cache lors de l’arrêt du cluster, Databricks recommande de remplacer l’emplacement du cache par DBFS en définissant la variable d’environnement HF_DATASETS_CACHE :
import os
os.environ["HF_DATASETS_CACHE"] = "/dbfs/place/you/want/to/save"
Ajuster vos modèles
Lorsque vos données sont prêtes, vous pouvez les utiliser pour ajuster un modèle Hugging Face.
Notebook : Télécharger des jeux de données à partir de Hugging Face
Cet exemple de notebook fournit les meilleures pratiques recommandées d’utilisation de la fonction Hugging Face load_dataset pour télécharger et préparer des jeux de données sur Azure Databricks pour différentes tailles de données.