Cara Melaksanakan Tugas Penglihatan Komputer dengan Florence -2 - Analytics Vidhya

Pengenalan

Pengenalan Transformers asal membuka jalan bagi model bahasa besar semasa. Begitu juga, selepas pengenalan model Transformer, Pengubah Visi (VIT) diperkenalkan. Seperti Transformers yang cemerlang dalam memahami teks dan menghasilkan teks yang diberikan, model Transformer Visi telah dibangunkan untuk memahami imej dan memberikan maklumat yang diberikan imej. Ini membawa kepada model bahasa penglihatan, yang cemerlang dalam memahami imej. Microsoft telah mengambil langkah ke hadapan untuk ini dan memperkenalkan model yang mampu melaksanakan banyak tugas penglihatan hanya dengan satu model. Dalam panduan ini, kami akan melihat model ini yang dipanggil Florence-2, yang dikeluarkan oleh Microsoft, yang direka untuk menyelesaikan banyak tugas penglihatan yang berbeza.

Objektif pembelajaran

• Dapatkan diperkenalkan kepada Florence-2, model bahasa penglihatan.
• Memahami data di mana Florence-2 dilatih.
• Mengenali model yang berbeza dalam keluarga Florence-2.
• Ketahui cara memuat turun Florence-2.
• Tulis kod untuk melaksanakan tugas penglihatan komputer yang berbeza dengan Florence-2.

Artikel ini diterbitkan sebagai sebahagian daripada Blogathon Sains Data.

Jadual Kandungan

• Apa itu Florence-2?
• Tajuk imej dengan Florence-2
• Pengesanan Objek dengan Florence-2
• Segmentasi dengan Florence-2
• Soalan yang sering ditanya

Apa itu Florence-2?

Florence-2 adalah model bahasa penglihatan (VLM) yang dibangunkan oleh pasukan Microsoft. Florence-2 datang dalam dua saiz. Satu adalah versi 0.23B dan yang lain adalah versi 0.77B. Saiz rendah ini memudahkan semua orang menjalankan model ini pada CPU itu sendiri. Florence-2 dicipta dengan mengingati bahawa satu model dapat menyelesaikan segala-galanya. Florence-2 dilatih untuk menyelesaikan tugas-tugas yang berbeza termasuk pengesanan objek, segmentasi objek, kapsyen imej (walaupun menghasilkan kapsyen terperinci), segmentasi frasa, OCR (pengiktirafan aksara optik), dan gabungannya juga.

Model bahasa penglihatan Florence-2 dilatih di dataset FLD 5B. FLD-5B ini adalah dataset yang dibuat oleh pasukan Microsoft. Dataset ini mengandungi kira -kira 5.4 bilion anotasi teks pada sekitar 126 juta imej. Ini termasuk 1.3 bilion anotasi rantau teks, 500 juta anotasi teks, dan 3.6 bilion anotasi rantau frasa teks. Florence-2 menerima arahan teks dan input imej, menghasilkan hasil teks untuk tugas seperti OCR, pengesanan objek, atau imej imej.

Senibina mengandungi pengekod visual diikuti oleh blok pengekod pengubah pengubah dan untuk kehilangan, mereka bekerja dengan fungsi kehilangan standard iaitu kehilangan entropi silang. Model Florence-2 melakukan tiga jenis pengesanan rantau: perwakilan kotak untuk pengesanan objek, perwakilan kotak quad untuk pengesanan teks OCR, dan perwakilan poligon untuk tugas segmentasi.

Tajuk imej dengan Florence-2

Tajuk imej adalah tugas bahasa penglihatan, di mana diberi imej, model pembelajaran mendalam akan mengeluarkan kapsyen mengenai imej. Kapsyen ini boleh pendek atau terperinci berdasarkan latihan model telah menjalani. Model -model yang melaksanakan tugas -tugas ini dilatih pada data imej imej yang besar, di mana mereka belajar cara mengeluarkan teks, diberi imej. Semakin banyak data yang mereka terlatih, semakin banyak mereka dapat menerangkan imej.

Memuat turun dan memasang

Kami akan bermula dengan memuat turun dan memasang beberapa perpustakaan yang kami perlukan untuk menjalankan model Florence Vision.

 ! Pip pemasangan -q -u transformer mempercepat flash_attn einops timm

• Transformers: Perpustakaan Transformers Huggingface menyediakan pelbagai model pembelajaran mendalam untuk tugas yang berbeza yang boleh anda muat turun.
• Mempercepatkan: Perpustakaan Percepat HuggingFace meningkatkan masa kesimpulan model apabila melayani model melalui GPU.
• Flash_attn: Perpustakaan Perhatian Flash melaksanakan algoritma perhatian yang lebih cepat daripada yang asal, dan ia digunakan dalam model Florence-2.
• Einops: Operasi Einstein memudahkan mewakili pendaraban matriks dan dilaksanakan dalam model Florence-2.

Memuat turun model Florence-2

Sekarang, kita perlu memuat turun model Florence-2. Untuk ini, kami akan bekerjasama dengan kod di bawah.

 Dari Transformers Import Autoprocessor, AutomelforCausallm

Model_id = 'Microsoft/Florence-2-Large-Ft'
model = automelforcausallm.from_pretrained (model_id, aman_remote_code = true) .eval (). cuda ()
pemproses = autoprocessor.from_pretrained (model_id, aman_remote_code = true, device_map = "cuda")

• Kami bermula dengan mengimport automelforcausallm dan autoprocessor.
• Kemudian kami menyimpan nama model dalam pemboleh ubah model_name. Di sini kita akan bekerjasama dengan model Florence-2 yang baik.
• Kemudian kami membuat contoh automodelforcausallm dengan memanggil fungsi .from_pretrained () memberikan nama model dan menetapkan trust_remote_code = benar, ini akan memuat turun model dari repositori HF.
• Kami kemudian menetapkan model ini kepada model penilaian dengan memanggil .eval () dan hantar ke GPU dengan memanggil fungsi .cuda ().
• Kemudian kami membuat contoh autoprocessor dengan memanggil .from_pretrained () dan memberikan nama model dan menetapkan peranti_map ke cuda.

Autoprocessor sangat mirip dengan autotokenizer. Tetapi kelas Autotokenizer memperkatakan teks dan teks. Manakala autoprocessor berurusan dengan kedua-dua teks dan tokenisasi imej, kerana Florence-2 berurusan dengan data imej, kami bekerjasama dengan autoprocessor.

Sekarang, marilah kita mengambil gambar:

 dari gambar import pil
imej = image.open ("/kandungan/pantai.jpg")

Di sini, kami telah mengambil gambar pantai.

Menghasilkan kapsyen

Sekarang kita akan memberikan imej ini kepada model bahasa penglihatan Florence-2 dan memintanya untuk menghasilkan kapsyen.

 Prompt = "<setertion>"
input = pemproses (teks = prompt, imej = imej, return_tensors = "pt"). ke ("cuda")
Generated_ids = Model.Generate (
    input_ids = input ["input_ids"],
    pixel_values ​​= input ["pixel_values"],
    max_new_tokens = 512,
    do_sample = palsu,
)
text_generations = processor.batch_decode (Generated_ids, 
skip_special_tokens = false) [0]

hasil = pemproses.post_process_generation (text_generations, 
tugas = prompt, image_size = (image.width, image.height))

cetak (hasil [prompt])</setertion>

• Kami mulakan dengan membuat petunjuk.
• Kemudian, kami memberikan kedua -dua prompt dan imej ke kelas pemproses dan mengembalikan sensor pytorch. Kami memberi mereka kepada GPU kerana model berada di GPU dan menyimpannya dalam input berubah -ubah.
• Pembolehubah input mengandungi input_ids, iaitu id token, dan nilai piksel untuk imej.
• Kemudian kami memanggil fungsi menghasilkan model dan memberikan ID input, nilai piksel imej. Kami menetapkan token yang dihasilkan maksimum kepada 512 menyimpan pensampelan untuk palsu dan menyimpan token yang dihasilkan dalam Generated_ids.
• Kemudian kami panggil fungsi .Batch_Decode pemproses memberikannya yang dihasilkan dan tetapkan bendera skip_special_tokens kepada palsu. Ini akan menjadi senarai dan oleh itu kita memerlukan elemen pertama senarai.
• Akhirnya, kami memaparkan teks yang dihasilkan dengan memanggil .post_process_generated dan memberikannya teks yang dihasilkan, jenis tugas, dan image_size sebagai tuple.

Menjalankan kod dan melihat gambar output di atas, kita melihat bahawa model telah menghasilkan kapsyen "sebuah kerusi payung dan lounge di pantai dengan lautan di latar belakang" untuk imej. Kapsyen imej di atas sangat pendek.

Memberikan arahan

Kita boleh mengambil langkah seterusnya ini dengan memberikan arahan lain seperti dan .

Kod untuk mencuba ini dapat dilihat di bawah:

 Prompt = "<pleterion_caption>"
input = pemproses (teks = prompt, imej = imej, return_tensors = "pt"). ke ("cuda")
Generated_ids = Model.Generate (
    input_ids = input ["input_ids"],
    pixel_values ​​= input ["pixel_values"],
    max_new_tokens = 512,
    do_sample = palsu,
)
text_generations = processor.batch_decode (Generated_ids, 
skip_special_tokens = false) [0]

hasil = pemproses.post_process_generation (text_generations, 
tugas = prompt, image_size = (image.width, image.height))

cetak (hasil [prompt])</pleterion_caption>

 Prompt = "<more_detailed_caption>"

input = pemproses (teks = prompt, imej = imej, return_tensors = "pt"). ke ("cuda")

Generated_ids = Model.Generate (
    input_ids = input ["input_ids"],
    pixel_values ​​= input ["pixel_values"],
    max_new_tokens = 512,
    do_sample = palsu,
)


text_generations = processor.batch_decode (Generated_ids, 
skip_special_tokens = false) [0]

hasil = pemproses.post_process_generation (text_generations, 
tugas = prompt, image_size = (image.width, image.height))

cetak (hasil [prompt])</more_detailed_caption>

Di sini, kami telah pergi dengan dan untuk jenis tugas, dan dapat melihat hasilnya setelah menjalankan kod dalam gambar di atas. The menghasilkan output "Dalam imej ini kita dapat melihat kerusi, meja, payung, air, kapal, pokok, bangunan dan langit dengan awan." dan prompt menghasilkan output "Payung oren berada di pantai. Terdapat kerusi lounge putih di sebelah payung. Terdapat dua bot di dalam air." Oleh itu, dengan kedua -dua arahan ini, kita boleh mendapatkan sedikit lebih mendalam dalam imej imej daripada prompt biasa.

Pengesanan Objek dengan Florence-2

Pengesanan objek adalah salah satu tugas yang terkenal dalam penglihatan komputer. Ia berkaitan dengan mencari beberapa objek yang diberikan imej. Dalam pengesanan objek, model mengenal pasti imej dan menyediakan koordinat x dan y kotak terikat di sekeliling objek. Model bahasa penglihatan Florence-2 sangat mampu mengesan objek yang diberikan imej.

Marilah kita mencuba ini dengan gambar di bawah:

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

Di sini, kami mempunyai imej van oren yang cerah di jalan raya dengan bangunan putih di latar belakang.

Memberi imej kepada model bahasa penglihatan Florence-2

Sekarang marilah kita berikan imej ini kepada model bahasa penglihatan Florence-2.

 Prompt = "<di>"

input = pemproses (teks = prompt, imej = imej, return_tensors = "pt"). ke ("cuda")

Generated_ids = Model.Generate (
    input_ids = input ["input_ids"],
    pixel_values ​​= input ["pixel_values"],
    max_new_tokens = 512,
    do_sample = palsu,
)
text_generations = processor.batch_decode (Generated_ids, 
skip_special_tokens = false) [0]

hasil = pemproses.post_process_generation (text_generations, 
tugas = prompt, image_size = (image.width, image.height))
</di>

Proses untuk pengesanan objek sangat mirip dengan tugas imej imej yang telah kami lakukan. Satu -satunya perbezaan di sini ialah kita menukar prompt ke makna pengesanan objek. Oleh itu, kami memberikan petunjuk ini bersama -sama dengan imej ke objek pemproses dan mendapatkan input tokenized. Kemudian kami memberikan input tokenized ini dengan nilai piksel imej kepada model bahasa penglihatan Florence-2 untuk menghasilkan output. Kemudian urcode output ini.

Output disimpan dalam hasil yang dinamakan pembolehubah. Keputusan pembolehubah adalah format {": {'bboxes': [[x1, y1, x2, y2], ...], 'label': ['label1', 'label2', ...]}}.

Melukis kotak sempadan pada gambar

Sekarang, kami akan menarik kotak -kotak yang terikat pada imej dengan koordinat yang kami ada.

 import matplotlib.pyplot sebagai PLT
import matplotlib.patches sebagai patch
Rajah, kapak = plt.subplots ()
ax.imshow (imej)
Untuk bbox, label dalam zip (hasil [prompt] ['bboxes'], hasil [prompt] ['label']):
    x1, y1, x2, y2 = bbox
    rect_box = patches.rectangle ((x1, y1), x2-x1, y2-y1, linewidth = 1, 
    edgecolor = 'r', faceColor = 'none')
    ax.add_patch (rect_box)
    PLT.Text (x1, y1, label, warna = 'putih', fontsize = 8, bbox = dict (faceColor = 'merah', alpha = 0.5))
ax.axis ('off')
plt.show ()

• Untuk melukis kotak sempadan segi empat tepat di sekeliling imej, kami bekerja dengan perpustakaan Matplotlib.
• Kami mulakan dengan membuat angka dan paksi dan kemudian kami memaparkan imej yang telah kami berikan kepada model bahasa penglihatan Florence-2.
• Di sini, kotak terikat bahawa output model adalah senarai yang mengandungi koordinat x, y, dan dalam output akhir, terdapat senarai kotak terikat, iaitu, setiap label mempunyai kotak terikat sendiri.
• Oleh itu, kami melangkah melalui senarai kotak terikat.
• Kemudian kami membongkar koordinat X dan Y dari kotak sempadan.
• Kemudian kami melukis segi empat tepat dengan koordinat yang kami telah membongkar dalam langkah terakhir.
• Akhirnya, kami menambalnya kepada imej yang sedang kami paparkan.
• Kami juga perlu menambah label ke kotak terikat untuk memberitahu bahawa kotak terikat mengandungi objek apa.
• Akhirnya, kami mengeluarkan paksi.

Menjalankan kod ini dan melihat gambar, kita melihat bahawa terdapat banyak kotak terikat yang dihasilkan oleh model bahasa penglihatan Florence-2 untuk imej van yang telah kami berikan kepadanya. Kami melihat bahawa model telah mengesan van, tingkap, dan roda dan dapat memberikan koordinat yang betul untuk setiap label.

Kapsyen ke landasan frasa

Seterusnya, kami mempunyai tugas yang dipanggil "kapsyen untuk frasa asas" yang menyokong model Florence-2. Apa model yang dilakukan, diberi imej dan kapsyen, tugas asas frasa adalah untuk mencari entiti / objek yang paling relevan yang disebutkan oleh frasa kata nama dalam kapsyen yang diberikan ke rantau dalam imej.

Kita boleh melihat tugas ini dengan kod di bawah:

 Prompt = "<cea caption_to_phrase_ground> van oren yang diletakkan di hadapan bangunan putih"
task_type = "<ceajtion_to_phrase_grounding>"
input = pemproses (teks = prompt, imej = imej, return_tensors = "pt"). ke ("cuda")
Generated_ids = Model.Generate (
    input_ids = input ["input_ids"],
    pixel_values ​​= input ["pixel_values"],
    max_new_tokens = 512,
    do_sample = palsu,
)
text_generations = processor.batch_decode (Generated_ids, 
skip_special_tokens = false) [0]
hasil = pemproses.post_process_generation (text_generations, 
tugas = tugas_type, image_size = (image.width, image.height))
</ceajtion_to_phrase_grounding></cea>

Di sini untuk mendapatkannya, kami memberikannya " van oren yang diletakkan di hadapan bangunan putih", di mana tugas itu adalah "" dan frasa adalah "van oren yang diletakkan di hadapan bangunan putih". Model Florence cuba menjana kotak terikat ke objek/entiti yang dapat diperoleh dari frasa yang diberikan ini. Marilah kita melihat output akhir dengan merancangnya.

 import matplotlib.pyplot sebagai PLT
import matplotlib.patches sebagai patch
Rajah, kapak = plt.subplots ()
ax.imshow (imej)
untuk bbox, label dalam zip (hasil [tugas_type] ['bboxes'], hasil [tugas_type] ['label']):
    x1, y1, x2, y2 = bbox
    rect_box = patches.rectangle ((x1, y1), x2-x1, y2-y1, linewidth = 1, 
    edgecolor = 'r', faceColor = 'none')
    ax.add_patch (rect_box)
    PLT.Text (x1, y1, label, warna = 'putih', fontsize = 8, bbox = dict (faceColor = 'merah', alpha = 0.5))
ax.axis ('off')
plt.show ()

Di sini kita melihat bahawa model bahasa penglihatan Florence-2 dapat mengekstrak dua entiti daripadanya. Satu adalah van oren dan yang lain adalah bangunan putih. Kemudian Florence-2 menjana kotak terikat untuk setiap entiti ini. Dengan cara ini, diberi kapsyen, model boleh mengekstrak entiti/objek yang relevan dari kapsyen yang diberikan dan dapat menjana kotak sempadan yang sepadan untuk objek tersebut.

Segmentasi dengan Florence-2

Segmentasi adalah proses, di mana imej diambil dan topeng dihasilkan untuk pelbagai bahagian imej. Di mana setiap topeng adalah objek. Segmentasi adalah tahap pengesanan objek seterusnya. Dalam pengesanan objek, kita hanya mencari lokasi imej dan menghasilkan kotak terikat. Tetapi dalam segmentasi, bukannya menghasilkan kotak sempadan segi empat tepat, kami menghasilkan topeng yang akan berada dalam bentuk objek, jadi ia seperti membuat topeng untuk objek itu. Ini berguna kerana bukan sahaja kita tahu lokasi objek, tetapi kita tahu bahkan bentuk objek. Dan bernasib baik, model bahasa penglihatan Florence-2 menyokong segmentasi.

Segmentasi pada imej

Kami akan mencuba segmentasi ke imej van kami.

 Prompt = "<rujukan_expression_segmentation> dua tayar hitam"
task_type = "<rujukan_expression_segmentation>"
input = pemproses (teks = prompt, imej = imej, return_tensors = "pt"). ke ("cuda")
Generated_ids = Model.Generate (
    input_ids = input ["input_ids"],
    pixel_values ​​= input ["pixel_values"],
    max_new_tokens = 512,
    do_sample = palsu,
)
text_generations = processor.batch_decode (Generated_ids, 
skip_special_tokens = false) [0]

hasil = pemproses.post_process_generation (text_generations, 
tugas = tugas_type, image_size = (image.width, image.height))
</rujukan_expression_segmentation></rujukan_expression_segmentation>

• Di sini, prosesnya sama dengan imej imej dan tugas pengesanan objek. Kami mulakan dengan memberikan petunjuk.
• Di sini prompt adalah " dua tayar hitam" di mana tugas itu adalah segmentasi.
• Segmentasi akan berdasarkan input teks yang disediakan, di sini ia adalah "dua tayar hitam".
• Jadi model Florence-2 akan cuba menjana topeng yang berkait rapat dengan input teks ini dan imej yang disediakan.

Di sini pembolehubah hasil akan menjadi format {": {'polygons': [[[polygon]], ...], 'label': [", ", ...]}} di mana setiap objek/topeng diwakili oleh senarai poligon.

Membuat topeng dan overlaying pada gambar sebenar

Sekarang, kita akan membuat topeng ini dan melapisi mereka pada imej sebenar supaya kita dapat memvisualisasikannya dengan lebih baik.

 salinan import
import numpy sebagai np
dari paparan import ipython.display
Dari Imej Import PIL, ImageDraw, ImageFont

output_image = copy.deepcopy (imej)
res = hasil [tugas_type]
Draw = ImageDRaw.Draw (output_image)
skala = 1
Untuk poligon, label dalam zip (res ['poligon'], res ['label']):
    fill_color = "biru"
    Untuk _polygon dalam poligon:
        _polygon = np.array (_polygon) .Reshape (-1, 2)
        jika 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="Cara Melaksanakan Tugas Penglihatan Komputer dengan Florence -2 - Analytics Vidhya" ></p><h4 id="Penjelasan"> Penjelasan</h4>

• Di sini, kita mulakan dengan mengimport pelbagai alat dari perpustakaan PIL untuk pemprosesan imej.
• Kami membuat salinan imej kami yang mendalam dan menyimpan nilai kunci "" dalam pembolehubah baru.
• Seterusnya, kami memuatkan imej dengan membuat contoh ImageDRaw dengan memanggil kaedah.Draw () dan memberikan salinan imej sebenar.
• Seterusnya, kami melangkah melalui zip poligon dan nilai label.
• Bagi setiap poligon, kami kemudian meleleh melalui poligon individu dengan nama _polygon dan membentuk semula. _Polygon kini merupakan senarai dimensi tinggi.
• Kami tahu bahawa _polygon mesti mempunyai sekurang -kurangnya 3 sisi supaya ia dapat disambungkan. Oleh itu, kami menyemak keadaan kesahihan ini, untuk melihat bahawa senarai _polygon mempunyai sekurang -kurangnya 3 item senarai.
• Akhirnya, kami melukis _polygon ini pada salinan imej sebenar dengan memanggil kaedah .polygon () dan memberikannya _polygon. Bersama -sama dengan itu kami memberikan warna garis besar dan warna mengisi.
• Jika model bahasa penglihatan Florence-2 menjana label untuk poligon tersebut, maka kita juga boleh menarik teks ini pada salinan imej sebenar dengan memanggil fungsi .teks () dan memberikan labelnya.
• Akhirnya, selepas melukis semua poligon yang dihasilkan oleh model Florence-2, kami mengeluarkan imej dengan memanggil fungsi paparan dari Perpustakaan Ipython.

Model bahasa penglihatan Florence-2 berjaya memahami pertanyaan kami tentang "dua tayar hitam" dan menyimpulkan bahawa imej itu mengandungi kenderaan dengan tayar hitam yang kelihatan. Model ini menghasilkan representasi poligon untuk tayar ini, yang bertopeng dengan warna biru. Model ini cemerlang dalam pelbagai tugas penglihatan komputer kerana data latihan yang kuat yang dikendalikan oleh pasukan Microsoft.

Kesimpulan

Florence-2 adalah model bahasa penglihatan yang dicipta dan dilatih dari bawah oleh pasukan Microsoft. Tidak seperti model bahasa penglihatan lain, Florence-2 melakukan pelbagai tugas penglihatan komputer, termasuk pengesanan objek, penangkapan imej, pengesanan objek frasa, OCR, segmentasi, dan kombinasi ini. Dalam panduan ini, kami telah melihat bagaimana untuk memuat turun model besar Florence-2 dan bagaimana untuk melaksanakan tugas penglihatan komputer yang berbeza dengan perubahan arahan dengan Florence-2.

Takeaways utama

• Model Florence-2 datang dalam dua saiz. Satu adalah varian asas yang merupakan versi parameter 0.23 bilion dan yang lain adalah varian besar yang merupakan versi parameter 0.7 bilion.
• Pasukan Microsoft telah melatih model Florence-2 dalam dataset FLD 5B, yang merupakan dataset imej yang mengandungi tugas imej yang berbeza yang dibuat oleh pasukan Microsoft.
• Florence-2 menerima imej bersama dengan prompt untuk input. Di mana petunjuk mentakrifkan jenis tugas model penglihatan Florence-2 harus dilakukan.
• Setiap tugas menghasilkan output yang berbeza dan semua output ini dihasilkan dalam format teks.
• Florence-2 adalah model sumber terbuka dengan lesen MIT, jadi boleh bekerja dengan aplikasi komersil.

Soalan yang sering ditanya

Q1. Apa itu Florence-2?

A. Florence-2 adalah model bahasa penglihatan yang dibangunkan oleh pasukan Microsoft dan dikeluarkan dalam dua saiz, parameter 0.23B, dan versi parameter 0.7B.

S2. Bagaimana autoprocessor berbeza dari autotokenizer?

A. Autotokenizer hanya boleh berurusan dengan data teks di mana ia menukar teks ke token. Sebaliknya, data pra-pemproses autoprosesor untuk model multi-modal yang termasuk data imej.

Q3. Apa itu FLD-5B?

A. FLD-5B adalah dataset imej yang dikendalikan oleh pasukan Microsoft. Ia mengandungi kira -kira 5.4 bilion imej imej untuk 126 juta imej.

Q4. Apakah output model Florence-2?

A. Florence-2 model output teks berdasarkan imej input dan teks input yang diberikan. Teks ini boleh menjadi kapsyen imej yang mudah atau ia dapat menyelaras kotak batas jika tugas itu adalah pengesanan objek atau segmentasi.

S5. Adakah sumber terbuka Florence-2?

A. Ya. Florence-2 dikeluarkan di bawah lesen MIT, sehingga menjadikannya sumber terbuka dan seseorang tidak perlu mengesahkan dengan Huggingface untuk bekerja dengan model ini.

Media yang ditunjukkan dalam artikel ini tidak dimiliki oleh Analytics Vidhya dan digunakan atas budi bicara penulis.

Atas ialah kandungan terperinci Cara Melaksanakan Tugas Penglihatan Komputer dengan Florence -2 - Analytics Vidhya. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!