Préparer les données pour l’affinement des modèles Hugging Face

Cet article explique comment préparer vos données pour l'affinement de grands modèles de langage open source avec Hugging Face Transformers et Hugging Face Datasets.

Exigences

• Databricks Runtime for Machine Learning 13.0 ou version ultérieure. Les exemples de ce guide utilisent les datasets Hugging Face, qui sont inclus dans Databricks Runtime 13.0 ML et versions ultérieures.

• Un Workspace avec Unity Catalog activé. Vous devez également disposer des autorisations suivantes pour écrire des données dans un volume Unity Catalog :

  • Le privilège WRITE VOLUME sur le volume vers lequel vous souhaitez upload des fichiers.
  • Le privilège USE SCHEMA sur le schéma parent.
  • Le privilège USE CATALOG sur le catalogue parent.

• Des ressources de compute importantes pour le download de grands datasets. Le grand dataset utilisé dans le Notebook d'exemple fourni prend plus d'une journée à download.

Charger les données depuis Hugging Face

Hugging Face Jeux de données est une bibliothèque 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 du langage naturel (TLN). Avec Hugging Face datasets, vous pouvez charger des données depuis différents emplacements. La bibliothèque datasets dispose de fonctionnalités pour lire des datasets depuis le Hugging Face Hub. De nombreux datasets sont téléchargeables et lisibles depuis le Hugging Face Hub en utilisant la fonction load_dataset. Apprenez-en davantage sur le chargement de données avec les ensembles de données Hugging Face dans la documentation Hugging Face.

Python

from datasets import load_dataset
dataset = load_dataset("imdb")

Certains jeux de données du Hub Hugging Face fournissent les tailles des données 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 download le dataset avec load_dataset.

Python

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")

Consultez le Notebook des meilleures pratiques de download de jeux de données depuis Hugging Face pour obtenir des conseils sur la façon de download et de préparer des jeux de données sur Databricks pour différentes tailles de données.

Formatez vos données de formation et d'évaluation.

Pour utiliser vos propres données pour l'affinement de modèle, vous devez d'abord formater vos données d'entraînement et d'évaluation en Spark DataFrames. Ensuite, chargez les DataFrames à l'aide de la bibliothèque Hugging Face datasets.

start par formater vos données d'entraînement dans une table répondant aux attentes de l'entraîneur. Pour la classification de texte, il s'agit d'une table avec deux colonnes : une colonne de texte et une colonne d'étiquettes.

Pour effectuer l'affinement, vous devez fournir un modèle. La bibliothèque AutoClasses de Hugging Face Transformer facilite le chargement des modèles et des paramètres de configuration, y compris un large éventail de Auto Models pour le traitement du langage naturel.

Par exemple, Hugging Face transformers fournit AutoModelForSequenceClassification en tant que chargeur de modèle pour la classification de texte, qui attend des ID entiers comme étiquettes de catégorie. Cependant, si vous disposez d'un DataFrame avec des étiquettes de chaîne, vous devez également spécifier des correspondances entre les étiquettes entières et les étiquettes de chaîne lors de la création du modèle. Vous pouvez recueillir ces informations comme suit :

Python

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 comme colonne d'étiquettes avec une UDF Pandas :

Python

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 dataset Hugging Face à partir d'un Spark DataFrame

Hugging Face datasets prend en charge le chargement à partir de Spark DataFrames à 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 disposez de train_df et test_df DataFrames, vous pouvez créer des datasets pour chacun avec le code suivant :

Python

import datasets
train_dataset = datasets.Dataset.from_spark(train_df, cache_dir="/Volumes/main/default/my-volume/train")
test_dataset = datasets.Dataset.from_spark(test_df, cache_dir="/Volumes/main/default/my-volume/test")

Dataset.from_spark met en cache le dataset. Cet exemple décrit l'entraînement de modèles sur le driver ; les données doivent donc lui être rendues accessibles. De plus, comme la matérialisation du cache est parallélisée à l'aide de Spark, le cache_dir fourni doit être accessible à tous les Worker. Pour satisfaire ces contraintes, cache_dir doit être un chemin d'accès au volume Unity Catalog.

L'accès au volume peut être géré à l'aide de Unity Catalog.

Si votre dataset est volumineux, son écriture dans Unity Catalog peut prendre beaucoup de temps. Pour accélérer le processus, vous pouvez utiliser le parameter working_dir pour que Hugging Face datasets écrive le dataset vers un emplacement temporaire sur le disque, puis le déplace vers Unity Catalog. Par exemple, pour utiliser le SSD comme emplacement temporaire :

Python

import datasets
dataset = datasets.Dataset.from_spark(
  train_df,
  cache_dir="/Volumes/main/default/my-volume/train",
  working_dir="/local_disk0/tmp/train",
)

Mise en cache pour les datasets

Le cache est l’un des moyens par lesquels datasets améliore l’efficacité. Il stocke tous les datasets téléchargés et traités, de sorte que lorsque l’utilisateur doit utiliser les datasets intermédiaires, ils sont rechargés directement depuis le cache.

Le répertoire de cache par défaut des dataset est ~/.cache/huggingface/datasets. Lorsqu'un cluster est arrêté, les données de cache sont également perdues. Pour conserver le fichier cache lors de la terminaison du cluster, Databricks recommande de modifier l'emplacement du cache en un chemin de volume Unity Catalog en définissant la variable d'environnement HF_DATASETS_CACHE:

Python

import os
os.environ["HF_DATASETS_CACHE"] = "/Volumes/main/default/my-volume/"

Affiner un modèle

Lorsque vos données sont prêtes, vous pouvez les utiliser pour affiner un modèle Hugging Face.

Notebook : Download datasets from Hugging Face

Ce Notebook d'exemple fournit les meilleures pratiques recommandées pour utiliser la fonction Hugging Face load_dataset afin de download et de préparer des datasets sur Databricks pour différentes tailles de données.

download datasets from the Hugging Face best practices Notebook.

Ouvrir le notebook dans un nouvel ongletOuvrir dans Databricks