Paligemma 2 Mix: Panduan dengan Projek Demo OCR

Paligemma 2 Mix adalah model AI multimodal yang dibangunkan oleh Google. Ia adalah versi yang lebih baik dari Model Bahasa Paligemma Vision (VLM), mengintegrasikan keupayaan maju dari model SIGLIP Vision dan model bahasa Gemma 2.

Dalam tutorial ini, saya akan menerangkan cara menggunakan campuran Paligemma 2 untuk membina pengimbas rang undang-undang AI dan penganalisis perbelanjaan yang mampu:

• Mengekstrak dan mengkategorikan perbelanjaan dari resit bil.
• Melaksanakan Pengiktirafan Watak Optik (OCR) untuk mendapatkan maklumat utama.
• meringkaskan perbelanjaan berdasarkan imej yang disediakan.

Walaupun tumpuan kami adalah untuk membina alat Insights Financial, anda boleh menggunakan apa yang anda pelajari di blog ini untuk meneroka kes penggunaan lain Paligemma 2 campuran, seperti segmentasi imej, pengesanan objek, dan menjawab soalan.

Apakah campuran Paligemma 2?

Paligemma 2 Mix adalah model bahasa-bahasa lanjutan (VLM) yang memproses kedua-dua imej dan teks sebagai input dan menghasilkan output berasaskan teks. Ia direka untuk mengendalikan pelbagai tugas AI multimodal semasa menyokong pelbagai bahasa.

Paligemma 2 direka untuk pelbagai tugas-tugas bahasa penglihatan, termasuk imej dan tajuk video pendek, menjawab soalan visual, pengiktirafan aksara optik (OCR), pengesanan objek, dan segmentasi.

Sumber imej yang digunakan dalam rajah: Google

model campuran Paligemma 2 direka untuk:

Imej & Kapsyen Video Pendek: Menjana kapsyen yang tepat dan konteks untuk imej statik dan video pendek.

• Soalan Visual Menjawab (VQA): Menganalisis imej dan menjawab soalan berasaskan teks berdasarkan kandungan visual.
• Pengiktirafan watak optik (OCR): Mengekstrak dan menafsirkan teks dari imej, menjadikannya berguna untuk dokumen, resit, dan bahan yang diimbas.
• Pengesanan Objek & Segmentasi: Ia Mengenalpasti, Label, dan Segmen Objek dalam Imej untuk Analisis Berstruktur.
• Sokongan pelbagai bahasa: Model ini juga membolehkan penjanaan teks dan pemahaman dalam pelbagai bahasa untuk aplikasi global.
Anda boleh mendapatkan lebih banyak maklumat mengenai model campuran Paligemma 2 dalam artikel pelepasan rasmi. 

Gambaran Keseluruhan Projek: Pengimbas Bill dan Penganalisis Perbelanjaan dengan Paligemma 2 Mix

mari kita menggariskan langkah -langkah utama yang akan kita ambil:

1. Muatkan dan sediakan dataset: Proses bermula dengan memuatkan dan menyediakan imej resit sebagai input.
2. Mulakan model campuran Paligemma 2: Kami mengkonfigurasi dan memuatkan model untuk memproses tugas bahasa penglihatan.
3. Proses Imej Input: Kemudian, tukar imej ke format yang sesuai (RGB) dan sediakannya untuk analisis.
4. Ekstrak Maklumat Utama: Melaksanakan Pengiktirafan Watak Optik (OCR) untuk mendapatkan jumlah keseluruhan.
5. mengkategorikan perbelanjaan: mengklasifikasikan pembelian ke dalam kategori seperti runcit, pakaian, elektronik, dan lain -lain.
6. Menjana wawasan perbelanjaan: Kami meringkaskan perbelanjaan yang dikategorikan dan menghasilkan carta pengedaran perbelanjaan.
7. Bina antara muka Vadio Interaktif: Akhirnya, kami membuat UI di mana pengguna boleh memuat naik pelbagai bil, mengekstrak data, dan menganalisis perbelanjaan secara visual.

Langkah 1: Prasyarat

Sebelum kita mula, mari kita pastikan bahawa kita mempunyai alat dan perpustakaan berikut yang dipasang:

• python 3.8
• obor
• Transformers
• pil
• Matplotlib
• Gradio

jalankan arahan berikut untuk memasang kebergantungan yang diperlukan:

pip install gradio -U bitsandbytes -U transformers -q

Setelah kebergantungan di atas dipasang, jalankan arahan import berikut:

import gradio as gr
import torch
import pandas as pd
import matplotlib.pyplot as plt
from transformers import PaliGemmaForConditionalGeneration, PaliGemmaProcessor, BitsAndBytesConfig
from transformers import BitsAndBytesConfig
from PIL import Image
import re

Langkah 2: Model Inisialisasi

Kami mengkonfigurasi dan memuatkan model campuran Paligemma 2 dengan kuantisasi untuk mengoptimumkan prestasi. Untuk demo ini, kami akan menggunakan model parameter 10B dengan resolusi imej input 448 x 448. Anda memerlukan minimum T4 GPU dengan memori 40GB (konfigurasi COLAB) untuk menjalankan model ini. 

device = "cuda" if torch.cuda.is_available() else "cpu"
# Model setup
model_id = "google/paligemma2-10b-mix-448" 
bnb_config = BitsAndBytesConfig(
    load_in_8bit=True,  # Change to load_in_4bit=True for even lower memory usage
    llm_int8_threshold=6.0,
)

# Load model with quantization
model = PaliGemmaForConditionalGeneration.from_pretrained(
    model_id, quantization_config=bnb_config
).eval()

# Load processor
processor = PaliGemmaProcessor.from_pretrained(model_id)
# Print success message
print("Model and processor loaded successfully!")

kuantisasi Bitsandbytes membantu mengurangkan penggunaan memori sambil mengekalkan prestasi, menjadikannya mungkin untuk menjalankan model besar pada sumber GPU yang terhad. Dalam pelaksanaan ini, kami menggunakan kuantisasi 4-bit untuk mengoptimumkan kecekapan memori.

Kami memuatkan model menggunakan kelas paligemmaforconditionalgeneration dari Perpustakaan Transformers dengan lulus dalam Model ID dan Konfigurasi Kuantisasi. Begitu juga, kita memuatkan pemproses, yang memproses input ke dalam tensor sebelum menyampaikannya ke model.

Langkah 3: Pemprosesan Imej

Setelah shard model dimuatkan, kami memproses imej sebelum menyampaikannya ke model untuk mengekalkan keserasian format imej dan mendapatkan keseragaman. Kami menukar imej ke format RGB:

def ensure_rgb(image: Image.Image) -> Image.Image:
    if image.mode != "RGB":
        image = image.convert("RGB")
    return image

Sekarang, imej kami siap untuk kesimpulan.

Langkah 4: Kesimpulan dengan Paligemma

Sekarang, kami menyediakan fungsi utama untuk menjalankan kesimpulan dengan model. Fungsi ini mengambil imej input dan soalan, menggabungkannya ke dalam arahan, dan menyerahkannya kepada model melalui pemproses untuk kesimpulan.

def ask_model(image: Image.Image, question: str) -> str:
    prompt = f"<image> answer en {question}"
    inputs = processor(text=prompt, images=image, return_tensors="pt").to(device)
    with torch.inference_mode():
        generated_ids = model.generate(
            **inputs,
            max_new_tokens=50,
            do_sample=False
        )
    result = processor.batch_decode(generated_ids, skip_special_tokens=True)
    return result[0].strip()

Langkah 5: Mengekstrak Maklumat Utama

Sekarang kita mempunyai fungsi utama siap, kita akan bekerja di sebelahnya untuk mengekstrak parameter utama dari imej -dalam kes kita, ini adalah jumlah keseluruhan dan kategori barangan.

pip install gradio -U bitsandbytes -U transformers -q

fungsi Extract_Total_amount () memproses imej untuk mengekstrak jumlah keseluruhan dari resit menggunakan OCR. Ia membina pertanyaan (soalan) yang mengarahkan model untuk mengekstrak hanya nilai berangka, dan kemudian ia memanggil fungsi Ask_model () untuk menghasilkan respons dari model. 

import gradio as gr
import torch
import pandas as pd
import matplotlib.pyplot as plt
from transformers import PaliGemmaForConditionalGeneration, PaliGemmaProcessor, BitsAndBytesConfig
from transformers import BitsAndBytesConfig
from PIL import Image
import re

Fungsi Categorize_goods () mengklasifikasikan jenis barangan dalam imej dengan mendorong model dengan penyenaraian soalan yang telah ditetapkan yang mungkin kategori: runcit, pakaian, elektronik, atau lain -lain. Fungsi Ask_model () kemudian memproses imej dan mengembalikan respons teks. Sekiranya tindak balas yang diproses sepadan dengan mana -mana kategori sah yang telah ditetapkan, ia mengembalikan kategori itu -sebaik sahaja, ia mungkir kepada kategori "Lain".

Langkah 6: Menganalisis maklumat

Kami mempunyai semua fungsi utama siap, jadi mari kita menganalisis output.

device = "cuda" if torch.cuda.is_available() else "cpu"
# Model setup
model_id = "google/paligemma2-10b-mix-448" 
bnb_config = BitsAndBytesConfig(
    load_in_8bit=True,  # Change to load_in_4bit=True for even lower memory usage
    llm_int8_threshold=6.0,
)

# Load model with quantization
model = PaliGemmaForConditionalGeneration.from_pretrained(
    model_id, quantization_config=bnb_config
).eval()

# Load processor
processor = PaliGemmaProcessor.from_pretrained(model_id)
# Print success message
print("Model and processor loaded successfully!")

Fungsi di atas mencipta carta pai untuk memvisualisasikan pengagihan perbelanjaan merentasi kategori yang berbeza. Sekiranya tiada data perbelanjaan yang sah, ia menghasilkan angka kosong dengan mesej yang menunjukkan "tiada data perbelanjaan." Jika tidak, ia mewujudkan carta pai dengan label kategori dan nilai peratusan, memastikan visualisasi yang berkadar dan sejajar.

Langkah 6: Menganalisis beberapa bil serentak

Kami biasanya mempunyai banyak bil untuk dianalisis, jadi mari kita buat fungsi untuk memproses semua bil kami secara serentak.

def ensure_rgb(image: Image.Image) -> Image.Image:
    if image.mode != "RGB":
        image = image.convert("RGB")
    return image

Untuk menganalisis pelbagai bil sekaligus, kami melakukan langkah -langkah berikut:

1. Inisialisasi Penyimpanan: Kami membuat senarai untuk menyimpan hasil dan imej, tetapkan total_spending ke 0, dan tentukan kamus untuk jumlah kategori yang bijak.
2. Proses setiap rang undang -undang:

• Buka dan tukar imej ke RGB.
• Masukkan imej ke senarai.
• Ekstrak jumlah keseluruhan dari resit.
• mengkategorikan barang dalam resit.
• Kemas kini jumlah perbelanjaan dan jumlah kategori yang bijak.
• Simpan data yang diekstrak dalam senarai hasil.

3. Menjana pandangan: Kami membuat carta pai pengedaran perbelanjaan bersama -sama dengan ringkasan jumlah perbelanjaan.
4. Hasil pulangan: Akhirnya, kami mengembalikan senarai imej, satu data ringkasan Rang Undang -Undang, ringkasan perbelanjaan jumlah, dan carta perbelanjaan.

Langkah 7: Bina antara muka Gradio

Sekarang, kita mempunyai semua fungsi logik utama di tempatnya. Seterusnya, kami bekerja untuk membina UI interaktif dengan Gradio.

def ask_model(image: Image.Image, question: str) -> str:
    prompt = f"<image> answer en {question}"
    inputs = processor(text=prompt, images=image, return_tensors="pt").to(device)
    with torch.inference_mode():
        generated_ids = model.generate(
            **inputs,
            max_new_tokens=50,
            do_sample=False
        )
    result = processor.batch_decode(generated_ids, skip_special_tokens=True)
    return result[0].strip()

Kod di atas mencipta UI Gradio berstruktur dengan pemuat naik fail untuk pelbagai imej dan butang hantar untuk mencetuskan pemprosesan. Setelah penyerahan, imej bil yang dimuat naik dipaparkan dalam galeri, data yang diekstrak ditunjukkan dalam jadual, jumlah perbelanjaan diringkaskan dalam teks, dan carta pai pengedaran perbelanjaan dijana. 

Fungsi ini menghubungkan input pengguna ke fungsi process_multiple_bills (), memastikan pengekstrakan dan visualisasi data lancar. Akhirnya, fungsi demo.launch () memulakan aplikasi Gradio untuk interaksi masa nyata.

Saya juga mencuba demo ini dengan dua bil berasaskan imej (invois membeli-belah Amazon) dan mendapat hasil berikut.

NOTA: VLMS merasa sukar untuk mengekstrak nombor, yang mungkin membawa kepada keputusan yang salah pada masa -masa. Sebagai contoh, ia mengekstrak jumlah yang salah untuk bil kedua di bawah. Ini boleh dibetulkan dengan menggunakan model yang lebih besar atau hanya menyempurnakan yang sedia ada.

Kesimpulan

Dalam tutorial ini, kami membina pengimbas rang undang-undang yang berkuasa AI menggunakan campuran Paligemma 2, yang dapat membantu kami mengekstrak dan mengkategorikan perbelanjaan kami dari resit. Kami menggunakan keupayaan bahasa Paligemma 2 Mix untuk OCR dan klasifikasi untuk menganalisis perbelanjaan dengan mudah. Saya menggalakkan anda menyesuaikan tutorial ini untuk kes penggunaan anda sendiri. 

Atas ialah kandungan terperinci Paligemma 2 Mix: Panduan dengan Projek Demo OCR. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!