Hugging Face's logo

Transformers documentation

ColPali

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Model ini dipublikasikan di HF papers pada 2024-06-27 dan disumbangkan ke Hugging Face Transformers pada 2024-12-17.

ColPali

ColPali adalah model yang dirancang untuk mengambil dokumen dengan menganalisis fitur visualnya. Berbeda dengan sistem tradisional yang sangat bergantung pada ekstraksi teks dan OCR, ColPali memperlakukan setiap halaman sebagai gambar. Model ini menggunakan Paligemma-3B untuk menangkap tidak hanya teks, tetapi juga tata letak, tabel, grafik, dan elemen visual lainnya untuk membuat embedding multi-vektor yang detail, yang dapat digunakan untuk pengambilan dengan menghitung skor kemiripan interaksi akhir pairwise. Hal ini memberikan pemahaman yang lebih komprehensif tentang dokumen dan memungkinkan pengambilan yang lebih efisien dan akurat.

Model ini disumbangkan oleh @tonywu71 (ILLUIN Technology) dan @yonigozlan (HuggingFace).

Anda dapat menemukan semua checkpoint ColPali asli di bawah koleksi Hf-native ColVision Models Vidore.

Klik pada model ColPali di bilah sisi kanan untuk melihat lebih banyak contoh cara menggunakan ColPali untuk pengambilan gambar.

retrieval gambar
import requests
import torch
from PIL import Image

from transformers import ColPaliForRetrieval, ColPaliProcessor


# Load the model and the processor
model_name = "vidore/colpali-v1.3-hf"

model = ColPaliForRetrieval.from_pretrained(
    model_name,
    device_map="auto",  # "cpu", "cuda", "xpu", or "mps" for Apple Silicon
)
processor = ColPaliProcessor.from_pretrained(model_name)

# The document page screenshots from your corpus
url1 = "https://upload.wikimedia.org/wikipedia/commons/8/89/US-original-Declaration-1776.jpg"
url2 = "https://upload.wikimedia.org/wikipedia/commons/thumb/4/4c/Romeoandjuliet1597.jpg/500px-Romeoandjuliet1597.jpg"

images = [
    Image.open(requests.get(url1, stream=True).raw),
    Image.open(requests.get(url2, stream=True).raw),
]

# The queries you want to retrieve documents for
queries = [
    "When was the United States Declaration of Independence proclaimed?",
    "Who printed the edition of Romeo and Juliet?",
]

# Process the inputs
inputs_images = processor(images=images).to(model.device)
inputs_text = processor(text=queries).to(model.device)

# Forward pass
with torch.no_grad():
    image_embeddings = model(**inputs_images).embeddings
    query_embeddings = model(**inputs_text).embeddings

# Score the queries against the images
scores = processor.score_retrieval(query_embeddings, image_embeddings)

print("Retrieval scores (query x image):")
print(scores)

Jika Anda mengalami masalah saat memuat gambar dengan PIL, Anda dapat menggunakan kode berikut untuk membuat gambar dummy:

images = [
    Image.new("RGB", (128, 128), color="white"),
    Image.new("RGB", (64, 32), color="black"),
]

Quantization mengurangi beban memori model besar dengan merepresentasikan bobot dalam presisi yang lebih rendah. Lihat ringkasan Quantization untuk backend quantization lain yang tersedia.

Contoh di bawah menggunakan bitsandbytes untuk mengkuantisasi bobot menjadi int4.

import requests
import torch
from PIL import Image

from transformers import BitsAndBytesConfig, ColPaliForRetrieval, ColPaliProcessor


model_name = "vidore/colpali-v1.3-hf"

# 4-bit quantization configuration
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_use_double_quant=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.float16,
)

model = ColPaliForRetrieval.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map="auto",
)

processor = ColPaliProcessor.from_pretrained(model_name)

url1 = "https://upload.wikimedia.org/wikipedia/commons/8/89/US-original-Declaration-1776.jpg"
url2 = "https://upload.wikimedia.org/wikipedia/commons/thumb/4/4c/Romeoandjuliet1597.jpg/500px-Romeoandjuliet1597.jpg"

images = [
    Image.open(requests.get(url1, stream=True).raw),
    Image.open(requests.get(url2, stream=True).raw),
]

queries = [
    "When was the United States Declaration of Independence proclaimed?",
    "Who printed the edition of Romeo and Juliet?",
]

# Process the inputs
inputs_images = processor(images=images, return_tensors="pt").to(model.device)
inputs_text = processor(text=queries, return_tensors="pt").to(model.device)

# Forward pass
with torch.no_grad():
    image_embeddings = model(**inputs_images).embeddings
    query_embeddings = model(**inputs_text).embeddings

# Score the queries against the images
scores = processor.score_retrieval(query_embeddings, image_embeddings)

print("Retrieval scores (query x image):")
print(scores)

Catatan

  • score_retrieval() mengembalikan tensor 2D di mana dimensi pertama adalah jumlah query dan dimensi kedua adalah jumlah gambar. Skor yang lebih tinggi menunjukkan kemiripan yang lebih besar antara query dan gambar.

ColPaliConfig

kelas transformers.ColPaliConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevlm_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneembedding_dim: int = 128 )

Parameter

  • vlm_config (Union[dict, ~configuration_utils.PreTrainedConfig], opsional) — Objek config atau dictionary dari backbone vision-language.
  • embedding_dim (int, opsional, default 128) — Dimensi dari embedding dan hidden states.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari ColpaliModel. Kelas ini digunakan untuk membuat instans model Colpali berdasarkan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari vidore/colpali-v1.2

Objek konfigurasi mewarisi dari PreTrainedConfig dan dapat digunakan untuk mengontrol output model. Baca dokumentasi dari PreTrainedConfig untuk informasi lebih lanjut.

Contoh:

from transformers.models.colpali import ColPaliConfig, ColPaliForRetrieval

config = ColPaliConfig()
model = ColPaliForRetrieval(config)

ColPaliProcessor

kelas transformers.ColPaliProcessor

< >

( image_processor = Nonetokenizer = Nonechat_template = Nonevisual_prompt_prefix: str = 'Describe the image.'query_prefix: str = 'Question: ' )

Parameter

  • image_processor (SiglipImageProcessor) — Prosesor gambar adalah input yang wajib.
  • tokenizer (tokenizer_class) — Tokenizer adalah input yang wajib.
  • chat_template (str) — Template Jinja untuk mengubah daftar pesan dalam chat menjadi string yang dapat ditokenisasi.
  • visual_prompt_prefix (str, opsional, defaultnya "Describe the image.") — String yang ditokenisasi dan ditambahkan di depan token gambar.
  • query_prefix (str, opsional, defaultnya "Question -- "): Awalan yang akan digunakan untuk query.

Membangun ColPaliProcessor yang membungkus image processor dan tokenizer menjadi satu processor.

ColPaliProcessor menyediakan semua fungsionalitas dari SiglipImageProcessor dan tokenizer_class. Lihat ~SiglipImageProcessor dan ~tokenizer_class untuk informasi lebih lanjut.

__call__

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Nonetext: str | list[str] | list[list[str]] = None**kwargs: *<class 'transformers.models.colpali.processing_colpali.ColPaliProcessorKwargs'> ) → BatchFeature

Parameter

  • images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], opsional) — Gambar yang akan dipreprocess. Mengharapkan satu gambar atau batch gambar dengan nilai piksel berkisar dari 0 hingga 255. Jika mengirimkan gambar dengan nilai piksel antara 0 dan 1, atur do_rescale=False.
  • text (Union[str, list[str], list[list[str]]], opsional) — Sequens atau batch dari sequens yang akan dienkod. Setiap sequens dapat berupa string atau daftar string (string yang sudah dipretokenisasi). Jika Anda memasukkan input yang sudah dipretokenisasi, atur is_split_into_words=True untuk menghindari ambiguitas dengan input yang di-batch.
  • return_tensors (str atau TensorType, opsional) — Jika diset, akan mengembalikan tensor dari framework tertentu. Nilai yang dapat diterima adalah:
    • 'pt': Mengembalikan objek PyTorch torch.Tensor.
    • 'np': Mengembalikan objek NumPy np.ndarray.
  • **kwargs (ProcessingKwargs, opsional) — Opsi pemrosesan tambahan untuk setiap modalitas (teks, gambar, video, audio). Parameter spesifik model tercantum di atas; lihat kelas TypedDict untuk daftar lengkap argumen yang didukung.

Mengembalikan

BatchFeature

BatchFeature dengan bidang berikut:

  • input_ids — Daftar token id yang akan diberikan ke model. Dikembalikan ketika text bukan None. Jika suffix disediakan, input_ids juga akan berisi input id dari suffix.
  • attention_mask — Daftar indeks yang menentukan token mana yang harus diperhatikan oleh model (ketika return_attention_mask=True atau jika “attention_mask” ada di self.model_input_names dan jika text bukan None).
  • pixel_values — Nilai piksel yang akan diberikan ke model. Dikembalikan ketika images bukan None.
  • labels — Label yang kompatibel dengan pelatihan jika suffix bukan None

ColPaliForRetrieval

kelas transformers.ColPaliForRetrieval

< >

( config: ColPaliConfig )

Parameter

  • config (ColPaliConfig) — Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode from_pretrained() untuk memuat bobot model.

Arsitektur ColPali memanfaatkan VLM untuk membangun embedding multi-vektor yang efisien langsung dari gambar dokumen (“screenshot”) untuk pengambilan dokumen. Model dilatih untuk memaksimalkan kemiripan antara embedding dokumen ini dan embedding kueri yang sesuai, menggunakan metode interaksi akhir yang diperkenalkan dalam ColBERT.

Menggunakan ColPali menghilangkan kebutuhan akan pipeline pengenalan tata letak dan OCR yang berpotensi kompleks dan rapuh, dengan satu model yang dapat mempertimbangkan konten teks dan visual (tata letak, grafik, dll.) dari sebuah dokumen.

ColPali merupakan bagian dari keluarga model ColVision, yang pertama kali diperkenalkan dalam makalah berikut: ColPali: Efficient Document Retrieval with Vision Language Models.

Model ini mewarisi dari PreTrainedModel. Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran embedding input, memangkas kepala, dll.)

Model ini juga merupakan subclass dari torch.nn.Module PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.FloatTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → ColPaliForRetrievalOutput or tuple(torch.FloatTensor)

Parameter

  • input_ids (torch.LongTensor dengan bentuk (batch_size, sequence_length), opsional) — Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default.

    Indeks dapat diperoleh menggunakan AutoTokenizer. Lihat PreTrainedTokenizer.encode() dan PreTrainedTokenizer.call() untuk detailnya.

    Apa itu input ID?

  • pixel_values (torch.FloatTensor dengan bentuk (batch_size, num_channels, image_size, image_size), opsional) — Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan image_processor_class. Lihat image_processor_class.__call__ untuk detailnya (processor_class menggunakan image_processor_class untuk memproses gambar).
  • attention_mask (torch.Tensor dengan bentuk (batch_size, sequence_length), opsional) — Mask untuk menghindari eksekusi attention pada indeks token padding. Nilai mask dipilih dari [0, 1]:
    • 1 untuk token yang tidak dimasker,
    • 0 untuk token yang dimasker.

    Apa itu attention mask?

Mengembalikan

ColPaliForRetrievalOutput atau tuple(torch.FloatTensor)

ColPaliForRetrievalOutput atau tuple dari torch.FloatTensor (jika return_dict=False diteruskan atau ketika config.return_dict=False) yang terdiri dari berbagai elemen tergantung pada konfigurasi (None) dan input.

Metode forward ColPaliForRetrieval menimpa metode khusus __call__.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance Module setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

  • loss (torch.FloatTensor dengan bentuk (1,), opsional, dikembalikan saat labels disediakan) — Loss pemodelan bahasa (untuk prediksi token berikutnya).

  • embeddings (torch.FloatTensor dengan bentuk (batch_size, sequence_length, hidden_size)) — Embeddings dari model.

  • past_key_values (Cache, opsional, dikembalikan saat use_cache=True dilewatkan atau saat config.use_cache=True) — Ini adalah instance Cache. Untuk detail lebih lanjut, lihat panduan kv cache kami.

    Berisi hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention) yang dapat digunakan (lihat input past_key_values) untuk mempercepat decoding berurutan.

  • hidden_states (tuple[torch.FloatTensor], opsional, dikembalikan saat output_hidden_states=True dilewatkan atau saat config.output_hidden_states=True) — Tuple dari torch.FloatTensor (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk (batch_size, sequence_length, hidden_size).

    Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.

  • attentions (tuple[torch.FloatTensor], opsional, dikembalikan saat output_attentions=True dilewatkan atau saat config.output_attentions=True) — Tuple dari torch.FloatTensor (satu untuk setiap layer) dengan bentuk (batch_size, num_heads, sequence_length, sequence_length).

    Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala perhatian diri (self-attention).

  • image_hidden_states (torch.FloatTensor, opsional) — Sebuah torch.FloatTensor berukuran (batch_size, num_images, sequence_length, hidden_size). image_hidden_states dari model yang dihasilkan oleh vision encoder setelah memproyeksikan last hidden state.

Update on GitHub

←ColModernVBert ColQwen2→