LALAME FINAGE 3.2 Vision de l'extraction des calories à partir d'images

Ces dernières années, l'intégration de l'intelligence artificielle dans divers domaines a révolutionné la façon dont nous interagissons avec la technologie. L'une des progrès les plus prometteurs est le développement de modèles multimodaux capables de comprendre et de traiter les informations visuelles et textuelles. Parmi ceux-ci, le modèle de vision LLAMA 3.2 se distingue comme un outil puissant pour les applications qui nécessitent une analyse complexe des images. Cet article explore le processus de réglage fin du modèle de vision LLAMA 3.2 spécifiquement pour l'extraction d'informations de calories des images alimentaires, en utilisant une AI.

Objectifs d'apprentissage

Explorez l'architecture et les caractéristiques du modèle de vision LLAMA 3.2.
Soyez introduit avec un aslot Ai et ses caractéristiques clés.
Apprenez à affiner le modèle de vision LLAMA 3.2 11b, pour analyser efficacement les données liées aux aliments, en utilisant un ensemble de données d'image à l'aide d'une AI non.

Cet article a été publié dans le cadre du Data Science Blogathon.

Table des matières

LLAMA 3.2 Modèle de vision
• Applications de LLAMA 3.2 Modèle de vision
Qu'est-ce qui est un seul Ai?
• Claires caractéristiques de l'AsLoth Ai
Vision
Fine Tuning Llama 3.2 11b Modèle de vision Utilisation d'un AI non loth
• Étape 1. Installation des bibliothèques nécessaires
  Étape 2. Définition du modèle
  Étape 3. Chargement de l'ensemble de données
  Étape 4. Conservation de la convertissement vers une conversation
  étape 5. Avant le modèle de données pour une conversation
  • >
  étape 5. Modèle
  Étape 6. Démarrage du réglage fin
  Étape 7. Vérification des résultats du modèle post-affinage
  Tests sur les exemples de données
Conclusion
Freetly Posés Questions

LLAMA 3.2 Modèle de vision

Le modèle LLAMA 3.2 Vision Model

, développé par Meta, est un modèle de grande langue multimodal de pointe conçu pour une compréhension visuelle et un raisonnement avancées et des tâches de raisonnement avancées. Voici les détails clés du modèle:

• Architecture : LLAMA 3.2 Vision s'appuie sur le modèle de texte LLAMA 3.1, en utilisant une architecture de transformateur optimisée. Il intègre un adaptateur de vision composé de couches de transtention croisée qui intègrent des représentations d'encodeur d'image avec le modèle de langue.
• Tailles disponibles: Le modèle est disponible en deux tailles de paramètres:
  • 11B (11 milliards de paramètres) pour un déploiement efficace sur les GPU de qualité consommatrice.
  • 90b (90 milliards de paramètres) pour les applications à grande échelle.
• Entrée multimodale: LLAMA 3.2 La vision peut traiter à la fois du texte et des images, ce qui lui permet d'effectuer des tâches telles que la reconnaissance visuelle, le raisonnement d'image, le sous-titrage et la réponse aux questions liées aux images.
• Données de formation: Le modèle a été formé sur environ 6 milliards de paires de texte d'image, améliorant sa capacité à comprendre et à générer du contenu en fonction des entrées visuelles.
• Longueur de contexte : Il prend en charge une longueur de contexte allant jusqu'à 128k jetons

LIRE AUSSI: LLAMA 3.2 90B VS GPT 4O: comparaison d'analyse d'image

Applications du LLAMA 3.2 Modèle de vision

LLAMA 3.2 La vision est conçue pour diverses applications, notamment:

• Réponse de question visuelle (VQA): Répondre aux questions basées sur le contenu des images.
• Cention d'image: Génération de légendes descriptives pour les images.
• RECOURATION DE TEXTE D'IMAGE: correspondant aux images avec leurs descriptions textuelles.
• terre visuelle: liant les références de langage à des parties spécifiques d'une image.

Qu'est-ce qui est insuffisant Ai?

Unsloth IA est une plate-forme innovante conçue pour améliorer le réglage fin des modèles de grande langue (LLMS) comme LLAMA-3, Mistral, PHI-3 et Gemma. Il vise à rationaliser le processus complexe d'adaptation des modèles pré-formés pour des tâches spécifiques, ce qui le rend plus rapide et plus efficace.

Caractéristiques clés de l'asloth Ai

• Formation accélérée: Unslots possède la possibilité de ramener les modèles jusqu'à 30 fois plus rapidement tout en réduisant l'utilisation de la mémoire de 60%. Cette amélioration significative est réalisée grâce à des techniques avancées telles que la multiplication manuelle Autograd, la multiplication matricielle enchaînée et les grains de GPU optimisés.
• convivial: La plate-forme est ouverte et facile à installer, permettant aux utilisateurs de le configurer localement ou d'utiliser des ressources cloud comme Google Colab. La documentation complète aide les utilisateurs à naviguer dans le processus de réglage fin.
• Évolutivité: Unsloth prend en charge une gamme de configurations matérielles, des GPU uniques aux configurations multi-nœuds, ce qui le rend adapté aux petites équipes et aux applications au niveau de l'entreprise.
• Polvylity: La plate-forme est compatible avec diverses LLM populaires et peut être appliquée à diverses tâches telles que la génération de la langue, le résumé et l'IA conversationnelle

UNSLOCK IA représente une progression importante dans la formation des modèles d'IA, ce qui le rend accessible aux développeurs et aux chercheurs qui cherchent à créer efficacement des modèles personnalisés de haute performance.

Performance Benchmarks of Llama 3.2 Vision

Les modèles de vision LLAMA 3.2 excellent dans l'interprétation des graphiques et des diagrammes.

Le modèle de 11 milliards dépasse Claude 3 haïku dans des repères visuels tels que MMMU-PRO, Vision (23.7), ChartQA (83,4), diagramme AI2 (91.1) tandis que le modèle de 90 milliards dépasse Claude 3 Haikuin tous les tass d'interprétation visuels.

En conséquence, LLAMA 3.2 est une option idéale pour les tâches qui nécessitent une compréhension des documents, une réponse visuelle et une extraction de données des graphiques.

Fine Tuning Llama 3.2 11b Modèle de vision en utilisant un non-aide Ai

Dans ce tutoriel, nous parcourons le processus de réglage fin du modèle de vision LLAMA 3.2 11b. En tirant parti de ses capacités avancées, nous visons à améliorer la précision du modèle dans la reconnaissance des aliments et l'estimation de leur contenu calorique en fonction de l'entrée visuelle.

Fonctionnement de ce modèle implique de la personnaliser pour mieux comprendre les nuances de l'imagerie alimentaire et des données nutritionnelles, améliorant ainsi ses performances dans les applications du monde réel. Nous nous plongerons dans les étapes clés impliquées dans ce processus de réglage fin, y compris la préparation des ensembles de données et la configuration de l'environnement de formation. Nous utiliserons également des techniques telles que LORA (adaptation de faible rang) pour optimiser les performances du modèle tout en minimisant l'utilisation des ressources.

Nous tirons parti de l'IA insuffisante pour personnaliser les capacités du modèle. L'ensemble de données que nous utiliserons consiste en images alimentaires, chacune accompagnée d'informations sur le contenu calorique des différents aliments. Cela nous permettra d'améliorer la capacité du modèle à analyser efficacement les données liées aux aliments.

Alors, commençons!

Étape 1. Installation des bibliothèques nécessaires

!pip install unsloth

Étape 2. Définition du modèle

from unsloth import FastVisionModel
import torch

model, tokenizer = FastVisionModel.from_pretrained(
    "unsloth/Llama-3.2-11B-Vision-Instruct",
    load_in_4bit = True,
    use_gradient_checkpointing = "unsloth",
)

model = FastVisionModel.get_peft_model(
    model,
    finetune_vision_layers     = True,
    finetune_language_layers   = True,
    finetune_attention_modules = True,
    finetune_mlp_modules       = True,
    r = 16,
    lora_alpha = 16,
    lora_dropout = 0,
    bias = "none",
    random_state = 3443,
    use_rslora = False,
    loftq_config = None,
)

• de_prétraind: Cette méthode charge un modèle pré-formé et son tokenizer. Le modèle spécifié est «Unstruck / Llama-3.2-11b-vision-Instruct».
• load_in_4bit = true : Cet argument indique que le modèle doit être chargé de quantification 4 bits, ce qui réduit considérablement l'utilisation de la mémoire tout en maintenant les performances.
• use_gradient_checkpointing = ”Unsloth”: Cela permet de contrôler le gradient, ce qui aide à gérer la mémoire pendant la formation en enregistrant des activations intermédiaires.

get_peft_model: Cette méthode configure le modèle pour un réglage fin en utilisant des techniques de réglage fin (PEFT) économes par les paramètres.

Options de réglage fin:

• finetune_vision_layers = true: Active le réglage fin des couches de vision.
• finetune_language_layers = true: permet un réglage fin des couches de langue (les couches de transformateur probables responsables de la compréhension du texte)
• finetune_attention_modules = true: Active le réglage fin des modules d'attention.
• finetune_mlp_modules = true: Active le réglage fin des modules Perceptron (MLP) multicouches.

Paramètres LORA:

• r = 16, lora_alpha = 16, lora_dropout = 0: Ces paramètres configurent une adaptation de faible rang (LORA), qui est une technique pour réduire le nombre de paramètres formables tout en maintenant les performances.
• biais = ”Aucun": Cela spécifie qu'aucun biais ne sera inclus dans le processus de réglage fin pour les couches.
• random_state = 3443: Cela définit la graine aléatoire pour la reproductibilité. En utilisant cette graine, le processus de réglage fin du modèle sera déterministe et donnera les mêmes résultats si vous exécutez à nouveau avec la même configuration.
• use_rslora = false: Cela indique que la variante de Lora appelée rslora n'est pas utilisée. RSLORA est une approche différente pour le réglage fin et efficace par les paramètres.
• LOFTQ_CONFIG = Aucun: Cela ferait référence à toute configuration liée à la quantification à faible précision. Puisqu'il est défini sur aucun, aucune configuration spécifique pour la quantification n'est appliquée.

Étape 3. Chargement de l'ensemble de données

from datasets import load_dataset
dataset = load_dataset("aryachakraborty/Food_Calorie_Dataset",
                       split = "train[0:100]")

Nous chargeons un ensemble de données sur les images alimentaires avec leur description calorique dans le texte.

L'ensemble de données a 3 colonnes - «image», «requête», «réponse»

Étape 4. Conversion de l'ensemble de données en conversation

def convert_to_conversation(sample):
    conversation = [
        {
            "role": "user",
            "content": [
                {"type": "text", "text": sample["Query"]},
                {"type": "image", "image": sample["image"]},
            ],
        },
        {
            "role": "assistant",
            "content": [{"type": "text", "text": sample["Response"]}],
        },
    ]
    return {"messages": conversation}


pass


converted_dataset = [convert_to_conversation(sample) for sample in dataset]

Nous convertissons l'ensemble de données en une conversation avec deux rôles impliqués - utilisateur et assistant.

L'assistant répond à la requête utilisateur sur les images fournies par l'utilisateur.

Étape 5. Inférence du modèle avant le modèle de réglage fin

FastVisionModel.for_inference(model)  # Enable for inference!

image = dataset[0]["image"]

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "text", "text": "You are an expert nutritionist analyzing the image to identify food items and estimate their calorie content and calculate the total calories. Please provide a detailed report in the format: 1. Item 1 - estimated calories 2. Item 2 - estimated calories ..."},
        ],
    }
]
input_text = tokenizer.apply_chat_template(
    messages, add_generation_prompt=True)

inputs = tokenizer(image,input_text, add_special_tokens=False,return_tensors="pt",).to("cuda")

from transformers import TextStreamer

text_streamer = TextStreamer(tokenizer, skip_prompt=True)
_ = model.generate(
    **inputs,
    streamer=text_streamer,
    max_new_tokens=500,
    use_cache=True,
    temperature=1.5,
    min_p=0.1
)

Sortie:

Article 1: Dumplings frits - 400-600 calories
Article 2: Sauce rouge - 200-300 calories
Calories totales - 600-900 calories

Sur la base des tailles de service et des ingrédients, le nombre de calories estimé pour les deux articles est respectivement de 400-600 et 200-300 pour les boulettes frites et la sauce rouge. Lorsqu'il est consommé ensemble, le nombre combiné de calories estimées pour l'ensemble du plat est de 600 à 900 calories.

Informations nutritionnelles totales:

• Calories: 600-900 Calories
• Service Taille: 1 Plaque de momos à la vapeur

Conclusion: En fonction des ingrédients utilisés pour préparer le repas, les informations nutritionnelles peuvent être estimées.

La sortie est générée pour l'image d'entrée ci-dessous:

Comme le montre la sortie du modèle d'origine, les éléments mentionnés dans le texte se réfèrent aux «boulettes frites» même si l'image d'entrée d'origine contient des «momos cuites à la vapeur». De plus, les calories de la laitue présents dans l'image d'entrée ne sont pas mentionnées dans la sortie du modèle d'origine.

Sortie du modèle d'origine:

• Article 1: Dumplings frits - 400-600 calories
• Article 2: Sauce rouge - 200-300 calories
• Calories totales - 600-900 calories

Sur la base des tailles de service et des ingrédients, le nombre de calories estimé pour les deux articles est respectivement de 400-600 et 200-300 pour les boulettes frites et la sauce rouge. Lorsqu'il est consommé ensemble, le nombre combiné de calories estimées pour l'ensemble du plat est de 600 à 900 calories.

Informations nutritionnelles totales:

• Calories: 600-900 calories
• Service Taille: 1 plaque de momos cuit à la vapeur

Conclusion: Sur la base des ingrédients utilisés pour préparer le repas, les informations nutritionnelles peuvent être estimées.

Étape 6. Démarrage du réglage fin

!pip install unsloth

Paramètres Sfttrainer

• sfttrainer (…): Cela initialise le formateur qui sera utilisé pour affiner le modèle. Le sfttrainer est spécialement conçu pour le réglage fin supervisé des modèles.
• modèle = modèle: le modèle pré-chargé ou initialisé qui sera affiné.
• tokenizer = tokenizer: Le tokenzer utilisé pour convertir les entrées de texte en ID de jetons. Cela garantit que les données de texte et d'image sont correctement traitées pour le modèle.
• data_collator = unsthVisionDatacollat ​​(modèle, tokenizer): Le collator de données est responsable de la préparation des lots de données (en particulier des données de vision en langue). Ce collator gère comment les paires de texte d'image sont losées ensemble, garantissant qu'elles sont correctement alignées et formatées pour le modèle.
• Train_dataset = convertid_dataset: Il s'agit de l'ensemble de données qui sera utilisé pour la formation. On suppose que converti_dataset est un ensemble de données prétraité qui comprend des paires de texte d'image ou des données structurées similaires.

Paramètres de classe SftConfig

• per_device_train_batch_size = 2: Cela définit la taille du lot sur 2 pour chaque appareil (par exemple, GPU) pendant la formation.
• gradient_accumulation_steps = 4: Ce paramètre détermine le nombre de passes avant (ou étapes) qui sont effectuées avant de mettre à jour les poids du modèle. Essentiellement, il permet de simuler une taille de lot plus grande en accumulant des gradients sur plusieurs lots plus petits.
• warmup_steps = 5: Son paramètre spécifie le nombre d'étapes de formation initiales pendant lesquelles le taux d'apprentissage est progressivement augmenté d'une petite valeur au taux d'apprentissage initial. Le nombre d'étapes pour l'échauffement du taux d'apprentissage, où le taux d'apprentissage augmente progressivement à la valeur cible.
• max_steps = 30: Le nombre maximum d'étapes de formation (itérations) à effectuer pendant le réglage fin.
• Learning_rate = 2e-4: Le taux d'apprentissage pour l'optimiseur, réglé sur 0,0002.

Paramètres de précision

• fp16 = pas is_bf16_supported (): si la précision bfloat16 (bf16) n'est pas prise en charge (vérifiée par IS_BF16_Supported ()), alors la précision du point de flux de flux 16 bits (FP16) sera utilisée. Si BF16 est pris en charge, le code utilisera automatiquement BF16 à la place.
• BF16 = IS_BF16_SUPPORTED (): Ceci vérifie si le matériel prend en charge la précision BFLOAT16 et le permet si cela est pris en charge.

journalisation et optimisation

• logging_steps = 5 : Le nombre d'étapes après lesquels les progrès de l'entraînement seront enregistrés.
• optim = ”adamw_8bit”: Cela définit l'optimiseur sur ADAMW avec une précision 8 bits (probablement pour un calcul plus efficace et une utilisation réduite de la mémoire).
• weight_decay = 0,01: La désintégration du poids (régularisation L2) pour empêcher le sur-ajustement en pénalisant de gros poids.
• LR_SCHEDULER_TYPE = ”Linear”: Cela définit le planificateur de taux d'apprentissage à une désintégration linéaire, où le taux d'apprentissage diminue linéairement de la valeur initiale à zéro.
• seed = 3407: Cela définit la graine aléatoire pour la reproductibilité dans l'entraînement.
• output_dir = ”sorties”: Cela spécifie le répertoire où le modèle formé et d'autres sorties (par exemple, les journaux) seront enregistrés.
• report_to = ”Aucun": Cela désactive les rapports à des systèmes externes comme les poids et les biais, de sorte que les journaux de formation ne seront envoyés à aucun service de suivi à distance.

Paramètres spécifiques à la vision

• retire_unused_columns = false: conserve toutes les colonnes de l'ensemble de données, ce qui peut être nécessaire pour les tâches de vision.
• Dataset_text_field = ””: Indique quel champ dans l'ensemble de données contient des données de texte; Ici, il est laissé vide, indiquant peut-être qu'il pourrait ne pas y avoir de champ de texte spécifique nécessaire.
• dataset_kwargs = {"skip_prepare_dataset": true} : ignore toutes les étapes de préparation supplémentaires pour l'ensemble de données, en supposant qu'elle est déjà préparée.
• DataSet_num_proc = 4 : nombre de processus à utiliser lors du chargement ou du traitement de l'ensemble de données, ce qui peut accélérer le chargement des données. En définissant TheDataSet_NUM_PROCPARAMETER, vous pouvez activer le traitement parallèle de l'ensemble de données.
• max_seq_length = 2048: Longueur de séquence maximale pour les données d'entrée, permettant de traiter des séquences plus longues. Le paramètre MAX_SEQ_LENGTH Spécifie La limite supérieure du nombre de jetons (ou ID d'entrée) qui peuvent être introduites dans le modèle à la fois. Le réglage de ce paramètre trop faible peut entraîner une troncature des entrées plus longues, ce qui peut entraîner une perte d'informations importantes.

LIRE AUSSI: LALAME DE TUNING FINANT 3.2 3B pour Rag

Étape 7. Vérification des résultats du modèle post-affinage

!pip install unsloth

Sortie du modèle affiné:

Comme le montre la sortie du modèle Finetuned, les trois éléments sont correctement mentionnés dans le texte avec leurs calories au format nécessaire.

Tests sur les exemples de données

Nous testons également à quel point le modèle affiné est bon sur des données invisibles. Ainsi, nous sélectionnons les lignes des données non vues par le modèle auparavant.

from unsloth import FastVisionModel
import torch

model, tokenizer = FastVisionModel.from_pretrained(
    "unsloth/Llama-3.2-11B-Vision-Instruct",
    load_in_4bit = True,
    use_gradient_checkpointing = "unsloth",
)

model = FastVisionModel.get_peft_model(
    model,
    finetune_vision_layers     = True,
    finetune_language_layers   = True,
    finetune_attention_modules = True,
    finetune_mlp_modules       = True,
    r = 16,
    lora_alpha = 16,
    lora_dropout = 0,
    bias = "none",
    random_state = 3443,
    use_rslora = False,
    loftq_config = None,
)

Nous sélectionnons cela comme image d'entrée.

from datasets import load_dataset
dataset = load_dataset("aryachakraborty/Food_Calorie_Dataset",
                       split = "train[0:100]")

Sortie du modèle à réglage fin :

Comme nous pouvons le voir à partir de la sortie du modèle affiné, tous les composants de la pizza ont été identifiés avec précision et leurs calories ont également été mentionnées.

Conclusion

L'intégration de modèles d'IA comme la vision LLAMA 3.2 transforme la façon dont nous analysons et interagissons avec les données visuelles, en particulier dans des domaines tels que la reconnaissance alimentaire et l'analyse nutritionnelle. En affinant ce modèle puissant avec une IA non avec un peu de l'IA, nous pouvons améliorer considérablement sa capacité à comprendre les images alimentaires et à estimer avec précision le contenu des calories.

Le processus de réglage fin, en tirant parti des techniques avancées telles que LORA et les capacités efficaces de l'IA insuffisante, assure des performances optimales tout en minimisant l'utilisation des ressources. Cette approche améliore non seulement la précision du modèle, mais ouvre également la porte pour les applications du monde réel en analyse alimentaire, surveillance de la santé et au-delà. Grâce à ce tutoriel, nous avons démontré comment adapter des modèles d'IA de pointe pour des tâches spécialisées, entraînant l'innovation dans la technologie et la nutrition.

Les plats clés

• Le développement de modèles multimodaux, comme Llama 3.2 Vision, permet à l'IA de traiter et de comprendre les données visuelles et textuelles, ouvrant de nouvelles possibilités pour des applications telles que l'analyse d'image alimentaire.
• LLAMA 3.2 La vision est un outil puissant pour les tâches impliquant la reconnaissance d'images, le raisonnement et la mise à la terre visuelle, en mettant l'accent sur l'extraction d'informations détaillées d'images, telles que le contenu calorique dans les images alimentaires.
• Fonctionnement du modèle de vision LLAMA 3.2 permet de personnaliser pour des tâches spécifiques, telles que l'extraction des calories alimentaires, améliorant sa capacité à reconnaître les aliments et à estimer avec précision les données nutritionnelles.
• Usloth IA accélère considérablement le processus de réglage fin, ce qui représente jusqu'à 30 fois plus rapidement tout en réduisant l'utilisation de la mémoire de 60%, permettant la création de modèles personnalisés plus efficacement.

Le média présenté dans cet article ne appartient pas à l'analyse vidhya et est utilisé à la discrétion de l'auteur.

Les questions fréquemment posées

Q1. Quel est le modèle de vision LLAMA 3.2, et comment fonctionne-t-il?

a. Le modèle de vision LLAMA 3.2 est un modèle d'IA multimodal développé par Meta, capable de traiter à la fois du texte et des images. Il utilise une architecture de transformateur et des couches transversales pour intégrer les données d'image avec les modèles de langage, en lui permettant d'effectuer des tâches telles que la reconnaissance visuelle, le sous-titrage et la récupération de texte d'image.

Q2. Comment le réglage fin du modèle de vision LLAMA 3.2 améliore-t-il ses performances?

a. Le réglage fin personnalise le modèle à des tâches spécifiques, telles que l'extraction d'informations caloriques des images alimentaires. En formant le modèle sur un ensemble de données spécialisé, il devient plus précis pour reconnaître les aliments et estimer leur contenu nutritionnel, ce qui le rend plus efficace dans les applications du monde réel.

Q3. Quel rôle joue un insuffisance IA dans le processus de réglage fin?

a. L'INA-Ai améliore le processus de réglage fin en le rendant plus rapide et plus efficace. Il permet aux modèles d'être affinés jusqu'à 30 fois plus rapides tout en réduisant l'utilisation de la mémoire de 60%. La plate-forme fournit également des outils pour une configuration et une évolutivité faciles, prenant en charge les petites équipes et les applications au niveau de l'entreprise.

Q4. Qu'est-ce que LORA (adaptation de faible rang), et pourquoi est-il utilisé dans le processus de réglage fin?

a. LORA est une technique utilisée pour optimiser les performances du modèle tout en réduisant l'utilisation des ressources. Il aide à affiner les grands modèles de langue plus efficacement, ce qui rend le processus de formation plus rapide et moins intensif en calcul sans compromettre la précision. LORA modifie qu'un petit sous-ensemble de paramètres en introduisant des matrices de bas rang dans l'architecture du modèle.

Q5. À quelles applications pratiques le modèle de vision LLAMA 3.2 affiné peut-il être utilisé?

a. Le modèle affiné peut être utilisé dans diverses applications, notamment l'extraction des calories à partir d'images alimentaires, la réponse aux questions visuelles, la compréhension des documents et le sous-titrage de l'image. Il peut améliorer considérablement les tâches qui nécessitent une analyse visuelle et textuelle, en particulier dans des domaines comme la santé et la nutrition.

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!