TinyLlama 1.1B – La taille n’a pas d’importance

Introduction

Dans le paysage en croissance rapide de l’intelligence artificielle et de l’apprentissage automatique, TinyLlama 1.1B apparaît comme un développement remarquable. À une époque où les contraintes informatiques posent des défis pour l'exécution de modèles plus complexes, TinyLlama se démarque en défiant les attentes. Il met en valeur les performances remarquables des modèles compacts.

Cet article vise à fournir une analyse de TinyLlama 1.1B, un grand modèle de langage compact. Nous approfondirons ses aspects fondamentaux, comme la manière dont il a été formé aux tests de performance et à la mise en œuvre pratique à l'aide de la plateforme Hugging Face. Nous exécuterons même ce modèle sur le Google Colab gratuit et testerons ses capacités mathématiques et de raisonnement.

Objectifs d'apprentissage

• Acquérir une compréhension complète de TinyLlama 1.1B
• Explorez le processus de formation complexe suivi par le modèle
• Analyser la performance et comparer les résultats pour évaluer son efficacité
• Découvrez les étapes pratiques pour implémenter TinyLlama 1.1B à l'aide d'exemples de codage

Cet article a été publié dans le cadre du Blogathon sur la science des données.

Qu'est-ce que TinyLlama 1.1B ?

TinyLlama 1.1B, qui fait partie du projet plus large Llama, témoigne des progrès de la modélisation du langage. Il s'agit d'un modèle avec 1.1 milliard de paramètres, entraîné sur un nombre impressionnant de 3 1.1 milliards de jetons, ce qui le place dans une position unique dans le paysage de l'IA. Contrairement à ses homologues plus grands, TinyLlama XNUMXB est conçu pour être plus efficace et plus facile à gérer, ce qui en fait un bon choix pour les applications disposant de ressources informatiques limitées.

Ce modèle open source démocratise l’accès à la technologie d’IA de pointe, permettant à de nombreux développeurs et chercheurs d’explorer et d’innover dans le domaine du traitement du langage naturel. Il s'agit d'un modèle connu pour sa capacité à équilibrer les performances avec la consommation de ressources, une considération essentielle dans les divers environnements informatiques d'aujourd'hui.

Processus de formation de TinyLlama 1.1B

Le processus de formation de TinyLlama 1.1B est fascinant, tout comme le modèle lui-même. La formation de TinyLlama n'a duré que 90 jours, sur les 16 GPU A100-40G. La pré-formation a été effectuée sur 3 billions de jetons, et l'équipe TinyLlama a publié le modèle intermédiaire entre chaque demi-billion. 

En ce qui concerne les données, Slimpajama et Starcoderdata ont été prises avec un ensemble de données combiné de 950 milliards de jetons. Le rapport langage naturel/code a été maintenu à 7:3, c'est-à-dire que 70 % des données étaient en langage naturel et 30 % en code. Ainsi, pour atteindre la barre des 3 3 milliards de jetons pour le réglage fin, le TinyLlama a subi XNUMX époques de formation pour cet ensemble de données. 

Il existe même une version de chat de TinyLlama appelée TinyLlama-Chat. Initialement, ce modèle a été affiné sur l'ensemble de données UltraChat, qui contient diverses conversations synthétiques générées par ChatGPT. Cette étape était cruciale pour créer un modèle capable de gérer différents contextes et styles de conversation.

Un affinement supplémentaire a été obtenu à l'aide du DPOTrainer sur l'ensemble de données UltraFeedback. Cette phase de formation s'est concentrée sur l'alignement des réponses du modèle pour les aligner sur des modèles de conversation de type humain. Le résultat est un modèle qui non seulement saisit des informations sur différents sujets, mais qui interagit même de manière naturelle et engageante.

Vous pouvez également lire: Premiers pas avec LlaMA 2 : un guide du débutant

Performances et résultats de référence

L'évaluation des performances de TinyLlama 1.1B révèle sa capacité à fournir rapidement des réponses de haute qualité. Sa formation lui a permis de répondre à des applications multilingues, une caractéristique importante dans notre monde globalisé. Malgré sa taille plus petite, TinyLlama 1.1B rattrape toujours ses homologues plus grands en termes de qualité et de vitesse de réponse, ce qui en fait un outil puissant dans différentes applications d'IA.

Les benchmarks de TinyLlama 1.1B, bien que moins étendus que ceux des modèles plus grands, démontrent néanmoins sa capacité à gérer des tâches linguistiques complexes. Sa capacité à générer des réponses cohérentes et contextuellement pertinentes dans plusieurs langues est particulièrement impressionnante. Le modèle a été testé sur différents benchmarks comme HellaSwag, WinoGrande, ARC, MMLU et autres. La note moyenne combinée s'est élevée à 52.99. C'est bien mieux que l'autre modèle à 1 milliard de paramètres, à savoir le Pythia 1B, qui a obtenu un score moyen de 48.3. Le tableau présente les scores individuels de chaque référence

TinyLlama – Pour commencer

Ici, dans cette section, nous allons télécharger la version quantifiée de TinyLlama Chat et l'exécuter dans Google Colab. Avant de télécharger le modèle, nous devons télécharger et installer les packages Python suivants

!CMAKE_ARGS="-DLLAMA_CUBLAS=on" FORCE_CMAKE=1 pip3 install llama-cpp-python 
!pip3 install huggingface-hub 

• La CMAKE_ARGS=”-DLLAMA_CUBLAS=on” ainsi que FORCE_CMAKE=1, permettra au llama_cpp_python d'utiliser le GPU Nvidia disponible dans la version gratuite de Colab.
• Ensuite, nous installons le lama_cpp_python paquet via pip3
• Nous téléchargeons même le câlins-hub, avec lequel nous téléchargerons le chat quantifié TinyLlama 1.1B

Pour tester le modèle TinyLlama 1.1B Chat, nous devons d'abord en télécharger la version quantifiée. Pour le télécharger, nous exécuterons le code suivant

from huggingface_hub import hf_hub_download

# specifying the model name
model_name = "TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF"
# specifying the type of quantization of the model
model_file = "tinyllama-1.1b-chat-v1.0.Q8_0.gguf"

# download the model by specifying the model name and quantized model name
model_path = hf_hub_download(model_name, filename=model_file)

Ici le câlin_face_hub La bibliothèque se chargera du processus de téléchargement du modèle quantifié. Pour cela, nous importons le hf_hub_download qui prend en compte les paramètres suivants :

• nom du modèle: A cette variable, on passe le modèle que l'on souhaite télécharger. Ici, nous souhaitons télécharger le modèle TinyLlama 1.1B Chat GGUF.
• fichier_modèle : Nous spécifions ici le type de modèle quantifié que nous souhaitons télécharger. Ici, nous allons télécharger la version quantifiée 8 bits du TinyLlama 1.1B Chat.
• Enfin, nous transmettons ces paramètres au hf_hub_download, qui prend en compte ces paramètres et télécharge le modèle spécifié. Après le téléchargement, il renvoie le chemin où le modèle est téléchargé.
• Ce chemin renvoyé est enregistré dans le chemin_modèle variable.

Maintenant, nous pouvons charger ce modèle via le lama_cpp_python bibliothèque. Le code de chargement du modèle sera comme celui ci-dessous.

from llama_cpp import Llama
llm = Llama(
    model_path=model_path,
    n_ctx=512,  # the number of i/p tokens the model can take
    n_threads=8, # the number of threads to use
    n_gpu_layers=40# how many layers of the model to offload to the GPU
)

Nous importons le Flamme classe de la lama_cpp, qui prend les paramètres suivants

• chemin_modèle : Cette variable prend le chemin où notre modèle est stocké. Nous avons obtenu le chemin de l'étape précédente, que nous fournirons ici
• n_ctx : Ici, nous donnons la longueur du contexte du modèle. Pour l'instant, nous fournissons 512 jetons comme longueur de contexte
• n_threads : Nous mentionnons ici le nombre de threads à utiliser par le Flamme classe
• n_gpu_layers : Nous le précisons si nous avons un GPU en marche, ce que nous faisons dans le cas de la collaboration gratuite. À cela, nous passons 40, ce qui implique que nous voulons décharger l'intégralité du modèle dans le GPU et que nous ne voulons pas qu'une partie de celui-ci s'exécute dans la RAM du système.
• Enfin, nous créons un objet à partir de ceci Flamme classe et donnez-le à la variable llm

L'exécution de ce code chargera le modèle quantifié TinyLlama 1.1B Chat sur le GPU et définira la longueur de contexte appropriée. Il est maintenant temps d'effectuer quelques inférences sur ce modèle. Pour cela, nous travaillons avec le code ci-dessous

output = llm(
  "<|im_start|>usernWho are you?<|im_end|>n<|im_start|>assistantn", # User Prompt
  max_tokens=512,  # Number of output tokens generated
  stop=["</s>"],   # Token which tells the LLM to stop
)
print(output['choices'][0]['text']) # Model generated text

Pour déduire le modèle, nous transmettons les paramètres suivants au LLM :

• modèle d'invite/de discussion : Il s'agit du modèle d'invite nécessaire pour discuter avec le modèle. Le modèle mentionné ci-dessus(c'est à dire , ) est celui qui fonctionne pour le modèle TinyLlama 1.1B Chat. Dans le modèle, la phrase après l'utilisateur est l'invite utilisateur et la génération sera générée après l'assistant.
• max_tokens : À cette variable, nous transmettons une valeur qui définit le nombre maximum de jetons qu'un grand modèle linguistique peut générer lorsqu'une invite est donnée. Pour l'instant, nous le limitons à 512 tokens.
• arrêter A cette variable, nous passons le jeton d'arrêt. Le jeton d'arrêt indique au Large Language Model d'arrêter de générer d'autres jetons. Pour TinyLlama 1.1B Chat, le jeton d'arrêt est

Le texte généré est stocké dans la variable de sortie lorsque nous exécutons ceci. Le résultat est généré dans un format similaire à l'appel API OpenAI. Par conséquent, nous pouvons accéder à la génération via l'instruction print donnée, de la même manière que nous accédons à la génération à partir des réponses OpenAI. La sortie générée peut être vue ci-dessous

Pour un modèle de cette taille, la réponse générée est excellente. C'est inattendu pour un modèle de cette taille ; la grammaire et le ton semblent parfaitement corrects et il n'y a aucun signe de répétition de phrases. Essayons de tester les capacités de raisonnement du modèle

output = llm(
  "<|im_start|>usernIf all students who study hard get good grades, 
  and John got good grades, can we conclude that John studied hard?
  <|im_end|>n<|im_start|>assistantn",
  max_tokens=512,
  stop=["</s>"],
)


print(output['choices'][0]['text'])

output = llm(
  "<|im_start|>usernHow fast can a snake fly?n<|im_end|>n<|im_start|>assistantn",
  max_tokens=512,
  stop=["</s>"],
)


print(output['choices'][0]['text'])

Jusqu'ici, tout va bien. D'après les exemples que nous avons vus, le modèle génère de bonnes réponses. Mais cela n’est peut-être pas vrai dans tous les cas car nous ne le testons que sur un nombre limité de questions. Testons même le modèle sur ses capacités de raisonnement mathématique

output = llm(
  "<|im_start|>usernJohn is twice as old as Sarah, and Sarah is three years 
  older than Mary. If Mary is 10 years old, how old is John?n<|im_end|>n<|im_start|>assistantn",
  max_tokens=512,
  stop=["</s>"],
)


print(output['choices'][0]['text'])

output = llm(
  "<|im_start|>usernWhat is the missing number in this pattern: 
  1, 4, 9, 16, __, 36?n<|im_end|>n<|im_start|>assistantn",
  max_tokens=512,
  stop=["</s>"],
)


print(output['choices'][0]['text'])

D’après les exemples que nous avons vus, il est clair que TinyLlamaChat répond extrêmement mal aux questions simples d’aptitude en mathématiques. Ceci est attendu car le modèle n'a été pré-entraîné sur aucun ensemble de données mathématiques. La qualité de la génération peut être améliorée en l'affinant sur l'ensemble de données mathématiques

En ce qui concerne le réglage fin, TinyLlama est un choix incontournable pour ceux qui sont limités par un matériel limité et souhaitent affiner de grands modèles de langage sur leur ensemble de données spécifique.

Cas d'utilisation et applications potentiels

Compte tenu de la taille compacte de Petit Lama, qui compte 1.1 milliard de paramètres, ses applications sont principalement adaptées aux environnements dans lesquels des modèles plus grands pourraient ne pas être aussi réalisables en raison de limitations matérielles ou d'une plus grande efficacité. Voici quelques cas d’utilisation spécifiques en tenant compte de sa taille :

Applications mobiles: La taille plus petite de TinyLlama en fait un bon choix pour l'intégration dans des applications mobiles où un traitement sur l'appareil est nécessaire. Cela inclut des applications de traduction linguistique, des fonctionnalités d’assistant personnel et des chatbots qui peuvent fonctionner efficacement sur les smartphones.

Systèmes embarqués dans les appareils IoT : Dans le domaine de l'Internet des objets (IoT), les ressources informatiques sont souvent limitées ; TinyLlama peut être utilisé pour ajouter des capacités de traitement intelligent du langage à différents équipements tels que les assistants domestiques intelligents, les technologies portables et d'autres équipements connectés de ce type.

Informatique de périphérie : Pour les applications qui bénéficient d'un traitement des données plus proche de la source plutôt que dans un environnement cloud centralisé, TinyLlama peut être utilisé efficacement. Cela inclut le traitement du langage en temps réel dans les systèmes automobiles, les équipements de fabrication et d’autres appareils de pointe.

Recherche sur les langues à faibles ressources : En raison de sa plus petite taille et de ses exigences de calcul réduites, TinyLlama peut être un outil précieux dans la recherche linguistique, en particulier pour les langues sous-financées où la formation de modèles à grande échelle n'est pas réalisable.

Outils pédagogiques : Dans les contextes éducatifs, en particulier ceux ayant un accès limité aux ressources informatiques haut de gamme, TinyLlama peut être utilisé pour développer des applications d'apprentissage des langues, des outils éducatifs interactifs et d'autres aides à l'apprentissage.

Génération de contenu pour les petites entreprises : Les petites entreprises disposant de ressources limitées peuvent utiliser TinyLlama pour générer du contenu, comme des descriptions de produits, des textes marketing et de la correspondance client, sans avoir besoin d'une puissance de calcul importante.

Prototypage et Expérimentation : Les développeurs et les chercheurs qui souhaitent expérimenter des modèles de langage mais qui n'ont pas accès à des ressources informatiques de grande puissance peuvent utiliser TinyLlama pour prototyper et développer de nouvelles applications NLP.

Analyse efficace des données : TinyLlama peut être utilisé pour l'analyse de texte et l'extraction de données dans des scénarios où un traitement rapide et efficace est nécessaire, comme l'analyse des commentaires des clients, des réponses à des enquêtes ou des interactions sur les réseaux sociaux.

Conclusion

TinyLlama 1.1B témoigne des progrès réalisés dans le domaine de l'IA et du traitement du langage naturel. Son développement et sa large disponibilité sont essentiels à la création de modèles de langage d'inférence plus efficaces, plus petits et plus rapides. En équilibrant une empreinte de paramètres plus petite et des performances robustes, TinyLlama 1.1B répond au besoin critique de modèles puissants et pratiques pour un large éventail d'applications. Sa capacité à comprendre et à générer du langage à la manière d'un humain tout en étant suffisamment léger pour différents environnements informatiques en fait un choix incontournable pour les personnes qui ont du mal à exécuter des modèles de langage étendus sur leurs machines. Le modèle peut être facilement ajusté sur un ensemble de données et peut être entraîné avec des ressources informatiques limitées. 

Les principaux points à retenir de cet article incluent

• Conçu pour être efficace, TinyLlama 1.1B est disponible pour un public plus large, y compris ceux disposant de ressources informatiques limitées, ce qui le rend adapté à plusieurs applications.
• Le modèle a subi un processus de formation approfondi, notamment une formation sur 3 90 milliards de jetons sur 16 jours à l'aide de 100 GPU A40-XNUMXG.
• Malgré sa taille réduite, TinyLlama 1.1B fournit des réponses de haute qualité et contextuellement pertinentes dans plusieurs langues, ce qui en fait un modèle à considérer.
• C'est un bon choix pour les applications mobiles, les équipements IoT, les outils pédagogiques et bien plus encore, sa taille compacte et son efficacité permettent de larges applications.
• Ses exigences informatiques moindres en font un outil précieux dans la recherche linguistique, en particulier pour les langues sous-financées.
• Le modèle est un bon choix pour ceux qui expérimentent des modèles de langage ou développent de nouvelles applications PNL, principalement dans des contextes où la puissance de calcul est limitée.

Foire aux Questions

Les médias présentés dans cet article n'appartiennent pas à Analytics Vidhya et sont utilisés à la discrétion de l'auteur.

Services Connexes

• Contenu propulsé par le référencement et distribution de relations publiques. Soyez amplifié aujourd'hui.
• PlatoData.Network Ai générative verticale. Autonomisez-vous. Accéder ici.
• PlatoAiStream. Intelligence Web3. Connaissance Amplifiée. Accéder ici.
• PlatonESG. Carbone, Technologie propre, Énergie, Environnement, Solaire, La gestion des déchets. Accéder ici.
• PlatoHealth. Veille biotechnologique et essais cliniques. Accéder ici.
• La source: https://www.analyticsvidhya.com/blog/2024/01/tinyllama-1-1b-size-doesnt-matter/