Comment effectuer des tâches de vision informatique avec Florence-2 - Analytics Vidhya

Introduction

L'introduction des transformateurs d'origine a ouvert la voie aux modèles de grande langue actuels. De même, après l'introduction du modèle de transformateur, le transformateur de vision (VIT) a été introduit. Comme les transformateurs qui excellent dans la compréhension du texte et la génération de texte étant donné une réponse, des modèles de transformateurs de vision ont été développés pour comprendre les images et fournir des informations compte tenu d'une image. Ceux-ci ont conduit aux modèles de langage de vision, qui excellent dans la compréhension des images. Microsoft a fait un pas en avant et a introduit un modèle capable d'effectuer de nombreuses tâches de vision uniquement avec un seul modèle. Dans ce guide, nous allons jeter un œil à ce modèle appelé Florence-2, publié par Microsoft, conçu pour résoudre de nombreuses tâches de vision différentes.

Objectifs d'apprentissage

• Soyez présenté à Florence-2, un modèle de langue de vision.
• Comprendre les données sur lesquelles Florence-2 est formée.
• Apprendre à connaître différents modèles dans la famille Florence-2.
• Apprenez à télécharger Florence-2.
• Écrivez du code pour effectuer différentes tâches de vision par ordinateur avec Florence-2.

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

Table des matières

• Qu'est-ce que Florence-2?
• Léspondre à l'image avec Florence-2
• Détection d'objets avec Florence-2
• Segmentation avec Florence-2
• Questions fréquemment posées

Qu'est-ce que Florence-2?

Florence-2 est un modèle de langage de vision (VLM) développé par l'équipe Microsoft. Florence-2 est disponible en deux tailles. L'un est une version de 0,23b et l'autre est une version de 0,77b. Ces faibles tailles permettent à tout le monde d'exécuter ces modèles sur le processeur lui-même. Florence-2 est créée en gardant à l'esprit qu'un modèle peut tout résoudre. Florence-2 est formée pour résoudre différentes tâches, notamment la détection d'objets, la segmentation des objets, le sous-titrage de l'image (même la génération de légendes détaillées), la segmentation des phrases, l'OCR (reconnaissance des caractères optiques) et une combinaison de ceux-ci également.

Le modèle de langue de vision de Florence-2 est formé sur l'ensemble de données FLD 5B. Ce FLD-5B est un ensemble de données créé par l'équipe Microsoft. Cet ensemble de données contient environ 5,4 milliards d'annotations de texte sur environ 126 millions d'images. Ceux-ci comprennent des annotations de région de texte de 1,3 milliard, 500 millions d'annotations textuelles et 3,6 milliards d'annotations de région de la phrase texte. Florence-2 accepte les instructions de texte et les entrées d'image, générant des résultats de texte pour des tâches telles que l'OCR, la détection d'objets ou le sous-titrage de l'image.

L'architecture contient un codeur visuel suivi d'un bloc de décodeur d'encodeur de transformateur et pour la perte, ils fonctionnent avec la fonction de perte standard, c'est-à-dire la perte d'entropie croisée. Le modèle Florence-2 effectue trois types de détection de région: représentations de boîtes pour la détection d'objets, les représentations quadruples pour la détection du texte OCR et les représentations du polygone pour les tâches de segmentation.

Léspondre à l'image avec Florence-2

Le sous-titrage de l'image est une tâche de langue de vision, où compte tenu d'une image, le modèle d'apprentissage en profondeur publiera une légende sur l'image. Cette légende peut être courte ou détaillée en fonction de la formation que le modèle a suivi. Les modèles qui effectuent ces tâches sont formés sur une énorme données de sous-titrage d'image, où elles apprennent à produire un texte, étant donné une image. Plus ils sont formés de données, plus ils deviennent bons pour décrire les images.

Téléchargement et installation

Nous allons commencer par télécharger et installer certaines bibliothèques dont nous avons besoin pour exécuter le modèle Florence Vision.

 ! pip install -q -u transformateurs accélérer flash_attn einops timm

• Transformers: La bibliothèque Transformers de HuggingFace fournit divers modèles d'apprentissage en profondeur pour différentes tâches que vous pouvez télécharger.
• Accélérer: la bibliothèque Accelerate de HuggingFace améliore le temps d'inférence du modèle lors du service de modèles via un GPU.
• Flash_attn: La bibliothèque d'attention Flash implémente un algorithme d'attention plus rapide que l'original, et il est utilisé dans le modèle Florence-2.
• Einops: les opérations d'Einstein simplifient la représentation des multiplications matricielles et sont implémentées dans le modèle Florence-2.

Télécharger le modèle Florence-2

Maintenant, nous devons télécharger le modèle Florence-2. Pour cela, nous travaillerons avec le code ci-dessous.

 De Transformers Import Autoprocesseur, AutomodelforCausallm

Model_id = 'Microsoft / Florence-2-Large-ft'
modèle = automodelforcusallm.from_pretrain (Model_id, trust_remote_code = true) .Eval (). Cuda ()
processeur = autoprocesseur.from_pretrain (Model_id, trust_remote_code = true, device_map = "CUDA")

• Nous commençons par importer l'automodelforcausallm et l'autoprocesseur.
• Ensuite, nous stockons le nom du modèle dans la variable Model_name. Ici, nous travaillerons avec le grand modèle à réglage fin Florence-2.
• Ensuite, nous créons une instance de AutomodelforCausAllm en appelant la fonction .from_pretrain () lui donnant le nom du modèle et en définissant le Trust_remote_code = true, cela téléchargera le modèle à partir du référentiel HF.
• Nous définissons ensuite ce modèle sur le modèle d'évaluation en appelant le .Eval () et l'envoyons au GPU en appelant la fonction .cuda ().
• Ensuite, nous créons une instance d'autoprocesseur en appelant le .From_pretrained () et en donnant le nom du modèle et en définissant le périphérique_map sur CUDA.

L'autoprocesseur est très similaire à Autotokenzizer. Mais la classe Autotokenzizer traite du texte et de la tokenisation de texte. Alors que l'autoprocesseur s'occupe à la fois de la tokenisation du texte et de l'image, car Florence-2 traite des données d'image, nous travaillons avec l'autoprocesseur.

Maintenant, prenons une image:

 à partir de l'image d'importation PIL
image = image.open ("/ contenu / plage.jpg")

Ici, nous avons pris une photo de plage.

Génération de la légende

Maintenant, nous allons donner cette image au modèle de langue de vision de Florence-2 et lui demander de générer une légende.

 Prompt = "<genture>"
entrées = processeur (text = invite, images = image, return_tensers = "pt"). à ("cuda")
généré_ids = modèle.generate (
    input_ids = entrées ["input_ids"],
    pixel_values ​​= entrées ["pixel_values"],
    max_new_tokens = 512,
    do_sample = false,
)
text_generations = procedor.batch_decode (généré_ids, 
skip_special_tokens = false) [0]

result = processor.post_process_generation (text_generations, 
tâche = invite, image_size = (image.width, image.height)))

imprimer (résultat [invite])</genture>

• Nous commençons par créer l'invite.
• Ensuite, nous donnons à la fois l'invite et l'image à la classe de processeur et retournons les capteurs Pytorch. Nous les donnons au GPU car le modèle réside dans le GPU et le stocke dans les entrées variables.
• La variable d'entrées contient les IDS Input_ID, c'est-à-dire les ID de jeton et les valeurs de pixel pour l'image.
• Ensuite, nous appelons la fonction de génération du modèle et donnons les ID d'entrée, les valeurs du pixel d'image. Nous définissons les jetons générés maximum sur 512 Gardez l'échantillonnage sur FALSE et stockez les jetons générés dans le généré_IDS.
• Ensuite, nous appelons la fonction .batch_decode du processeur lui donne le signalement généré_ids et définissez l'indicateur skip_special_tokens sur false. Ce sera une liste et nous avons donc besoin du premier élément de la liste.
• Enfin, nous postons le texte généré en appelant le .post_process_generated et en lui donnant le texte généré, le type de tâche et l'image_size comme tuple.

Exécutant le code et voyant la photo de sortie ci-dessus, nous voyons que le modèle a généré la légende «un parapluie et une chaise de salon sur une plage avec l'océan en arrière-plan» pour l'image. La légende de l'image ci-dessus est très courte.

Fournir des invites

Nous pouvons franchir cette prochaine étape en fournissant d'autres invites comme le et le .

Le code pour essayer cela peut être vu ci-dessous:

 Prompt = "<d>"
entrées = processeur (text = invite, images = image, return_tensers = "pt"). à ("cuda")
généré_ids = modèle.generate (
    input_ids = entrées ["input_ids"],
    pixel_values ​​= entrées ["pixel_values"],
    max_new_tokens = 512,
    do_sample = false,
)
text_generations = procedor.batch_decode (généré_ids, 
skip_special_tokens = false) [0]

result = processor.post_process_generation (text_generations, 
tâche = invite, image_size = (image.width, image.height)))

imprimer (résultat [invite])</d>

 Prompt = "<more_detailed_caption>"

entrées = processeur (text = invite, images = image, return_tensers = "pt"). à ("cuda")

généré_ids = modèle.generate (
    input_ids = entrées ["input_ids"],
    pixel_values ​​= entrées ["pixel_values"],
    max_new_tokens = 512,
    do_sample = false,
)


text_generations = procedor.batch_decode (généré_ids, 
skip_special_tokens = false) [0]

result = processor.post_process_generation (text_generations, 
tâche = invite, image_size = (image.width, image.height)))

imprimer (résultat [invite])</more_detailed_caption>

Ici, nous sommes allés avec le et pour le type de tâche, et pouvons voir les résultats après avoir exécuté le code dans la photo ci-dessus. Le a produit la sortie «Dans cette image, nous pouvons voir une chaise, une table, un parapluie, de l'eau, des navires, des arbres, un bâtiment et un ciel avec des nuages.» Et l'invite a produit la sortie «Un parapluie orange est sur la plage. Il y a une chaise longue blanche à côté du parapluie. Il y a deux bateaux dans l'eau.» Donc, avec ces deux invites, nous pouvons obtenir un peu plus de profondeur dans le sous-titrage de l'image que l'invite régulière.

Détection d'objets avec Florence-2

La détection d'objets est l'une des tâches bien connues de la vision par ordinateur. Il traite de la recherche d'un objet étant donné une image. Dans la détection d'objets, le modèle identifie l'image et fournit les coordonnées x et y des boîtes de délimitation autour de l'objet. Le modèle de langue de vision de Florence-2 est très capable de détecter des objets étant donné une image.

Essayons ceci avec l'image ci-dessous:

 image = image.open ("/ contenu / van.jpg")

Ici, nous avons une image d'une camionnette orange vif sur la route avec un bâtiment blanc en arrière-plan.

Fournir une image au modèle de langue de la vision de Florence-2

Maintenant, donnons cette image au modèle de langue de la vision de Florence-2.

 Prompt = "<od>"

entrées = processeur (text = invite, images = image, return_tensers = "pt"). à ("cuda")

généré_ids = modèle.generate (
    input_ids = entrées ["input_ids"],
    pixel_values ​​= entrées ["pixel_values"],
    max_new_tokens = 512,
    do_sample = false,
)
text_generations = procedor.batch_decode (généré_ids, 
skip_special_tokens = false) [0]

résultats = processeur.post_process_generation (text_generations, 
tâche = invite, image_size = (image.width, image.height)))
</od>

Le processus de détection d'objet est très similaire à la tâche de sous-titrage d'image que nous venons de faire. La seule différence ici est que nous modifions l'invite en Signification de la détection d'objets. Nous donnons donc cette invite avec l'image à l'objet de processeur et obtenons les entrées tokenisées. Ensuite, nous donnons ces entrées tokenisées avec les valeurs de pixels d'image au modèle de langage de vision Florence-2 pour générer la sortie. Puis décodez cette sortie.

La sortie est stockée dans la variable nommée Résultats. Les résultats variables sont du format {”: {'bboxes': [[x1, y1, x2, y2],…], 'Labels': ['Label1', 'Label2',…]}}. Ainsi, le modèle de vision Florence-2 sort la boîte de limite, x, y coordonnées pour chaque label, c'est-à-dire pour chaque objet qui détecte dans l'image.

Dessin Boîtes de délimitation sur l'image

Maintenant, nous allons dessiner ces boîtes de délimitation sur l'image avec les coordonnées que nous avons.

 Importer Matplotlib.pyplot en tant que plt
importer matplotlib.patches comme correctifs
Fig, ax = plt.subplots ()
ax.imshow (image)
Pour bbox, étiquette dans zip (résultats [invite] ['bboxes'], résultats [invite] ['labels']):
    x1, y1, x2, y2 = bbox
    rect_box = patchs.rectangle ((x1, y1), x2-x1, y2-y1, linewidth = 1, 
    edgecolor = 'r', faceColor = 'Aucun')
    ax.add_patch (rect_box)
    plt.Text (x1, y1, étiquette, color = 'blanc', Fontsize = 8, bbox = dict (faceColor = 'Red', alpha = 0,5))
ax.axis («off»)
plt.show ()

• Pour dessiner les boîtes de délimitation rectangulaires autour des images, nous travaillons avec la bibliothèque Matplotlib.
• Nous commençons par créer une figure et un axe, puis nous affichons l'image que nous avons donnée au modèle de langue de vision Florence-2.
• Ici, les boîtes de délimitation que le modèle sort est une liste contenant des coordonnées X, Y, et dans la sortie finale, il y a une liste de boîtes de délimitation, c'est-à-dire que chaque étiquette a sa propre boîte de limite.
• Nous itons donc à travers la liste des boîtes de délimitation.
• Ensuite, nous déballons les coordonnées X et Y des boîtes de délimitation.
• Ensuite, nous dessinons un rectangle avec les coordonnées que nous avons déballées dans la dernière étape.
• Enfin, nous le réparons sur l'image que nous affichons actuellement.
• Nous devons même ajouter une étiquette à la boîte de délimitation pour dire que la boîte de délimitation contient quel objet.
• Enfin, nous supprimons l'axe.

En exécutant ce code et en voyant la photo, nous voyons qu'il y a beaucoup de boîtes de délimitation générées par le modèle de langage de vision Florence-2 pour l'image Van que nous lui avons donnée. Nous voyons que le modèle a détecté la camionnette, les fenêtres et les roues et a pu donner les coordonnées correctes pour chaque étiquette.

Légende à la mise à la terre

Ensuite, nous avons une tâche appelée «Légende pour expliquer la mise à la terre» que le modèle Florence-2 soutient. Ce que le modèle fait, c'est, étant donné une image et une légende de celle-ci, la tâche de mise à la terre des phrases est de trouver chaque entité / objet le plus pertinent mentionné par une phrase nominale dans la légende donnée à une région de l'image.

Nous pouvons jeter un œil à cette tâche avec le code ci-dessous:

 Prompt = "<l> une camionnette orange garée devant un bâtiment blanc"
task_type = "<m>"
entrées = processeur (text = invite, images = image, return_tensers = "pt"). à ("cuda")
généré_ids = modèle.generate (
    input_ids = entrées ["input_ids"],
    pixel_values ​​= entrées ["pixel_values"],
    max_new_tokens = 512,
    do_sample = false,
)
text_generations = procedor.batch_decode (généré_ids, 
skip_special_tokens = false) [0]
résultats = processeur.post_process_generation (text_generations, 
task = task_type, image_size = (image.width, image.height))
</m></l>

Ici pour l'invite, nous lui donnons " une camionnette orange garée devant un bâtiment blanc", où la tâche est "" et la phrase est "une camionnette orange garée devant un bâtiment blanc". Le modèle Florence essaie de générer des boîtes de délimitation aux objets / entités qu'il peut obtenir de cette phrase donnée. Voyons la sortie finale en le tracé.

 Importer Matplotlib.pyplot en tant que plt
importer matplotlib.patches comme correctifs
Fig, ax = plt.subplots ()
ax.imshow (image)
Pour bbox, étiquette dans zip (résultats [task_type] ['bboxes'], résultats [task_type] ['labels']):
    x1, y1, x2, y2 = bbox
    rect_box = patchs.rectangle ((x1, y1), x2-x1, y2-y1, linewidth = 1, 
    edgecolor = 'r', faceColor = 'Aucun')
    ax.add_patch (rect_box)
    plt.Text (x1, y1, étiquette, color = 'blanc', Fontsize = 8, bbox = dict (faceColor = 'Red', alpha = 0,5))
ax.axis («off»)
plt.show ()

Ici, nous voyons que le modèle de langue de Vision Florence-2 a pu en extraire deux entités. L'un est une camionnette orange et l'autre est un bâtiment blanc. Florence-2 a ensuite généré les boîtes de délimitation pour chacune de ces entités. De cette façon, étant donné une légende, le modèle peut extraire des entités / objets pertinents de cette légende donnée et être en mesure de générer des boîtes de délimitation correspondantes pour ces objets.

Segmentation avec Florence-2

La segmentation est un processus, où une image est prise et des masques sont générés pour plusieurs parties de l'image. Où chaque masque est un objet. La segmentation est la prochaine étape de la détection d'objets. Dans la détection d'objets, nous ne trouvons que l'emplacement de l'image et générons les boîtes de délimitation. Mais dans la segmentation, au lieu de générer une boîte de délimitation rectangulaire, nous générons un masque qui sera en forme de l'objet, donc c'est comme créer un masque pour cet objet. Cela est utile car non seulement nous connaissons l'emplacement de l'objet, mais nous connaissons même la forme de l'objet. Et heureusement, le modèle de langue de Vision Florence-2 soutient la segmentation.

Segmentation sur l'image

Nous essaierons de segmenter à notre image de fourgonnette.

 Prompt = "<r> deux pneus noirs"
task_type = "<redeing_expression_segmentation>"
entrées = processeur (text = invite, images = image, return_tensers = "pt"). à ("cuda")
généré_ids = modèle.generate (
    input_ids = entrées ["input_ids"],
    pixel_values ​​= entrées ["pixel_values"],
    max_new_tokens = 512,
    do_sample = false,
)
text_generations = procedor.batch_decode (généré_ids, 
skip_special_tokens = false) [0]

résultats = processeur.post_process_generation (text_generations, 
task = task_type, image_size = (image.width, image.height))
</redeing_expression_segmentation></r>

• Ici, le processus est similaire au sous-titrage de l'image et aux tâches de détection d'objet. Nous commençons par fournir l'invite.
• Ici, l'invite est « deux pneus noirs» où la tâche est la segmentation.
• La segmentation sera basée sur l'entrée de texte fournie, ici, il s'agit de «deux pneus noirs».
• Le modèle Florence-2 essaiera donc de générer des masques étroitement liés à cette entrée de texte et à l'image fournie.

Ici, la variable de résultats sera du format {”: {'Polygons': [[[polygon]],…], 'Labels': [”, »,…]}} où chaque objet / masque est représenté par une liste de polygones. Et chaque polygone est de la forme [x1, y1, x2, y2,… xn, yn].

Création de masques et superposition sur l'image réelle

Maintenant, nous allons créer ces masques et les superposer sur l'image réelle afin que nous puissions le visualiser mieux.

 copie d'importation
Importer Numpy comme NP
à partir de l'affichage d'importation Ipython.Display
à partir de l'image d'importation PIL, iMagedraw, ImageFont

output_image = copy.deepcopy (image)
res = résultats [task_type]
draw = iMageDraw.draw (output_image)
échelle = 1
pour les polygones, étiqueter dans zip (res ['polygons'], res ['labels']):
    fill_color = "bleu"
    pour _polygon dans les polygones:
        _polygon = np.array (_polygon) .Reshape (-1, 2)
        Si Len (_Polygon) <p><img  src="/static/imghwm/default1.png" data-src="https://img.php.cn/upload/article/000/000/000/174502929770135.png?x-oss-process=image/resize,p_40" class="lazy" alt="Comment effectuer des tâches de vision informatique avec Florence-2 - Analytics Vidhya" ></p><h4 id="Explication"> Explication</h4>

• Ici, nous commençons par importer divers outils de la bibliothèque PIL pour le traitement d'image.
• Nous créons une copie profonde de notre image et stockons la valeur de la clé «» dans une nouvelle variable.
• Ensuite, nous chargeons l'image en créant une instance iMagedRaw en appelant la méthode.Draw () et en donnant la copie de l'image réelle.
• Ensuite, nous itérons à travers le zip des polygones et les valeurs d'étiquette.
• Pour chaque polygone, nous allons ensuite dans le polygone individuel avec le nom _polygon et le remodeler. Le _Polygon est désormais une liste de grande dimension.
• Nous savons qu'un _polygon doit avoir au moins 3 côtés afin qu'il puisse être connecté. Nous vérifions donc cette condition de validité, pour voir que la liste _polygon a au moins 3 éléments de la liste.
• Enfin, nous dessinons ce _polygon sur la copie de l'image réelle en appelant la méthode .polygon () et en lui donnant le _polygon. Parallèlement à cela, nous lui donnons même la couleur de contour et la couleur de remplissage.
• Si le modèle de langue de vision de Florence-2 génère une étiquette pour ces polygones, nous pouvons même dessiner ce texte sur la copie de l'image réelle en appelant la fonction .text () et en lui donnant l'étiquette.
• Enfin, après avoir dessiné tous les polygones générés par le modèle Florence-2, nous publions l'image en appelant la fonction d'affichage à partir de la bibliothèque Ipython.

Le modèle de langue de la vision de Florence-2 a compris avec succès notre requête de «deux pneus noirs» et a déduit que l'image contenait un véhicule avec des pneus noirs visibles. Le modèle a généré des représentations de polygones pour ces pneus, qui ont été masqués avec une couleur bleue. Le modèle a excellé dans diverses tâches de vision par ordinateur en raison des fortes données de formation organisées par l'équipe Microsoft.

Conclusion

Florence-2 est un modèle de langue de vision créé et formé à partir de zéro par l'équipe Microsoft. Contrairement à d'autres modèles de langage de vision, Florence-2 effectue diverses tâches de vision par ordinateur, y compris la détection d'objets, le sous-titrage de l'image, la détection d'objets de phrase, l'OCR, la segmentation et les combinaisons de ceux-ci. Dans ce guide, nous avons examiné comment télécharger le grand modèle Florence-2 et comment effectuer différentes tâches de vision par ordinateur avec des invites changeantes avec la Florence-2.

Principaux à retenir

• Le modèle Florence-2 est disponible en deux tailles. L'un est la variante de base qui est une version de 0,23 milliard de paramètres et l'autre est la grande variante qui est une version de paramètre de 0,7 milliard.
• L'équipe Microsoft a formé le modèle Florence-2 dans l'ensemble de données FLD 5B, qui est un ensemble de données d'image contenant différentes tâches d'image créées par l'équipe Microsoft.
• La Florence-2 accepte des images ainsi que l'invite de l'entrée. Où l'invite définit le type de tâche que le modèle de vision de Florence-2 devrait effectuer.
• Chaque tâche génère une sortie différente et toutes ces sorties sont générées au format texte.
• Florence-2 est un modèle open-source avec une licence MIT, il peut donc être travaillé avec des applications commerciales.

Questions fréquemment posées

Q1. Qu'est-ce que Florence-2?

A. Florence-2 est un modèle de langage de vision développé par l'équipe Microsoft et a été publié en deux tailles, un paramètre de 0,23b et une version de paramètre de 0,7b.

Q2. En quoi l'autoprocesseur est-il différent de Autotokenzizer?

A. Autotokenzer ne peut gérer que des données de texte où elle convertit le texte en jetons. D'un autre côté, les données pré-processeurs de l'autoprocesseur pour les modèles multimodales qui incluent même les données d'image.

Q3. Qu'est-ce que FLD-5B?

A. FLD-5B est un ensemble de données d'image organisé par l'équipe Microsoft. Il contient environ 5,4 milliards d'images pour 126 millions d'images.

Q4. Qu'est-ce que le modèle de Florence-2 sort?

A. Le modèle Florence-2 sort du texte basé sur l'image d'entrée et le texte d'entrée donné. Ce texte peut être une légende d'image simple ou il peut les coordonnées de la boîte de délimitation si la tâche est la détection ou la segmentation des objets.

Q5. Florence-2 est-il open source?

A. Oui. Florence-2 est publiée sous la licence MIT, ce qui le rend open source et il n'a pas besoin de s'authentifier avec HuggingFace pour travailler avec ce modèle.

Les médias présentés dans cet article ne sont pas détenus par l'analytique vidhya et sont utilisés à la discrétion de l'auteur.

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!