


LLMS open-source adiquées à l'aide de lamini - analytique vidhya
Apr 12, 2025 am 10:20 AMRécemment, avec la montée en puissance des modèles de grande langue et de l'IA, nous avons vu d'innombrables progrès dans le traitement du langage naturel. Les modèles dans des domaines comme le texte, le code et la génération d'images / vidéo ont un raisonnement et des performances archivés de type humain. Ces modèles fonctionnent exceptionnellement bien dans les questions générales basées sur les connaissances. Des modèles comme GPT-4O, Llama 2, Claude et Gemini sont formés sur des ensembles de données accessibles au public. Ils ne répondent pas à des questions de domaine ou spécifiques au sujet qui peuvent être plus utiles pour diverses taches organisationnelles.
Le réglage fin aide les développeurs et les entreprises à s'adapter et à former des modèles pré-formés à un ensemble de données spécifique au domaine qui archive une précision et une cohérence élevées sur les requêtes liées au domaine. Le réglage fin améliore les performances du modèle sans nécessiter de nombreuses ressources informatiques car les modèles pré-formés ont déjà appris le texte général des vastes données publiques.
Ce blog examinera pourquoi nous devons affiner les modèles pré-formés à l'aide de la plate-forme Lamini. Cela nous permet de affiner et d'évaluer les modèles sans utiliser beaucoup de ressources de calcul.
Alors, commen?ons!
Objectifs d'apprentissage
- Pour explorer le besoin de ToFine-Tune open-source LLMS usinglamini
- Pour découvrir l'utilisation de lamini et sous des instructions sur les modèles affinés
- Pour obtenir une compréhension pratique du processus de bout en bout des modèles de réglage fin.
Cet article a été publié dans le cadre de Thedata Science Blogathon.
Table des matières
- Objectifs d'apprentissage
- Pourquoi les modèles de grande langue devraient-ils affiner?
- Comment affiner les LLMS open-source à l'aide de lamini?
- Préparation des données
- Tokenize l'ensemble de données
- Processus de réglage fin
- Configuration d'un environnement
- Ensemble de données de chargement
- Configuration de la formation pour affiner, le modèle
- Conclusion
- Questions fréquemment posées
Pourquoi les modèles de grande langue devraient-ils affiner?
Les modèles pré-formés sont principalement formés sur de vastes données générales avec une forte chance de manque de contexte ou de connaissances spécifiques au domaine. Les modèles pré-formés peuvent également entra?ner des hallucinations et des sorties inexactes et incohérentes. Les modèles de grande langue les plus populaires basés sur des chatbots comme Chatgpt, Gemini et Bingchat ont montré à plusieurs reprises que les modèles pré-formés sont sujets à de telles inexactitudes. C'est là que le réglage fin arrive à la rescousse, qui peut aider à adapter efficacement les LLM pré-formées aux taches et aux questions spécifiques au sujet. D'autres moyens d'aligner les modèles sur vos objectifs incluent l'ingénierie rapide et l'ingénierie rapide à quelques coups.
Pourtant, le réglage fin reste un surperformateur en ce qui concerne les mesures de performance. Des méthodes telles que le réglage fin efficace des paramètres et le réglage fin du classement adaptatif ont encore amélioré le réglage du modèle et ont aidé les développeurs à générer de meilleurs modèles. Voyons à quel point le réglage du réglage s'adapte dans un contexte de modèle de langue large.
# Chargez l'ensemble de données de réglage fin filename = "lamini_docs.json" instruction_dataset_df = pd.read_json (nom de fichier, lignes = true) instruction_dataset_df # Chargez-le dans un dictionnaire de Python Exemples = instruction_dataset_df.to_dict () # Préparez un échantillon pour un réglage fin Si "Question" dans des exemples et "réponse" dans des exemples: text = exemples ["Question"] [0] Exemples ["Réponse"] [0] ELIF "Instruction" dans des exemples et "réponse" dans des exemples: text = exemples ["instruction"] [0] Exemples ["réponse"] [0] ELIF "entrée" dans des exemples et "sortie" dans des exemples: text = exemples ["entrée"] [0] Exemples ["out"] [0] autre: text = exemples ["text"] [0] # Utilisation d'un modèle d'invite pour créer un ensemble de données instruit pour le réglage fin prompt_template_qa = "" "### Question: {question} ### Répondre: {répondre}"""
Le code ci-dessus montre que le réglage des instructions utilise un modèle d'invite pour préparer un ensemble de données pour le réglage des instructions et affiner un modèle pour un ensemble de données spécifique. Nous pouvons affiner le modèle pré-formé à un cas d'utilisation spécifique en utilisant un tel ensemble de données personnalisé.
La section suivante examinera comment Lamini peut aider à affiner les modèles de grande langue (LLM) pour les ensembles de données personnalisés.
Comment affiner les LLMS open-source usinglamini?
La plate-forme Lamini permet aux utilisateurs de s'affronter et de déployer les modèles de manière transparente sans trop de co?ts et de configurations matérielles. Lamini fournit une pile de bout en bout pour développer, former, régler des modèles, E et déploier des modèles à la commodité des utilisateurs et aux exigences du modèle. Lamini fournit son propre réseau informatique GPU hébergé pour former des modèles de manière rentable.
Les outils de réglage de la mémoire des lamini et l'optimisation de calcul aident à former et à régler les modèles avec une grande précision tout en contr?lant les co?ts. Les modèles peuvent être hébergés n'importe où, sur un cloud privé ou via le réseau GPU de Lamini. Ensuite, nous verrons un guide étape par étape pour préparer les données pour affiner les modèles de grande langue (LLMS) à l'aide de la plate-forme lamini.
Préparation des données
Généralement, nous devons sélectionner un ensemble de données spécifique au domaine pour le nettoyage des données, la promotion, la tokenisation et le stockage pour préparer des données pour toute tache de réglage fin. Après avoir chargé l'ensemble de données, nous le préparons pour le convertir en un ensemble de données réglées par l'instruction. Nous formons chaque échantillon de l'ensemble de données dans un format d'instruction, de question et de réponse pour mieux l'affiner pour nos cas d'utilisation. Consultez la source de l'ensemble de données à l'aide du lien indiqué ici. Examinons l'exemple de code des instructions sur le réglage avec la tokenisation pour la formation à l'aide de la plate-forme lamini.
Importer des pandas en tant que PD # Chargez l'ensemble de données et stockez-le comme ensemble de données d'instructions filename = "lamini_docs.json" instruction_dataset_df = pd.read_json (nom de fichier, lignes = true) Exemples = instruction_dataset_df.to_dict () Si "Question" dans des exemples et "réponse" dans des exemples: text = exemples ["Question"] [0] Exemples ["Réponse"] [0] ELIF "Instruction" dans des exemples et "réponse" dans des exemples: text = exemples ["instruction"] [0] Exemples ["réponse"] [0] ELIF "entrée" dans des exemples et "sortie" dans des exemples: text = exemples ["entrée"] [0] Exemples ["out"] [0] autre: text = exemples ["text"] [0] inside_template = "" "### Question: {question} ### Répondre:""" # Stockez des exemples de réglage fin comme format d'instruction num_examples = len (exemples ["question"]) finetuning_dataset = [] pour i dans la plage (num_examples): Question = Exemples ["Question"] [i] Réponse = Exemples ["Réponse"] [I] text_with_prompt_template = prompt_template.format (question = question) finetuning_dataset.append ({"question": text_with_prompt_template, "Réponse": réponse})
Dans l'exemple ci-dessus, nous avons formaté ?Questions? et ?réponses? dans un modèle invite et les avons stockées dans un fichier séparé pour la tokenisation et le rembourrage avant de former le LLM.
Tokenize l'ensemble de données
# Tokenisation de l'ensemble de données avec rembourrage et troncature Def tokenize_function (Exemples): Si "Question" dans des exemples et "réponse" dans des exemples: text = exemples ["Question"] [0] Exemples ["Réponse"] [0] ELIF "entrée" dans des exemples et "sortie" dans des exemples: text = exemples ["entrée"] [0] Exemples ["out"] [0] autre: text = exemples ["text"] [0] # rembourrage tokenizer.pad_token = tokenizer.eos_token tokenized_inputs = tokenizer ( texte, return_tensers = "np", rembourrage = vrai, ) max_length = min ( tokenized_inputs ["input_ids"]. Forme [1], 2048 ) # troncature du texte tokenizer.truncation_side = "Left" tokenized_inputs = tokenizer ( texte, return_tensers = "np", troncature = vrai, max_length = max_length ) retour tokeniszed_inputs
Le code ci-dessus prend les échantillons d'ensemble de données comme entrée pour le rembourrage et la troncature avec la tokenisation pour générer des échantillons de jeu de données à tokenisés prétraités, qui peuvent être utilisés pour les modèles pré-formés au réglage fin. Maintenant que l'ensemble de données est prêt, nous examinerons la formation et l'évaluation des modèles à l'aide de la plate-forme Lamini.
Processus de réglage fin
Maintenant que nous avons un ensemble de données préparé dans un format d'instruction, nous chargerons l'ensemble de données dans l'environnement et affinerons le modèle LLM pré-formé en utilisant des techniques de formation faciles à utiliser de Lamini.
Configuration d'un environnement
Pour commencer les ouvertures open-ailes finales à l'aide de lalamini, nous devons d'abord nous assurer que notre environnement de code a des ressources et des bibliothèques appropriées installées. Nous devons nous assurer d'avoir une machine appropriée avec des ressources GPU suffisantes et d'installer les bibliothèques nécessaires telles que les transformateurs, les ensembles de données, les torches et les pandas. Vous devez charger en toute sécurité des variables d'environnement comme API_URL et API_KEY, généralement à partir des fichiers environnementaux. Vous pouvez utiliser des packages comme Dotenv pour charger ces variables. Après avoir préparé l'environnement, chargez l'ensemble de données et les modèles de formation.
Importer un système d'exploitation à partir de lamini import lesmini lamini.api_url = os.getenv ("powerml__production__url") lamini.api_key = os.getenv ("powerml__production__key") # Importez la bibliothèque nécessaire et chargez les fichiers environnementaux Importer des ensembles de données Importer Tempfile journalisation d'importation Importer au hasard Importer la configuration Importer un système d'exploitation Importer Yaml heure d'importation Importer une torche Transformers d'importation Importer des pandas en tant que PD Importer des lignes JSON # Chargement de l'architecture du transformateur et [[[ Depuis l'importation des services publics * à partir de Transformers Import Autotokenzer à partir de Transformers Import AutomodelforcUsallm à partir des transformateurs importants de formation à partir de Transformers Import AutomodelforcUsallm de lalama import BasicModelrunner logger = logging.getLogger (__ name__) global_config = aucun
Ensemble de données de chargement
Après avoir configuré la journalisation pour la surveillance et le débogage, préparez votre ensemble de données à l'aide de ensembles de données ou d'autres bibliothèques de traitement des données comme JSONLines et Pandas. Après avoir chargé l'ensemble de données, nous allons configurer un tokenzer et un modèle avec des configurations de formation pour le processus de formation.
# Chargez l'ensemble de données de votre système local ou du cloud HF dataset_name = "lamini_docs.jsonl" dataset_path = f "/ contenu / {dataset_name}" use_hf = false # Chemin de jeu de données dataset_path = "lamini / lamini_docs"
Configurer le modèle, la configuration de la formation et le tokenizer
Ensuite, nous sélectionnons le modèle de réglage fin des OpenCellms à l'aide de lalamini, ?eleutherai / pythia-70m?, et définissons sa configuration sous Training_config, spécifiant le nom du modèle pré-formé et le chemin de l'ensemble de données. Nous initialisons l'autoTokenzizer avec le tokenizer du modèle et fixons le rembourrage sur le jeton de fin de séquence. Ensuite, nous tokenniser les données et les divisera en ensembles de données de formation et de test à l'aide d'une fonction personnalisée, tokenize_and_split_data. Enfin, nous instancions le modèle de base à l'aide de AutomodelforCausallm, lui permettant d'effectuer des taches de modélisation du langage causal. En outre, le code ci-dessous établit des exigences de calcul pour notre processus de réglage fin du modèle.
# Nom du modèle Model_Name = "Eleutherai / Pythia-70m" # Configuration de formation Training_config = { "modèle": { "Pretrained_name": Model_name, "max_length": 2048 }, "ensembles de données": { "use_hf": use_hf, "Path": DataSet_Path }, "Verbose": vrai } # Configuration du tokenizer automatique tokenizer = autotokenizer.from_pretrain (Model_name) tokenizer.pad_token = tokenizer.eos_token Train_dataset, test_dataset = tokenize_and_split_data (Training_config, tokenizer) # Configurez un modèle de base de Lamini base_model = lamini (Model_name) # Parallisation GPU device_count = torch.cuda.device_count () si device_count> 0: Logger.debug ("Sélectionner le périphérique GPU") dispositif = torch.device ("cuda") autre: Logger.debug ("Sélectionner le périphérique CPU") dispositif = torch.device ("CPU")
Configuration de la formation pour affiner, le modèle
Enfin, nous avons mis en place des paramètres d'argument de formation avec des hyperparamètres. Il comprend le taux d'apprentissage, les époques, la taille du lot, le répertoire de sortie, les étapes d'évaluation, SAV, les étapes d'échauffement, la stratégie d'évaluation et de journalisation, etc., pour affiner l'ensemble de données de formation personnalisé.
max_steps = 3 # Nom du modèle formé TRADED_MODEL_NAME = F "LAMINI_DOCS_ {Max_Steps} _Steps" output_dir = TRADED_MODEL_NAME Training_args = TrainingArguments ( # Taux d'apprentissage apprentissage_rate = 1.0e-5, # Nombre d'époches de formation num_train_epochs = 1, # étapes maximales pour s'entra?ner (chaque étape est un lot de données) # Remplace num_train_epochs, sinon -1 max_steps = max_steps, # Taille du lot pour la formation per_device_train_batch_size = 1, # Répertoire pour enregistrer les points de contr?le du modèle output_dir = output_dir, # Autres arguments suwrite_output_dir = false, # écraser le contenu du répertoire de sortie disable_tqdm = false, # Désactiver les barres de progression EVAL_STEPS = 120, # Nombre d'étapes de mise à jour entre deux évaluations Save_steps = 120, # After # Steps Le modèle est enregistré WarmUp_steps = 1, # Nombre d'étapes d'échauffement pour le planificateur de taux d'apprentissage per_device_eval_batch_size = 1, # Taille du lot pour l'évaluation evaluation_strategy = "étapes", logging_strategy = "étapes", logging_steps = 1, optim = "adafactor", gradient_accumulation_steps = 4, gradient_checkpointing = false, # Paramètres pour l'arrêt anticipé load_best_model_at_end = true, Save_Total_limit = 1, metric_for_best_model = "EVAL_LOSS", Greater_is_better = false )
Après avoir réglé les arguments de formation, le système calcule les opérations à virgule flottante du modèle par seconde (flops) en fonction des étapes de taille d'entrée et d'accumulation de gradient. Donnant ainsi un aper?u de la charge de calcul. Il évalue également l'utilisation de la mémoire, en estimant l'empreinte du modèle dans les gigaoctets. Une fois ces calculs terminés, un entra?neur initialise le modèle de base, les flops, les étapes de formation totale et les ensembles de données préparés pour la formation et l'évaluation. Cette configuration optimise le processus de formation et permet la surveillance de l'utilisation des ressources, essentiellement pour gérer efficacement le réglage fin du modèle à grande échelle. à la fin de la formation, le modèle affiné est prêt pour le déploiement sur le cloud pour servir les utilisateurs en tant qu'API.
# Paramètres du modèle Model_flops = ( base_model.floating_point_ops ( { "input_ids": torch.zeros ( (1, formation_config ["modèle"] ["max_length"]) ) } ) * Training_args.gradient_accumulation_steps ) print (base_model) print ("Memory Footprint", base_model.get_memory_footprint () / 1e9, "gb") print ("flops", model_flops / 1e9, "gflops") # Configurer un entra?neur entra?neur = entra?neur ( modèle = base_model, Model_flops = Model_flops, total_steps = max_steps, args = Training_args, Train_dataset = Train_dataset, EVAL_DATASET = TEST_DATASET, )
Conclusion
En conclusion, cet article fournit un guide approfondi pour comprendre la nécessité de faire affiner les LLM à l'aide de la plate-forme lamini. Il donne un aper?u complet des raisons pour lesquelles nous devons affiner le modèle pour les ensembles de données personnalisés et les cas d'utilisation de l'entreprise et les avantages de l'utilisation d'outils lamini. Nous avons également vu un guide étape par étape pour affiner le modèle à l'aide d'un ensemble de données personnalisé et de LLM avec des outils de Lamini. Résumons les plats critiques du blog.
Principaux à retenir
- L'apprentissage est nécessaire pour les modèles de réglage fin contre l'ingénierie rapide et les méthodes de génération augmentée.
- Uutilisation de plates-formes comme Lamini pour des techniques de configuration et de déploiement de matériel facile à utiliser pour des modèles affinés pour répondre aux exigences de l'utilisateur
- Nous préparons des données pour la tache de réglage fin et créons un pipeline pour former un modèle de base en utilisant une large gamme d'hyperparamètres.
Explorez le code derrière cet article sur GitHub.
Les médias présentés dans cet article ne appartiennent pas à l'analytique vidhya et sont utilisés à la discrétion de l'auteur.
Questions fréquemment posées
Q1. Comment affiner mes modèles?A. Le processus de réglage fin commence par la compréhension des exigences spécifiques au contexte, la préparation des ensembles de données, la tokenisation et la mise en place de configurations de formation comme les exigences matérielles, les configurations de formation et les arguments de formation. Finalement, un travail de formation pour le développement de modèles est exécuté.
Q2. Que signifie le réglage fin des LLM?A. Fonctionner un LLM signifie former un modèle de base sur un ensemble de données personnalisé spécifique. Cela génère des sorties précises et pertinentes au contexte pour des requêtes spécifiques selon le cas d'utilisation.
Q3. Qu'est-ce que les lamini dans le réglage fin LLM?A. Lamini fournit une configuration de réglage fin, d'inférence et de GPU du modèle de langage intégré pour le développement transparent, efficace et rentable de LLMS.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

Outils d'IA chauds

Undress AI Tool
Images de déshabillage gratuites

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Clothoff.io
Dissolvant de vêtements AI

Video Face Swap
échangez les visages dans n'importe quelle vidéo sans effort grace à notre outil d'échange de visage AI entièrement gratuit?!

Article chaud

Outils chauds

Bloc-notes++7.3.1
éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Rappelez-vous le flot de modèles chinois open source qui a perturbé l'industrie du Genai plus t?t cette année? Alors que Deepseek a fait la majeure partie des titres, Kimi K1.5 était l'un des noms importants de la liste. Et le modèle était assez cool.

à la mi-2025, l'AI ?Arme Race? se réchauffe, et Xai et Anthropic ont tous deux publié leurs modèles phares, Grok 4 et Claude 4.

Mais nous n'aurons probablement pas à attendre même 10 ans pour en voir un. En fait, ce qui pourrait être considéré comme la première vague de machines vraiment utiles, de type humain, est déjà là. Les dernières années ont vu un certain nombre de prototypes et de modèles de production sortant de T

Jusqu'à l'année précédente, l'ingénierie rapide était considérée comme une compétence cruciale pour interagir avec les modèles de langage grand (LLM). Récemment, cependant, les LLM ont considérablement progressé dans leurs capacités de raisonnement et de compréhension. Naturellement, nos attentes

Construit sur le moteur de profondeur neuronale propriétaire de Leia, l'application traite des images fixes et ajoute de la profondeur naturelle avec un mouvement simulé - comme les casseroles, les zooms et les effets de parallaxe - pour créer de courts bobines vidéo qui donnent l'impression de pénétrer dans le SCE

Imaginez quelque chose de sophistiqué, comme un moteur d'IA prêt à donner des commentaires détaillés sur une nouvelle collection de vêtements de Milan, ou une analyse de marché automatique pour une entreprise opérant dans le monde entier, ou des systèmes intelligents gérant une grande flotte de véhicules.

Une nouvelle étude de chercheurs du King’s College de Londres et de l’Université d’Oxford partage les résultats de ce qui s'est passé lorsque Openai, Google et Anthropic ont été jetés ensemble dans un concours fardé basé sur le dilemme du prisonnier itéré. Ce n'était pas

Les scientifiques ont découvert une méthode intelligente mais alarmante pour contourner le système. Juillet 2025 a marqué la découverte d'une stratégie élaborée où les chercheurs ont inséré des instructions invisibles dans leurs soumissions académiques - ces directives secrètes étaient la queue
