ludwig

Cadre d'apprentissage profond déclaratif conçu pour l'évolutivité et l'efficacité.

Important

Notre communauté a déménagé sur Discord – rejoignez-nous là-bas !

Qu'est-ce que Ludwig ?

Ludwig est un framework low-code permettant de créer des modèles d'IA personnalisés tels que les LLM et d'autres réseaux de neurones profonds.

Principales caractéristiques :

• ? Créez facilement des modèles personnalisés : un fichier de configuration YAML déclaratif est tout ce dont vous avez besoin pour former un LLM de pointe sur vos données. Prise en charge de l’apprentissage multitâche et multimodalité. La validation complète de la configuration détecte les combinaisons de paramètres non valides et évite les échecs d'exécution.
• ⚡ Optimisé pour l'évolutivité et l'efficacité : sélection automatique de la taille des lots, formation distribuée (DDP, DeepSpeed), réglage fin efficace des paramètres (PEFT), quantification 4 bits (QLoRA), optimiseurs paginés et 8 bits et mémoire plus grande que la mémoire ensembles de données.
• ? Contrôle de niveau expert : conservez le contrôle total de vos modèles jusqu’aux fonctions d’activation. Prise en charge de l'optimisation des hyperparamètres, de l'explicabilité et de riches visualisations de métriques.
• ? Modulaire et extensible : expérimentez différentes architectures de modèles, tâches, fonctionnalités et modalités avec seulement quelques modifications de paramètres dans la configuration. Pensez aux éléments constitutifs de l’apprentissage profond.
• ? Conçu pour la production : conteneurs Docker prédéfinis, prise en charge native de l'exécution avec Ray sur Kubernetes, exportation de modèles vers Torchscript et Triton, téléchargement sur HuggingFace avec une seule commande.

Ludwig est hébergé par la Linux Foundation AI & Data.

? Installation

Installez depuis PyPi. Sachez que Ludwig nécessite Python 3.8+.

pip install ludwig

Ou installez avec toutes les dépendances facultatives :

pip install ludwig[full]

Veuillez consulter la contribution pour des instructions d'installation plus détaillées.

? Commencer

Vous souhaitez jeter un coup d’œil rapide à certaines des fonctionnalités de Ludwig 0.8 ? Découvrez ce carnet Colab

Vous cherchez à peaufiner Llama-2 ou Mistral ? Découvrez ces cahiers :

1. Affiner le Lama-2-7b :
2. Affiner le Lama-2-13b :
3. Affiner Mistral-7b :

Pour un didacticiel complet, consultez le guide de démarrage officiel ou jetez un œil aux exemples de bout en bout.

Ajustement du modèle de langage étendu

Affinons un grand modèle de langage LLaMA-2-7b pré-entraîné pour suivre des instructions comme un chatbot (« réglage des instructions »).

Conditions préalables

• Jeton API HuggingFace
• Approbation d'accès à Llama2-7b-hf
• GPU avec au moins 12 Go de VRAM (dans nos tests, nous avons utilisé un Nvidia T4)

En cours d'exécution

Nous utiliserons l'ensemble de données Stanford Alpaca, qui sera formaté sous la forme d'un fichier de type tableau ressemblant à ceci :

instruction	saisir	sortir
Donnez trois conseils pour rester en bonne santé.		1. Ayez une alimentation équilibrée et assurez-vous d’inclure...
Disposez les éléments ci-dessous dans l'ordre de...	gâteau, moi, en train de manger	Je mange du gâteau.
Écrivez un paragraphe d'introduction sur un célèbre...	Michelle Obama	Michelle Obama est une femme inspirante qui r...
...	...	...

Créez un fichier de configuration YAML nommé model.yaml avec ce qui suit :

 model_type : llm
base_model : meta-llama/Llama-2-7b-hf

quantization :
  bits : 4

adapter :
  type : lora

prompt :
  template : |
    Below is an instruction that describes a task, paired with an input that may provide further context.
    Write a response that appropriately completes the request.

    ### Instruction:
    {instruction}

    ### Input:
    {input}

    ### Response:

input_features :
  - name : prompt
    type : text

output_features :
  - name : output
    type : text

trainer :
  type : finetune
  learning_rate : 0.0001
  batch_size : 1
  gradient_accumulation_steps : 16
  epochs : 3
  learning_rate_scheduler :
    decay : cosine
    warmup_fraction : 0.01

preprocessing :
  sample_ratio : 0.1

backend :
  type : local

Et maintenant, entraînons le modèle :

 export HUGGING_FACE_HUB_TOKEN = " <api_token> "

ludwig train --config model.yaml --dataset " ludwig://alpaca " 

ML supervisé

Construisons un réseau neuronal qui prédit si la critique d'un critique de cinéma donné sur Rotten Tomatoes était positive ou négative.

Notre ensemble de données sera un fichier CSV qui ressemble à ceci :

titre_film	content_rating	genres	durée d'exécution	top_critique	review_content	recommandé
Délivre-nous du mal	R.	Action & Aventure, Horreur	117,0	VRAI	Le réalisateur Scott Derrickson et son co-scénariste, Paul Harris Boardman, livrent une procédure routinière avec des frayeurs banales.	0
Barbara	PG-13	Art, essai et international, Théâtre	105,0	FAUX	D'une manière ou d'une autre, dans ce récit émouvant, Barbara parvient à conserver ses principes, son humanité et son courage, et se bat pour sauver une adolescente dissidente dont les communistes tentent de détruire la vie.	1
Des patrons horribles	R.	Comédie	98,0	FAUX	Ces patrons ne peuvent justifier ni le meurtre ni les souvenirs comiques durables, compromettant fatalement une farce qui aurait pu être grande mais qui se révèle simplement médiocre.	0
...	...	...	...	...	...	...

Téléchargez un échantillon de l'ensemble de données à partir d'ici.

wget https://ludwig.ai/latest/data/rotten_tomatoes.csv

Créez ensuite un fichier de configuration YAML nommé model.yaml avec ce qui suit :

 input_features :
  - name : genres
    type : set
    preprocessing :
      tokenizer : comma
  - name : content_rating
    type : category
  - name : top_critic
    type : binary
  - name : runtime
    type : number
  - name : review_content
    type : text
    encoder :
      type : embed
output_features :
  - name : recommended
    type : binary

C'est ça! Entraîneons maintenant le modèle :

ludwig train --config model.yaml --dataset rotten_tomatoes.csv

Bonne modélisation

Essayez d'appliquer Ludwig à vos données. Contactez Discord si vous avez des questions.

❓ Pourquoi devriez-vous utiliser Ludwig

• Modèle standard minimal d'apprentissage automatique

  Ludwig prend en charge la complexité technique de l'apprentissage automatique dès le départ, permettant aux chercheurs de se concentrer sur la création de modèles au plus haut niveau d'abstraction. Le prétraitement des données, l'optimisation des hyperparamètres, la gestion des appareils et la formation distribuée pour les modèles torch.nn.Module sont entièrement gratuits.

• Construisez facilement vos benchmarks

  Créer une base de référence de pointe et la comparer avec un nouveau modèle est un simple changement de configuration.

• Appliquez facilement de nouvelles architectures à plusieurs problèmes et ensembles de données

  Appliquez de nouveaux modèles à l’ensemble complet de tâches et d’ensembles de données pris en charge par Ludwig. Ludwig inclut une boîte à outils d'analyse comparative complète accessible à tout utilisateur, pour exécuter des expériences avec plusieurs modèles sur plusieurs ensembles de données avec une simple configuration.

• Prétraitement, modélisation et métriques des données hautement configurables

  Tous les aspects de l'architecture du modèle, de la boucle de formation, de la recherche d'hyperparamètres et de l'infrastructure backend peuvent être modifiés en tant que champs supplémentaires dans la configuration déclarative pour personnaliser le pipeline afin de répondre à vos besoins. Pour plus de détails sur ce qui peut être configuré, consultez la documentation Ludwig Configuration.

• Apprentissage multimodal et multitâche prêt à l'emploi

  Mélangez et associez des données tabulaires, du texte, des images et même de l'audio dans des configurations de modèles complexes sans écrire de code.

• Exportation et suivi de modèles riches

  Suivez automatiquement tous les essais et métriques avec des outils tels que Tensorboard, Comet ML, Weights & Biases, MLFlow et Aim Stack.

• Adaptez automatiquement la formation aux clusters multi-GPU et multi-nœuds

  Passez de la formation sur votre machine locale au cloud sans modification de code.

• Interface low-code pour les modèles de pointe, y compris les Huggingface Transformers pré-entraînés

  Ludwig s'intègre également nativement aux modèles pré-entraînés, tels que ceux disponibles dans Huggingface Transformers. Les utilisateurs peuvent choisir parmi une vaste collection de modèles PyTorch pré-entraînés de pointe à utiliser sans avoir besoin d’écrire de code. Par exemple, entraîner un modèle d'analyse des sentiments basé sur BERT avec Ludwig est aussi simple que :

  ludwig train --dataset sst5 --config_str " {input_features: [{name: sentence, type: text, encoder: bert}], output_features: [{name: label, type: category}]} "

• Interface low-code pour AutoML

  Ludwig AutoML permet aux utilisateurs d'obtenir des modèles entraînés en fournissant simplement un ensemble de données, la colonne cible et un budget de temps.

   auto_train_results = ludwig . automl . auto_train ( dataset = my_dataset_df , target = target_column_name , time_limit_s = 7200 )

• Production facile

  Ludwig facilite la diffusion de modèles d'apprentissage profond, y compris sur les GPU. Lancez une API REST pour votre modèle Ludwig entraîné.

  ludwig serve --model_path=/path/to/model

  Ludwig prend en charge l'exportation de modèles vers des bundles Torchscript efficaces.

  ludwig export_torchscript -–model_path=/path/to/model

Tutoriels

• Classement du texte
• Classification des données tabulaires
• Classement des images
• Classification multimodale

? Exemples de cas d'utilisation

• Marquage de reconnaissance d'entité nommée
• Compréhension du langage naturel
• Traduction automatique
• Modélisation de dialogue Chit-Chat via seq2seq
• Analyse des sentiments
• Apprentissage ponctuel avec les réseaux siamois
• Réponse visuelle aux questions
• Reconnaissance vocale des chiffres parlés
• Vérification du haut-parleur
• Classification binaire (Titanic)
• Prévisions de séries temporelles
• Prévisions de séries temporelles (Météo)
• Prédiction des notes de films
• Classification multi-étiquettes
• Apprentissage multi-tâches
• Régression simple : prévision de l'efficacité énergétique
• Détection de fraude

Plus d'informations

Lisez nos publications sur Ludwig, le ML déclaratif et les benchmarks SoTA de Ludwig.

Apprenez-en davantage sur le fonctionnement de Ludwig, sur la façon de démarrer et sur d’autres exemples.

Si vous souhaitez contribuer, avez des questions, des commentaires ou des réflexions à partager, ou si vous souhaitez simplement être informé, pensez à rejoindre notre Discord communautaire et suivez-nous sur X !

? Rejoignez la communauté pour construire Ludwig avec nous

Ludwig est un projet open source géré activement qui s'appuie sur les contributions de personnes comme vous. Pensez à rejoindre le groupe actif de contributeurs Ludwig pour faire de Ludwig un framework encore plus accessible et riche en fonctionnalités que tout le monde peut utiliser !

Histoire des étoiles

S'impliquer

• Discorde
• X
• Moyen
• Problèmes GitHub