So führen Sie Computer -Vision -Aufgaben mit Florence -2 - Analytics Vidhya aus

Einführung

Die Einführung der ursprünglichen Transformatoren ebnete den Weg für die aktuellen großsprachigen Modelle. In ähnlicher Weise wurde nach der Einführung des Transformatormodells der Vision Transformator (VIT) eingeführt. Wie die Transformatoren, die sich beim Verständnis von Text und zum Generieren von Text mit einer Antwort übertreffen, wurden Sehtransformatormodelle entwickelt, um Bilder zu verstehen und Informationen mit einem Bild bereitzustellen. Diese führten zu den Vision -Sprachmodellen, die sich beim Verständnis von Bildern hervorheben. Microsoft hat einen Schritt vorwärts und hat ein Modell eingeführt, das viele Sichtaufgaben nur mit einem einzigen Modell ausführen kann. In diesem Leitfaden werden wir uns dieses Modell namens Florence-2 ansehen, das von Microsoft veröffentlicht wurde und viele verschiedene Sehvermögensaufgaben löst.

Lernziele

• Beziehen Sie sich in Florence-2, einem Vision-Sprachmodell.
• Verständnis der Daten, über die Florence-2 trainiert wird.
• Unter verschiedene Modelle in der Familie Florence-2 kennenlernen.
• Erfahren Sie, wie Sie Florence-2 herunterladen.
• Schreiben Sie Code, um mit Florence-2 verschiedene Computer Vision-Aufgaben auszuführen.

Dieser Artikel wurde als Teil des Data Science -Blogathons veröffentlicht.

Inhaltsverzeichnis

• Was ist Florence-2?
• Bildunterschrift mit Florence-2
• Objekterkennung mit Florence-2
• Segmentierung mit Florence-2
• Häufig gestellte Fragen

Was ist Florence-2?

Florence-2 ist ein vom Microsoft-Team entwickeltes Vision Language Model (VLM). Florence-2 gibt es in zwei Größen. Eine ist eine 0,23B -Version und die andere ist eine 0,77B -Version. Diese niedrigen Größen erleichtern es jedem, diese Modelle auf der CPU selbst auszuführen. Florence-2 wird erstellt, wenn man bedenkt, dass ein Modell alles lösen kann. Florence-2 wird geschult, um verschiedene Aufgaben zu lösen, einschließlich Objekterkennung, Objektsegmentierung, Bildunterschrift (sogar detaillierte Bildunterschriften erzeugen), Phrasensegmentierung, OCR (optische Zeichenerkennung) und auch eine Kombination von diesen.

Das Florence-2 Vision Language-Modell ist auf dem FLD 5B-Datensatz geschult. Dieser FLD-5B ist ein Datensatz, der vom Microsoft-Team erstellt wurde. Dieser Datensatz enthält etwa 5,4 Milliarden Textanmerkungen auf rund 126 Millionen Bildern. Dazu gehören 1,3 -Milliarden -Anmerkungen zur Textregion, 500 Millionen Textanmerkungen und Annotationen der Textphrasenregion von 3,6 Milliarden. Florence-2 akzeptiert Textanweisungen und Bildeingaben und generiert Textergebnisse für Aufgaben wie OCR, Objekterkennung oder Bildunterschrift.

Die Architektur enthält einen visuellen Encoder, gefolgt von einem Transformator -Encoder -Decoder -Block, und für den Verlust arbeiten sie mit der Standardverlustfunktion, dh der Kreuzentropieverlust. Das Florence-2-Modell führt drei Arten von Regionserkennungen durch: Boxdarstellungen für die Objekterkennung, Quad-Box-Darstellungen für die OCR-Texterkennung und Polygondarstellungen für Segmentierungsaufgaben.

Bildunterschrift mit Florence-2

Bildunterschriften ist eine Vision -Sprachaufgabe, bei der das Deep -Learning -Modell eine Bildunterschrift über das Bild ausgibt. Diese Bildunterschrift kann basierend auf dem Training, das das Modell unterzogen hat, kurz oder detailliert sein. Die Modelle, die diese Aufgaben ausführen, werden nach einem riesigen Bildunterschriftsdaten trainiert, in denen sie lernen, wie man einen Text ausgibt, mit einem Bild. Je mehr Daten sie geschult sind, desto mehr können sie die Bilder gut beschreiben.

Herunterladen und Installieren

Wir werden zunächst einige Bibliotheken herunterladen und installieren, die wir zum Ausführen des Florence Vision -Modells benötigen.

 !

• Transformers: Die Transformers Library von Suggingface bietet verschiedene Deep -Learning -Modelle für verschiedene Aufgaben, die Sie herunterladen können.
• Accelerate: Die Beschleunigungsbibliothek von Suggingface verbessert die Inferenzzeit des Modells beim Servieren von Modellen über eine GPU.
• Flash_attn: Die Flash-Aufmerksamkeitsbibliothek implementiert einen schnelleren Aufmerksamkeitsalgorithmus als das Original und wird im Florence-2-Modell verwendet.
• EINOPS: Einstein-Operationen vereinfachen die Darstellung von Matrixmultiplikationen und sind im Florence-2-Modell implementiert.

Herunterladen von Florence-2-Modell

Jetzt müssen wir das Florence-2-Modell herunterladen. Dafür werden wir mit dem folgenden Code arbeiten.

 aus Transformatoren importieren Autoprozessor, AutomodelforcausAllm

model_id = 'microsoft/florence-2-large-ft'
model = automodelforcausAllm.from_petrarmed (model_id, treued_remote_code = true) .eval (). CUDA ()
processor = autoprocessor.from_pretraed (model_id, trust_remote_code = true, develation_map = "cuda")

• Wir beginnen mit dem Importieren des Automodelcausallm und des Autoprozessors.
• Dann speichern wir den Modellnamen in der Variablen model_name. Hier arbeiten wir mit dem Florence-2 Large Fine Tuned Model.
• Anschließend erstellen wir eine Instanz von AutomodelforcausAllm, indem wir die Funktion .from_Pretrainierte () aufrufen, wobei der Modellname und das Festlegen der Trust_Remote_Code = true das Modell aus dem HF -Repository heruntergeladen wird.
• Anschließend setzen wir dieses Modell auf das Bewertungsmodell, indem wir die EVAL () aufgerufen und an die GPU senden, indem wir die Funktion .cuda () aufrufen.
• Anschließend erstellen wir eine Instanz von Autoprocessor, indem wir das .From_Pretrainierte () aufrufen und den Modellnamen geben und die Device_Map auf CUDA einstellen.

Autoprozessor ist dem Autotokenizer sehr ähnlich. Die Autotokenizer -Klasse befasst sich jedoch mit Text- und Text -Tokenisierung. Während sich Autoprocessor sowohl mit Text- als auch mit Bildtokenisierung befasst, da wir mit Bilddaten befasst, arbeiten wir mit dem Autoprozessor zusammen.

Lassen Sie uns nun ein Bild nehmen:

 vom PIL -Importbild
Image = Image.open ("/content/Beach.jpg")

Hier haben wir ein Strandfoto gemacht.

Bildunterschrift erzeugen

Jetzt geben wir dieses Bild dem Florence-2-Vision-Sprachmodell und bitten es, eine Bildunterschrift zu generieren.

 Fordert = "<caption>"
inputs = processor (text = prompt, images = Bild, return_tensors = "pt"). An ("Cuda")
generated_ids = model.generate (
    input_ids = inputs ["input_ids"],
    pixel_values ​​= inputs ["pixel_values"],
    max_new_tokens = 512,
    Do_Sample = false,
)
text_generations = processor.batch_decode (generated_ids, 
Skip_special_tokens = false) [0]

result = processor.post_process_generation (text_generations, 
Task = Eingabeaufforderung, Image_Size = (Image.width, Image.Height))

drucken (Ergebnis [Eingabeaufforderung])</caption>

• Wir beginnen damit, die Eingabeaufforderung zu erstellen.
• Dann geben wir der Prozessorklasse sowohl die Eingabeaufforderung als auch die Bild und geben die Pytorch -Sensoren zurück. Wir geben sie der GPU, weil sich das Modell in der GPU befindet und es in den variablen Eingängen speichert.
• Die Variable der Eingänge enthält die input_ids, dh die Token -IDs und die Pixelwerte für das Bild.
• Dann nennen wir die Erzeugungsfunktion des Modells und geben die Eingabe -IDs, die Bildpixelwerte an. Wir setzen die maximal erzeugten Token auf 512, um die Abtastung auf False zu halten und die generierten Token in den generierten_IDs zu speichern.
• Dann rufen wir die Funktion .batch_decode des Prozessors auf und geben ihm die generierten_IDs und setzen das Flag cip_special_tokens auf false. Dies wird eine Liste sein und daher brauchen wir das erste Element der Liste.
• Schließlich verarbeiten wir den generierten Text, indem wir die .post_process_generated aufrufen und ihm den generierten Text, den Task-Typ und das Image_Size als Tupel geben.

Wenn wir den Code ausführen und das Output -Bild oben sehen, sehen wir, dass das Modell die Bildunterschrift „Ein Dach- und Lounge -Stuhl am Strand mit dem Ozean im Hintergrund“ für das Bild generiert hat. Die obige Bildunterschrift ist sehr kurz.

Eingabeaufforderungen bereitstellen

Wir können diesen nächsten Schritt tun, indem wir andere Eingabeaufforderungen wie die und die bereitstellen.

Der Code zum Versuch ist unten zu sehen:

 Fordert = "<detailed_caption>"
inputs = processor (text = prompt, images = Bild, return_tensors = "pt"). An ("Cuda")
generated_ids = model.generate (
    input_ids = inputs ["input_ids"],
    pixel_values ​​= inputs ["pixel_values"],
    max_new_tokens = 512,
    Do_Sample = false,
)
text_generations = processor.batch_decode (generated_ids, 
Skip_special_tokens = false) [0]

result = processor.post_process_generation (text_generations, 
Task = Eingabeaufforderung, Image_Size = (Image.width, Image.Height))

drucken (Ergebnis [Eingabeaufforderung])</detailed_caption>

 Fordert = "<more_detailed_caption>"

inputs = processor (text = prompt, images = Bild, return_tensors = "pt"). An ("Cuda")

generated_ids = model.generate (
    input_ids = inputs ["input_ids"],
    pixel_values ​​= inputs ["pixel_values"],
    max_new_tokens = 512,
    Do_Sample = false,
)


text_generations = processor.batch_decode (generated_ids, 
Skip_special_tokens = false) [0]

result = processor.post_process_generation (text_generations, 
Task = Eingabeaufforderung, Image_Size = (Image.width, Image.Height))

drucken (Ergebnis [Eingabeaufforderung])</more_detailed_caption>

Hier haben wir mit der und für den Aufgabentyp gegangen und können die Ergebnisse nach dem Ausführen des Code im obigen Bild sehen. Die erzeugte die Ausgabe „In diesem Bild können wir einen Stuhl, einen Tisch, einen Regenschirm, Wasser, Schiffe, Bäume, Gebäude und Himmel mit Wolken sehen.“ und die Eingabeaufforderung erzeugt den Ausgang „Ein orangefarbener Regenschirm befindet sich am Strand. Neben dem Regenschirm befindet sich ein weißer Lounge -Stuhl. Es gibt zwei Boote im Wasser.“ Mit diesen beiden Eingaben können wir die Bildunterschrift etwas mehr Tiefe erzielen als die reguläre Eingabeaufforderung.

Objekterkennung mit Florence-2

Die Objekterkennung ist eine der bekannten Aufgaben im Computer Vision. Es befasst sich damit, ein Objekt zu finden, das ein Bild mit einem Bild findet. Bei der Objekterkennung identifiziert das Modell das Bild und liefert die X- und Y -Koordinaten der Begrenzungsboxen um das Objekt. Das Florence-2-Vision-Sprachmodell ist sehr in der Lage, Objekte mit einem Bild zu erkennen.

Versuchen wir dies mit dem folgenden Bild:

 Image = Image.open ("/content/van.jpg"))

Hier haben wir ein Bild von einem hellen orangefarbenen Van auf der Straße mit einem weißen Gebäude im Hintergrund.

Bereitstellung von Image für Florence-2 Vision Sprachmodell

Lassen Sie uns nun dieses Bild dem Florence-2 Vision Language-Modell geben.

 Fordert = "<od>"

inputs = processor (text = prompt, images = Bild, return_tensors = "pt"). An ("Cuda")

generated_ids = model.generate (
    input_ids = inputs ["input_ids"],
    pixel_values ​​= inputs ["pixel_values"],
    max_new_tokens = 512,
    Do_Sample = false,
)
text_generations = processor.batch_decode (generated_ids, 
Skip_special_tokens = false) [0]

Ergebnisse = processor.post_process_generation (text_generations, 
Task = Eingabeaufforderung, Image_Size = (Image.width, Image.Height))
</od>

Der Prozess für die Objekterkennung ist der Bildunterschrift, die wir gerade durchgeführt haben, sehr ähnlich. Der einzige Unterschied besteht darin, dass wir die Eingabeaufforderung in die Erkennung von Objekten für ändern. Deshalb geben wir diese Eingabeaufforderung zusammen mit dem Bild dem Prozessorobjekt und erhalten die tokenisierten Eingänge. Anschließend geben wir diese tokenisierten Eingänge mit den Bildpixelwerten an das Florence-2-Vision-Sprachmodell an, um die Ausgabe zu generieren. Dann dekodieren Sie diesen Ausgang.

Die Ausgabe wird in den mit Variablen benannten Ergebnissen gespeichert. Die variablen Ergebnisse stammen aus dem Format {": {'Bboxes': [[x1, y1, x2, y2],…], 'Labels': ['Label1', 'Label2',…]}}. Also gibt das Modell von Florence-2 Vision das Begrenzungsbox aus, x, y Koordinaten für jedes Label, für jedes Objekt, das auf dem Bild erfasst.

Zeichnen von Begrenzungsboxen auf dem Bild

Jetzt werden wir diese Begrenzungsboxen mit den Koordinaten, die wir haben, auf das Bild zeichnen.

 matplotlib.pyplot als pLT importieren
Importieren Sie Matplotlib.patches als Patches
Abb, ax = plt.subplots ()
ax.imshow (Bild)
Für Bbox, Beschriften Sie in ZIP (Ergebnisse [Eingabeaufforderung] ['Bboxes'], Ergebnisse [Eingabeaufforderung] ['Labels']):
    x1, y1, x2, y2 = bbox
    rect_box = patches.Rectangle ((x1, y1), x2-x1, y2-y1, linewidth = 1,, 
    edgecolor = 'r', facecolor = 'keine')
    ax.add_patch (rekt_box)
    Plt.Text (x1, y1, label, color = 'white', fontsize = 8, bbox = dict (faceColor = 'rot', alpha = 0,5))
Ax.axis ('Off')
Plt.Show ()

• Um die rechteckigen Begrenzungsboxen um die Bilder zu zeichnen, arbeiten wir mit der Matplotlib -Bibliothek.
• Wir beginnen mit der Erstellung einer Figur und einer Achse und dann zeigen wir das Bild, das wir dem Florence-2 Vision Language-Modell gegeben haben.
• Hier sind die Begrenzungsboxen, die die Modellausgaben ausgängen, eine Liste mit X-, Y -Koordinaten, und in der endgültigen Ausgabe gibt es eine Liste von Begrenzungsboxen, dh jedes Etikett verfügt über ein eigenes Begrenzungsfeld.
• Also iterieren wir die Liste der Begrenzungsboxen.
• Dann packen wir die X- und Y -Koordinaten der Begrenzungsboxen aus.
• Dann zeichnen wir ein Rechteck mit den Koordinaten, die wir im letzten Schritt ausgepackt haben.
• Schließlich pflücken wir es auf das Bild, das wir derzeit anzeigen.
• Wir müssen sogar ein Etikett zum Begrenzungsfeld hinzufügen, um festzustellen, dass das Begrenzungsfeld welches Objekt enthält.
• Schließlich entfernen wir die Achse.

Wenn wir diesen Code ausführen und das Bild sehen, sehen wir, dass es viele Begrenzungsboxen gibt, die vom Florence-2 Vision Language-Modell für das Van-Bild generiert werden, das wir ihm gegeben haben. Wir sehen, dass das Modell den Van, die Fenster und die Räder erkannt hat und die richtigen Koordinaten für jedes Etikett angeben konnte.

Bildunterschrift zur Ausdrucks Erdung

Als nächstes haben wir eine Aufgabe namens "Bildunterschrift zur Ausdrucksgründe", die das Florence-2-Modell unterstützt. Was das Modell tut, ist, ein Bild und eine Bildunterschrift zu geben, die Aufgabe der Phrase Erdung besteht darin, jede / relevanteste Entität / das relevanteste Einsatz / Objekt zu finden, die durch eine Substantivphrase in der angegebenen Bildunterschrift in einem Bereich im Bild erwähnt werden.

Wir können uns diese Aufgabe mit dem folgenden Code ansehen:

 Fordert = "<caption_to_phrase_grounding> ein orangefarbener Van, der vor einem weißen Gebäude geparkt ist."
task_type = "<caption_to_phrase_grounding>"
inputs = processor (text = prompt, images = Bild, return_tensors = "pt"). An ("Cuda")
generated_ids = model.generate (
    input_ids = inputs ["input_ids"],
    pixel_values ​​= inputs ["pixel_values"],
    max_new_tokens = 512,
    Do_Sample = false,
)
text_generations = processor.batch_decode (generated_ids, 
Skip_special_tokens = false) [0]
Ergebnisse = processor.post_process_generation (text_generations, 
task = task_type, image_size = (image.width, image.height))
</caption_to_phrase_grounding></caption_to_phrase_grounding>

Hier geben wir für die Eingabeaufforderung „ einen vor einem weißen Gebäude geparkten orangefarbenen Van“, in dem die Aufgabe "" ist und der Ausdruck der "ein orangefarbenes Van, das vor einem weißen Gebäude geparkt ist". Das Florenzmodell versucht, Begrenzungsboxen an die Objekte/Entitäten zu generieren, die es von dieser gegebenen Phrase erhalten kann. Lassen Sie uns die endgültige Ausgabe sehen, indem Sie ihn darstellen.

 matplotlib.pyplot als pLT importieren
Importieren Sie Matplotlib.patches als Patches
Abb, ax = plt.subplots ()
ax.imshow (Bild)
Für Bbox, Beschriften Sie in ZIP (Ergebnisse [Task_type] ['Bboxes'], Ergebnisse [Task_type] ['Labels']):
    x1, y1, x2, y2 = bbox
    rect_box = patches.Rectangle ((x1, y1), x2-x1, y2-y1, linewidth = 1,, 
    edgecolor = 'r', facecolor = 'keine')
    ax.add_patch (rekt_box)
    Plt.Text (x1, y1, label, color = 'white', fontsize = 8, bbox = dict (faceColor = 'rot', alpha = 0,5))
Ax.axis ('Off')
Plt.Show ()

Hier sehen wir, dass das Florence-2-Vision-Sprachmodell zwei Entitäten aus der IT extrahieren konnte. Einer ist ein orangefarbener Van und der andere ist ein weißes Gebäude. Dann erzeugte Florence-2 die Begrenzungsboxen für jede dieser Einheiten. Auf diese Weise kann das Modell angesichts einer Bildunterschrift relevante Entitäten/Objekte aus dieser gegebenen Beschriftung extrahieren und in der Lage sein, entsprechende Begrenzungsboxen für diese Objekte zu erzeugen.

Segmentierung mit Florence-2

Die Segmentierung ist ein Prozess, bei dem ein Bild aufgenommen wird und Masken für mehrere Teile des Bildes erzeugt werden. Wo jede Maske ein Objekt ist. Die Segmentierung ist die nächste Stufe der Objekterkennung. Bei der Objekterkennung finden wir nur die Position des Bildes und erzeugen die Begrenzungsboxen. In der Segmentierung erzeugen wir anstatt ein rechteckiges Begrenzungsfeld zu erzeugen, eine Maske, die in der Form des Objekts steht, so dass es so ist, als würde man eine Maske für dieses Objekt erstellen. Dies ist hilfreich, da wir nicht nur den Ort des Objekts kennen, sondern auch die Form des Objekts kennen. Und zum Glück unterstützt das Florence-2 Vision Language-Modell die Segmentierung.

Segmentierung auf dem Bild

Wir werden die Segmentierung in unser Van -Bild versuchen.

 Fordert = "<refering_expression_segmentation> Zwei schwarze Reifen"
Task_type = "<refering_expression_segmentation>"
inputs = processor (text = prompt, images = Bild, return_tensors = "pt"). An ("Cuda")
generated_ids = model.generate (
    input_ids = inputs ["input_ids"],
    pixel_values ​​= inputs ["pixel_values"],
    max_new_tokens = 512,
    Do_Sample = false,
)
text_generations = processor.batch_decode (generated_ids, 
Skip_special_tokens = false) [0]

Ergebnisse = processor.post_process_generation (text_generations, 
task = task_type, image_size = (image.width, image.height))
</refering_expression_segmentation></refering_expression_segmentation>

• Hier ähnelt der Prozess der Bildunterschrift und den Objekterkennungsaufgaben. Wir beginnen mit der Eingabeaufforderung.
• Hier ist die Eingabeaufforderung " zwei schwarze reifen", wobei die Aufgabe eine Segmentierung ist.
• Die Segmentierung basiert auf der bereitgestellten Texteingabe. Hier handelt es sich um „zwei schwarze Reifen“.
• Das Florence-2-Modell wird also versuchen, Masken zu generieren, die eng mit dieser Texteingabe und dem bereitgestellten Bild zusammenhängen.

Hier ist die Ergebnisvariable des Formats {": {'polygons': [[[polygon]],…], 'labels': [”,…]}} wobei jedes Objekt/die Maske durch eine Liste von Polygonen dargestellt wird. Und jedes Polygon ist aus der Form [x1, y1, x2, y2, yn, yn, yn].

Erstellen von Masken und Überlagern auf dem tatsächlichen Bild

Jetzt werden wir diese Masken erstellen und sie auf dem eigentlichen Bild überlagern, damit wir sie besser visualisieren können.

 Kopie importieren
Numph als NP importieren
Aus Ipython.display Import Display
vom PIL -Importbild, Imagedraw, ImageFont

output_image = copy.deepcopy (Bild)
res = Ergebnisse [Task_type]
zeichnen = imagedraw.draw (output_image)
Skala = 1
Für Polygone, Etikett in ZIP (res ['Polygone'], res ['Labels']):
    fill_color = "blau"
    für _polygon in Polygonen:
        _polygon = np.Array (_polygon) .reshape (-1, 2)
        Wenn Len (_polygon) <p><img  src="/static/imghw/default1.png" data-src="https://img.php.cn/upload/article/000/000/000/174502929770135.png" class="lazy" alt="So führen Sie Computer -Vision -Aufgaben mit Florence -2 - Analytics Vidhya aus" ></p><h4 id="Erläuterung"> Erläuterung</h4>

• Hier importieren wir zunächst verschiedene Tools aus der PIL -Bibliothek für die Bildverarbeitung.
• Wir erstellen eine tiefe Kopie unseres Bildes und speichern den Wert des Schlüssels "" in einer neuen Variablen.
• Als nächstes laden wir das Bild, indem wir eine Imagedraw -Instanz erstellen, indem wir die Methode.DRAW () aufrufen und die Kopie des eigentlichen Bildes geben.
• Als nächstes iterieren wir den Reißverschluss von Polygonen und die Etikettenwerte.
• Für jedes Polygon iterieren wir dann durch das individuelle Polygon mit dem Namen _polygon und formen es um. Das _polygon ist jetzt eine hochdimensionale Liste.
• Wir wissen, dass ein _polygon mindestens 3 Seiten haben muss, damit er verbunden werden kann. Daher prüfen wir nach dieser Gültigkeitsbedingung, um festzustellen, dass die Liste _polygon mindestens 3 Listenelemente enthält.
• Schließlich zeichnen wir dieses _polygon auf die Kopie des eigentlichen Bildes, indem wir die Methode .polygon () aufrufen und ihm den _polygon geben. Damit geben wir ihm sogar die Umrissfarbe und die Füllfarbe.
• Wenn das Florence-2-Vision-Sprachmodell ein Etikett für diese Polygone generiert, können wir diesen Text sogar auf die Kopie des tatsächlichen Bildes zeichnen, indem wir die Funktion .Text () aufrufen und ihm das Etikett geben.
• Nach dem Zeichnen aller Polygone, die vom Florence-2-Modell erzeugt werden, geben wir schließlich das Bild aus, indem wir die Anzeigefunktion aus der Ipython-Bibliothek aufrufen.

Das Florence-2 Vision Language-Modell verstand unsere Abfrage von „zwei schwarzen Reifen“ erfolgreich und schließte darauf hin, dass das Bild ein Fahrzeug mit sichtbaren schwarzen Reifen enthielt. Das Modell erzeugte Polygon -Darstellungen für diese Reifen, die mit einer blauen Farbe maskiert wurden. Das Modell war aufgrund der starken Trainingsdaten, die vom Microsoft -Team kuratiert wurden, in verschiedenen Computer -Vision -Aufgaben hervorragend.

Abschluss

Florence-2 ist ein Vision-Sprachmodell, das vom Microsoft-Team von Grund auf erstellt und trainiert wurde. Im Gegensatz zu anderen Vision-Sprachmodellen führt Florence-2 verschiedene Computer-Vision-Aufgaben aus, einschließlich Objekterkennung, Bildunterschrift, Phrase-Objekterkennung, OCR, Segmentierung und Kombinationen dieser. In diesem Leitfaden haben wir uns angesehen, wie Sie das große Modell von Florence-2 herunterladen und wie Sie verschiedene Computer-Vision-Aufgaben ausführen können, wobei sich die Eingabeaufforderungen mit dem Florence-2 ändern.

Key Takeaways

• Das Florence-2-Modell ist in zwei Größen erhältlich. Eine ist die Basisvariante, die eine Parameterversion von 0,23 Milliarden ist, und die andere ist die große Variante, die eine Parameterversion von 0,7 Milliarden ist.
• Das Microsoft-Team hat das Florence-2-Modell im FLD 5B-Datensatz geschult, einem Bilddatensatz, das verschiedene Bildaufgaben enthält, die vom Microsoft-Team erstellt wurden.
• Das Florence-2 akzeptiert Bilder zusammen mit der Eingabeaufforderung. Wo die Eingabeaufforderung die Art der Aufgabe definiert, sollte das Florence-2-Vision-Modell ausführen.
• Jede Aufgabe generiert eine andere Ausgabe und alle diese Ausgänge werden im Textformat generiert.
• Florence-2 ist ein Open-Source-Modell mit einer MIT-Lizenz und kann auch für kommerzielle Anwendungen bearbeitet werden.

Häufig gestellte Fragen

Q1. Was ist Florence-2?

A. Florence-2 ist ein vom Microsoft-Team entwickeltes Visionsprachmodell und wurde in zwei Größen veröffentlicht, einem Parameter von 0,23B und einer 0,7B-Parameterversion.

Q2. Wie unterscheidet sich Autoprozessor von Autotokenizer?

A. Autotokenizer kann nur mit Textdaten umgehen, in denen Text in Token umgewandelt wird. Andererseits sind Autoprozessor-Vorverarbeitungsdaten für multimodale Modelle, die sogar die Bilddaten enthalten.

Q3. Was ist FLD-5B?

A. FLD-5B ist ein vom Microsoft-Team kuratierter Bilddatensatz. Es enthält etwa 5,4 Milliarden Bildunterschriften für 126 Millionen Bilder.

Q4. Was gibt das Modell von Florence-2 aus?

A. Florence-2-Modell-Ausgabementext basiert auf dem angegebenen Eingabebild und Eingabetxt. Dieser Text kann eine einfache Bildunterschrift sein oder die Begrenzungsbox koordiniert, wenn die Aufgabe Objekterkennung oder -segmentierung ist.

Q5. Ist Florence-2 Open Source?

A. Ja. Florence-2 wird unter der MIT-Lizenz veröffentlicht, wodurch es Open Source macht, und man muss sich nicht mit dem Umarmungen authentifizieren, um mit diesem Modell zu arbeiten.

Die in diesem Artikel gezeigten Medien sind nicht im Besitz von Analytics Vidhya und werden nach Ermessen des Autors verwendet.

Das obige ist der detaillierte Inhalt vonSo führen Sie Computer -Vision -Aufgaben mit Florence -2 - Analytics Vidhya aus. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!