Transformers documentation
MiniCPM-V
Este modelo foi publicado no HF papers em 2025-09-16 e contribuído para o Hugging Face Transformers em 2026-04-28.
MiniCPM-V
MiniCPM-V é uma série de modelos de linguagem grandes multimodais eficientes desenvolvidos pela OpenBMB. A arquitetura do MiniCPM-V 4.6 utiliza um codificador de visão SigLIP com um mesclador de atenção por janela e um backbone de modelo de linguagem Qwen3.5, suportando os modos de downsampling visual 4x e 16x.
Este modelo foi contribuído por OpenBMB. O código original pode ser encontrado aqui.
Exemplo de uso
Inferência com Pipeline
from transformers import pipeline
messages = [
{
"role": "user",
"content": [
{
"type": "image",
"image": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg",
},
{"type": "text", "text": "Describe this image."},
],
},
]
pipe = pipeline("image-text-to-text", model="openbmb/MiniCPM-V-4_6")
outputs = pipe(text=messages, max_new_tokens=50, return_full_text=False)
outputs[0]["generated_text"]Inferência em uma única imagem
O modelo foi treinado com um formato de prompt específico para conversas. Use
processor.apply_chat_template(my_conversation_dict)para formatar corretamente seus prompts.
from transformers import AutoProcessor, AutoModelForImageTextToText
model_checkpoint = "openbmb/MiniCPM-V-4_6"
processor = AutoProcessor.from_pretrained(model_checkpoint)
model = AutoModelForImageTextToText.from_pretrained(model_checkpoint, device_map="auto")
messages = [
{
"role": "user",
"content": [
{"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
{"type": "text", "text": "Describe this image."},
],
}
]
inputs = processor.apply_chat_template(
messages, add_generation_prompt=True, tokenize=True,
return_dict=True, return_tensors="pt",
).to(model.device, dtype=model.dtype)
output = model.generate(**inputs, max_new_tokens=100)
decoded_output = processor.decode(output[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True)
print(decoded_output)Modo de redução de amostragem
MiniCPM-V 4.6 suporta dois modos de redução de amostragem visual:
- 16x (padrão): Downsampling mais agressivo, menos tokens visuais, inferência mais rápida.
- 4x: Menos redução de amostragem, mais tokens visuais, melhor para tarefas ricas em detalhes.
Você pode alterar o modo de redução de amostragem em tempo de execução passando downsample_mode via processor_kwargs e para model.generate:
inputs = processor.apply_chat_template(
messages, add_generation_prompt=True, tokenize=True,
return_dict=True, return_tensors="pt",
processor_kwargs={"downsample_mode": "4x"},
).to(model.device, dtype=model.dtype)
output = model.generate(**inputs, max_new_tokens=100, downsample_mode="4x")Modo de raciocínio
O modelo suporta um modo de raciocínio controlado por enable_thinking no modelo de chat. Quando ativado, o modelo gera um raciocínio interno antes de fornecer a resposta final:
inputs = processor.apply_chat_template(
messages, add_generation_prompt=True, tokenize=True,
return_dict=True, return_tensors="pt",
enable_thinking=True,
).to(model.device, dtype=model.dtype)
output = model.generate(**inputs, max_new_tokens=1024)Para desativar o raciocínio (padrão para avaliação):
inputs = processor.apply_chat_template(
messages, add_generation_prompt=True, tokenize=True,
return_dict=True, return_tensors="pt",
enable_thinking=False,
).to(model.device, dtype=model.dtype)Backend de processamento de imagem
O MiniCPM-V 4.6 oferece dois backends de processamento de imagem:
- torchvision (padrão): usa
torchvision.transformspara redimensionar imagens. - pil: Usa
PIL.Image.resize, correspondendo à implementação original.
Para usar o backend PIL:
from transformers import AutoProcessor, AutoImageProcessor
processor = AutoProcessor.from_pretrained(model_checkpoint)
processor.image_processor = AutoImageProcessor.from_pretrained(model_checkpoint, backend="pil")Inferência de vídeo
O MiniCPM-V 4.6 suporta a compreensão de vídeos.
messages = [
{
"role": "user",
"content": [
{"type": "video", "video": "path/to/video.mp4"},
{"type": "text", "text": "Describe what happens in this video."},
],
}
]
inputs = processor.apply_chat_template(
messages, add_generation_prompt=True, tokenize=True,
return_dict=True, return_tensors="pt",
).to(model.device, dtype=model.dtype)
output = model.generate(**inputs, max_new_tokens=200)
decoded_output = processor.decode(output[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True)
print(decoded_output)Se você já possui a string do prompt renderizada, pode chamar processor(text=..., videos=[...]) diretamente, em vez disso.
MiniCPMV4_6Config
classe transformers.MiniCPMV4_6Config
< source >( 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 = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonevision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneinsert_layer_id: int = 6image_size: int = 448drop_vision_last_layer: bool = Falseimage_token_id: int | None = Nonevideo_token_id: int | None = Nonetie_word_embeddings: bool = Falsedownsample_mode: str = '16x'merge_kernel_size: tuple[int, int] | list[int] = (2, 2)merger_times: int = 1 )
Parâmetros
- text_config (
Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — O objeto de configuração ou dicionário do backbone de texto. - vision_config (
Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — O objeto de configuração ou dicionário do backbone de visão. - insert_layer_id (
int, opcional, padrão 6) — Índice da camada do codificador de visão após a qual o mesclador de atenção em janela é aplicado. - image_size (
int, opcional, padrão 448) — Resolução base para o pré-processamento de imagens. - drop_vision_last_layer (
bool, opcional, padrãoFalse) — Indica se a última camada do codificador de visão deve ser removida. - image_token_id (
int, opcional) — ID do token usado como marcador de posição para a imagem. - video_token_id (
int, opcional) — ID do token usado como marcador de posição para o vídeo. - tie_word_embeddings (
bool, opcional, padrãoFalse) — Se deve vincular as embeddings de pesos de acordo com o mapeamentotied_weights_keysdo modelo. - downsample_mode (
str, opcional, padrão"16x") — Proporção de downsampling de tokens visuais."4x"mantém 4× mais tokens. - merge_kernel_size (
tuple[int, int], opcional, padrão(2, 2)) — Tamanho do kernel(h, w)para mesclar patches visuais adjacentes no Merger. - merger_times (
int, opcional, padrão 1) — Número de rodadas iterativas de mesclagem no Merger.
Esta é a classe de configuração para armazenar a configuração de um MiniCPMV4_6Model. Ela é usada para instanciar um modelo Minicpmv4 6 de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do openbmb/MiniCPM-V-4.6
Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.
MiniCPMV4_6VisionConfig
classe transformers.MiniCPMV4_6VisionConfig
< source >( 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 = Nonehidden_size: int = 768intermediate_size: int = 3072num_hidden_layers: int = 12num_attention_heads: int = 12num_channels: int = 3image_size: int | list[int] | tuple[int, int] = 224patch_size: int | list[int] | tuple[int, int] = 16hidden_act: str = 'gelu_pytorch_tanh'layer_norm_eps: float = 1e-06attention_dropout: float | int = 0.0insert_layer_id: int = 6window_kernel_size: tuple[int, int] | list[int] = (2, 2) )
Parâmetros
- hidden_size (
int, opcional, padrão768) — Dimensão das representações ocultas. - intermediate_size (
int, opcional, padrão3072) — Dimensão das representações do MLP. - num_hidden_layers (
int, opcional, padrão12) — Número de camadas ocultas no decodificador do Transformer. - num_attention_heads (
int, opcional, padrão12) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. - num_channels (
int, opcional, padrão3) — O número de canais de entrada. - image_size (
Union[int, list[int], tuple[int, int]], opcional, padrão224) — O tamanho (resolução) de cada imagem. - patch_size (
Union[int, list[int], tuple[int, int]], opcional, padrão16) — O tamanho (resolução) de cada patch. - hidden_act (
str, opcional, padrãogelu_pytorch_tanh) — A função de ativação não linear (função ou string) no decodificador. Por exemplo,"gelu","relu","silu", etc. - layer_norm_eps (
float, opcional, padrão1e-06) — O epsilon usado pelas camadas de normalização de camada. - attention_dropout (
Union[float, int], opcional, padrão0.0) — A taxa de dropout para as probabilidades de atenção. - insert_layer_id (
int, opcional, padrão 6) — Índice da camada do codificador de visão após a qual o mesclador de atenção em janela é aplicado. - window_kernel_size (
tuple[int, int], opcional, padrão(2, 2)) — Tamanho da janela(h, w)para o mesclador de atenção por janela intermediário.
Esta é a classe de configuração para armazenar a configuração de um MiniCPMV4_6Model. Ela é usada para instanciar um modelo Minicpmv4 6 de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do openbmb/MiniCPM-V-4.6
Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.
MiniCPMV4_6Model
classe transformers.MiniCPMV4_6Model
< source >( config: MiniCPMV4_6Config )
Parâmetros
- config (MiniCPMV4_6Config) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
O modelo MiniCPMV4_6, que consiste em um backbone de visão e um modelo de linguagem, sem uma cabeça de modelagem de linguagem.
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Nonetarget_sizes: typing.Optional[torch.IntTensor] = Nonepixel_values_videos: typing.Optional[torch.Tensor] = Nonetarget_sizes_videos: typing.Optional[torch.IntTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: list[torch.Tensor] | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Nonedownsample_mode: str | None = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPast or tuple(torch.Tensor)
Parâmetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
- pixel_values (
torch.Tensor, opcional) — Patches de valores de pixels para imagens, empacotados pelo NaViT. - target_sizes (
torch.IntTensor, opcional) — Altura e largura (em patches) para cada imagem. - pixel_values_videos (
torch.Tensor, opcional) — Patches de valores de pixel para quadros de vídeo, empacotados pelo NaViT. - target_sizes_videos (
torch.IntTensor, opcional) — Altura e largura (em patches) para cada quadro de vídeo. - attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em[0, 1]:- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo[0, config.n_positions - 1]. - past_key_values (
list[torch.Tensor], opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nospast_key_valuesretornados pelo modelo em uma etapa anterior da decodificação, quandouse_cache=Trueouconfig.use_cache=True.Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum
past_key_valuesfor passado, DynamicCache será inicializado por padrão.O modelo sairá no mesmo formato de cache que é fornecido como entrada.
Se
past_key_valuesforem usados, espera-se que o usuário insira apenas osinput_idsnão processados (aqueles que não têm seus estados de chave e valor passados fornecidos a este modelo) com a forma(batch_size, unprocessed_length), em vez de todos osinput_idscom a forma(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - use_cache (
bool, opcional) — Se definido comoTrue, os estados de chave-valorpast_key_valuessão retornados e podem ser usados para acelerar a decodificação (vejapast_key_values). - downsample_mode (
str, opcional) —"4x"mantém 4x mais tokens visuais; o padrão"16x"aplica a mesclagem completa. - mm_encoder_outputs (
dict[str, ~modeling_outputs.BaseModelOutputWithPooling], opcional) — Dicionário em que as chaves são as modalidades suportadas e os valores são as saídas codificadas para essa modalidade. Cada saída codificada é uma tupla que consiste em (pooler_output, opcional:last_hidden_states, opcional:hidden_states, opcional:attentions)pooler_outputde forma(batch_size, sequence_length, hidden_size), opcional) é uma sequência de recursos multimodais do codificador mesclados em incorporações de texto.
Retorna
BaseModelOutputWithPast ou tuple(torch.Tensor)
Um BaseModelOutputWithPast ou uma tupla de
torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários
elementos, dependendo da configuração (MiniCPMV4_6Config) e das entradas.
O método forward do MiniCPMV4_6Model substitui o método especial __call__.
Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de
Moduleem seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.
last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.Se
past_key_valuesfor usado, apenas o último hidden-state das sequências, com forma(batch_size, 1, hidden_size), é retornado.past_key_values (
Cache, opcional, retornado quandouse_cache=Trueé passado ou quandoconfig.use_cache=True) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e, opcionalmente, se
config.is_encoder_decoder=True, nos blocos de atenção cruzada) que podem ser usados (veja a entradapast_key_values) para acelerar a decodificação sequencial.hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma(batch_size, sequence_length, hidden_size).Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
attentions (
tuple(torch.Tensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.
get_image_features
< source >( pixel_values: Tensortarget_sizes: IntTensordownsample_mode: str | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)
Parâmetros
- pixel_values (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size)) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando MiniCPMV4_6ImageProcessor. Consulte MiniCPMV4_6ImageProcessor.call() para mais detalhes (MiniCPMV4_6Processor usa MiniCPMV4_6ImageProcessor para processar as imagens). - target_sizes (
torch.IntTensorde forma(num_images, 2)) — Altura e largura (em patches) de cada imagem. - downsample_mode (
str, opcional) — Quando definido como"4x", ovit_mergerintermediário é ignorado, de modo que cada imagem mantém4×mais tokens visuais. O modo padrão"16x"aplica o pipeline completo de mesclagem.
Retorna
BaseModelOutputWithPooling ou tuple(torch.Tensor)
Um BaseModelOutputWithPooling ou uma tupla de
torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários
elementos, dependendo da configuração (MiniCPMV4_6Config) e das entradas.
Extração de características de imagem: codificador de visão, inserção do merger, em seguida, o merger MLP.
last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.pooler_output (
torch.Tensorde forma(batch_size, hidden_size)) — Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional através das camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para a família de modelos BERT, isso retorna o token de classificação após o processamento através de uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento.hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma(batch_size, sequence_length, hidden_size).Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
attentions (
tuple(torch.Tensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.
MiniCPMV4_6ForConditionalGeneration
classe transformers.MiniCPMV4_6ForConditionalGeneration
< source >( config: MiniCPMV4_6Config )
Parâmetros
- config (MiniCPMV4_6Config) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
O Modelo Minicpmv4 6 para geração de tokens condicionado a outras modalidades (por exemplo, geração de texto a partir de imagem e texto).
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Nonetarget_sizes: typing.Optional[torch.IntTensor] = Nonepixel_values_videos: typing.Optional[torch.Tensor] = Nonetarget_sizes_videos: typing.Optional[torch.IntTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: list[torch.Tensor] | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonedownsample_mode: str | None = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CausalLMOutputWithPast or tuple(torch.Tensor)
Parâmetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
- pixel_values (
torch.Tensor, opcional) — Patches de valores de pixels para imagens, empacotados pelo NaViT. - target_sizes (
torch.IntTensor, opcional) — Altura e largura (em patches) para cada imagem. - pixel_values_videos (
torch.Tensor, opcional) — Patches de valores de pixel para quadros de vídeo, empacotados pelo NaViT. - target_sizes_videos (
torch.IntTensor, opcional) — Altura e largura (em patches) para cada quadro de vídeo. - attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em[0, 1]:- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo[0, config.n_positions - 1]. - past_key_values (
list[torch.Tensor], opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nospast_key_valuesretornados pelo modelo em uma etapa anterior da decodificação, quandouse_cache=Trueouconfig.use_cache=True.Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum
past_key_valuesfor passado, DynamicCache será inicializado por padrão.O modelo sairá no mesmo formato de cache que é fornecido como entrada.
Se
past_key_valuesforem usados, espera-se que o usuário insira apenas osinput_idsnão processados (aqueles que não têm seus estados de chave e valor passados fornecidos a este modelo) com a forma(batch_size, unprocessed_length), em vez de todos osinput_idscom a forma(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Rótulos para o cálculo da perda de modelagem de linguagem mascarada. Os índices devem estar em[0, ..., config.vocab_size]ou ser -100 (veja a docstring deinput_ids). Tokens com índices definidos como-100são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em[0, ..., config.vocab_size]. - use_cache (
bool, opcional) — Se definido comoTrue, os estados de chave-valorpast_key_valuessão retornados e podem ser usados para acelerar a decodificação (vejapast_key_values). - downsample_mode (
str, opcional) —"4x"mantém 4x mais tokens visuais; o padrão"16x"aplica a mesclagem completa. - mm_encoder_outputs (
dict[str, ~modeling_outputs.BaseModelOutputWithPooling], opcional) — Dicionário em que as chaves são as modalidades suportadas e os valores são as saídas codificadas para essa modalidade. Cada saída codificada é uma tupla que consiste em (pooler_output, opcional:last_hidden_states, opcional:hidden_states, opcional:attentions)pooler_outputde forma(batch_size, sequence_length, hidden_size), opcional) é uma sequência de recursos multimodais do codificador mesclados em incorporações de texto.
Retorna
CausalLMOutputWithPast ou tuple(torch.Tensor)
Um CausalLMOutputWithPast ou uma tupla de
torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários
elementos, dependendo da configuração (MiniCPMV4_6Config) e das entradas.
O método forward de MiniCPMV4_6ForConditionalGeneration substitui o método especial __call__.
Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de
Moduleem seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.
loss (
torch.Tensorde forma(1,), opcional, retornado quandolabelsé fornecido) — Perda de modelagem de linguagem (para previsão do próximo token).logits (
torch.Tensorde forma(batch_size, sequence_length, config.vocab_size)) — Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).past_key_values (
Cache, opcional, retornado quandouse_cache=Trueé passado ou quandoconfig.use_cache=True) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados (veja a entrada
past_key_values) para acelerar a decodificação sequencial.hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma(batch_size, sequence_length, hidden_size).Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
attentions (
tuple(torch.Tensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.
Exemplo:
>>> from PIL import Image
>>> from transformers import AutoProcessor, MiniCPMV4_6ForConditionalGeneration
>>> model = MiniCPMV4_6ForConditionalGeneration.from_pretrained("openbmb/MiniCPM-V-4.6")
>>> processor = AutoProcessor.from_pretrained("openbmb/MiniCPM-V-4.6")
>>> messages = [
... {
... "role": "user", "content": [
... {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
... {"type": "text", "text": "Where is the cat standing?"},
... ]
... },
... ]
>>> inputs = processor.apply_chat_template(
... messages,
... tokenize=True,
... return_dict=True,
... return_tensors="pt",
... add_generation_prompt=True
... )
>>> # Generate
>>> generate_ids = model.generate(**inputs)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]get_image_features
< source >( *args**kwargs ) → BaseModelOutputWithPooling or tuple(torch.Tensor)
Retorna
BaseModelOutputWithPooling ou tuple(torch.Tensor)
Um BaseModelOutputWithPooling ou uma tupla de
torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários
elementos, dependendo da configuração (MiniCPMV4_6Config) e das entradas.
Extração de características de imagem: codificador de visão, inserção do merger, em seguida, o merger MLP.
last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.pooler_output (
torch.Tensorde forma(batch_size, hidden_size)) — Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional através das camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para a família de modelos BERT, isso retorna o token de classificação após o processamento através de uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento.hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma(batch_size, sequence_length, hidden_size).Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
attentions (
tuple(torch.Tensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.
Exemplo:
>>> from PIL import Image
>>> from transformers import AutoProcessor, MiniCPMV4_6ForConditionalGeneration
>>> model = MiniCPMV4_6ForConditionalGeneration.from_pretrained("openbmb/MiniCPM-V-4.6")
>>> processor = AutoProcessor.from_pretrained("openbmb/MiniCPM-V-4.6")
>>> messages = [
... {
... "role": "user", "content": [
... {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
... {"type": "text", "text": "Where is the cat standing?"},
... ]
... },
... ]
>>> inputs = processor.apply_chat_template(
... messages,
... tokenize=True,
... return_dict=True,
... return_tensors="pt",
... add_generation_prompt=True
... )
>>> # Generate
>>> generate_ids = model.generate(**inputs)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]MiniCPMV4_6Processor
classe transformers.MiniCPMV4_6Processor
< source >( image_processor = Nonevideo_processor = Nonetokenizer = Nonechat_template = None**kwargs )
Parâmetros
- image_processor (
MiniCPMV4_6ImageProcessor) — O processador de imagem é uma entrada obrigatória. - video_processor (
MiniCPMV4_6VideoProcessor) — O processador de vídeo é uma entrada obrigatória. - tokenizer (
TokenizersBackend) — O tokenizer é uma entrada obrigatória. - chat_template (
str) — Um modelo Jinja para converter listas de mensagens em um chat em uma string tokenizável.
Constrói um MiniCPMV4_6Processor que encapsula um processador de imagem, um processador de vídeo e um tokenizer em um único processador.
MiniCPMV4_6Processor oferece todas as funcionalidades de MiniCPMV4_6ImageProcessor, MiniCPMV4_6VideoProcessor e TokenizersBackend. Consulte ~MiniCPMV4_6ImageProcessor, ~MiniCPMV4_6VideoProcessor e ~TokenizersBackend para mais informações.
__call__
< source >( 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 = Nonevideos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = None**kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'> )
Parâmetros
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], opcional) — Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se passar imagens com valores de pixel entre 0 e 1, definado_rescale=False. - text (
Union[str, list[str], list[list[str]]], opcional) — A sequência ou lote de sequências a ser codificada. Cada sequência pode ser uma string ou uma lista de strings (string pré-tokenizada). Se você passar uma entrada pré-tokenizada, definais_split_into_words=Truepara evitar ambiguidade com entradas em lote. - videos (
Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]], opcional) — Vídeo a ser pré-processado. Espera um único vídeo ou um lote de vídeos com valores de pixel variando de 0 a 255. Se passar vídeos com valores de pixel entre 0 e 1, definado_rescale=False. - return_tensors (
strou TensorType, opcional) — Se definido, retornará tensors de um framework específico. Os valores aceitos são:'pt': Retorna objetostorch.Tensordo PyTorch.'np': Retorna objetosnp.ndarraydo NumPy.
- **kwargs (ProcessingKwargs, opcional) — Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados.
MiniCPMV4_6ImageProcessor
classe transformers.MiniCPMV4_6ImageProcessor
< source >( **kwargs: *<class 'transformers.models.minicpmv4_6.image_processing_minicpmv4_6.MiniCPMV4_6ImageProcessorKwargs'> )
Parâmetros
- do_convert_rgb (bool, kwargs, opcional, padrão True) — Se a imagem deve ser convertida para RGB.
- do_resize (bool, kwargs, opcional, padrão True) — Se deve redimensionar a imagem.
- size (Annotated[int | list[int] | tuple[int, …] | dict[str, int] | None, None], kwargs) — Descreve as dimensões máximas de entrada para o modelo.
- default_to_square (bool, kwargs, opcional, padrão True) — Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro.
- crop_size (Annotated[int | list[int] | tuple[int, …] | dict[str, int] | None, None], kwargs) — Tamanho da imagem de saída após aplicar center_crop.
- resample (Annotated[Union[int, PILImageRedimensionamento, NoneType], None], kwargs, padrão 3) — Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração PILImageResampling. Tem efeito apenas se do_resize estiver definido como True.
- do_rescale (bool, kwargs, opcional, padrão True) — Se deve reescalar a imagem.
- rescale_factor (float, kwargs, opcional, padrão 0.00392156862745098) — Fator de reescala para reescalar a imagem, caso do_rescale esteja definido como True.
- do_normalize (bool, kwargs, opcional, padrão True) — Se a imagem deve ser normalizada.
- image_mean (Union[float, list[float], tuple[float, …]], kwargs, opcional, padrão [0.5, 0.5, 0.5]) — Média da imagem a ser usada para normalização. Tem efeito apenas se do_normalize estiver definido como True.
- image_std (Union[float, list[float], tuple[float, …]], kwargs, opcional, padrão [0.5, 0.5, 0.5]) — Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se do_normalize estiver definido como True.
- do_pad (bool, kwargs, opcional) — Indica se a imagem deve ser preenchida (padding). O preenchimento é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de preenchimento depende do modelo.
- pad_size (Annotated[int | list[int] | tuple[int, …] | dict[str, int] | None, None], kwargs) — O tamanho em {“height”: int, “width” int} para o qual as imagens devem ser preenchidas. Deve ser maior que qualquer tamanho de imagem fornecido para o pré-processamento. Se pad_size não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando do_pad=True.
- do_center_crop (bool, kwargs, opcional) — Se deve recortar a imagem pelo centro.
- data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — Apenas ChannelDimension.FIRST é suportado. Adicionado para compatibilidade com processadores lentos.
- input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) —
O formato da dimensão de canal para a imagem de entrada. Se não definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes:
- “channels_first” ou ChannelDimension.FIRST: imagem no formato (num_channels, height, width).
- “channels_last” ou ChannelDimension.LAST: imagem no formato (altura, largura, num_canais).
- “none” ou ChannelDimension.NONE: imagem no formato (altura, largura).
- device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada.
- return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retorna tensores empilhados se definido como ‘pt’; caso contrário, retorna uma lista de tensores.
- disable_grouping (bool, kwargs, opcional) — Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157
- image_seq_length (int, kwargs, opcional) — O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros.
- max_slice_nums (int, kwargs, opcional, padrão 9) — Número máximo de fatias ao dividir uma imagem de alta resolução.
- scale_resolution (int, kwargs, opcional, padrão 448) — Resolução de destino para os slices individuais.
- patch_size (int, kwargs, opcional, padrão 14) — Tamanho do patch espacial do codificador de visão.
- slice_mode (bool, kwargs, opcional, padrão True) — Se as imagens devem ser divididas em múltiplas fatias para obter maior resolução.
- downsample_mode (str, kwargs, opcional, padrão “16x”) — Modo de redução de amostragem de tokens visuais. “16x” aplica a mesclagem completa; “4x” mantém 4x mais tokens.
- use_image_id (bool, kwargs, opcional, padrão True) —
Indica se deve ser adicionada uma tag de ID de imagem (
<image_id>N</image_id>) antes de cada marcador de posição de imagem. Utilizada pelo Processor para a geração de marcadores de posição, e não pelo próprio pipeline de processamento de imagens.
Constrói um processador de imagem MiniCPMV4_6ImageProcessor.
pré-processamento
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]**kwargs: *<class 'transformers.models.minicpmv4_6.image_processing_minicpmv4_6.MiniCPMV4_6ImageProcessorKwargs'> ) → ~image_processing_base.BatchFeature
Parâmetros
- images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se passar imagens com valores de pixel entre 0 e 1, defina do_rescale=False.
- do_convert_rgb (bool, kwargs, opcional) — Se deve converter a imagem para RGB.
- do_resize (bool, kwargs, opcional) — Se deve redimensionar a imagem.
- size (Annotated[int | list[int] | tuple[int, …] | dict[str, int] | None, None], kwargs) — Descreve as dimensões máximas de entrada para o modelo.
- default_to_square (bool, kwargs, opcional) — Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro.
- crop_size (Annotated[int | list[int] | tuple[int, …] | dict[str, int] | None, None], kwargs) — Tamanho da imagem de saída após aplicar center_crop.
- resample (Annotated[Union[int, PILImageRedimensionamento, NoneType], None], kwargs) — Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração PILImageResampling. Tem efeito apenas se do_resize estiver definido como True.
- do_rescale (bool, kwargs, opcional) — Se deve reescalar a imagem.
- rescale_factor (float, kwargs, opcional) — Fator de reescala para reescalar a imagem, caso do_rescale esteja definido como True.
- do_normalize (bool, kwargs, opcional) — Se a imagem deve ser normalizada.
- image_mean (Union[float, list[float], tuple[float, …]], kwargs, opcional) — Média da imagem a ser usada para normalização. Tem efeito apenas se do_normalize estiver definido como True.
- image_std (Union[float, list[float], tuple[float, …]], kwargs, opcional) — Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se do_normalize estiver definido como True.
- do_pad (bool, kwargs, opcional) — Indica se a imagem deve ser preenchida (padding). O preenchimento é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de preenchimento depende do modelo.
- pad_size (Annotated[int | list[int] | tuple[int, …] | dict[str, int] | None, None], kwargs) — O tamanho em {“height”: int, “width” int} para o qual as imagens devem ser preenchidas. Deve ser maior que qualquer tamanho de imagem fornecido para o pré-processamento. Se pad_size não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando do_pad=True.
- do_center_crop (bool, kwargs, opcional) — Se deve recortar a imagem pelo centro.
- data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — Apenas ChannelDimension.FIRST é suportado. Adicionado para compatibilidade com processadores lentos.
- input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) —
O formato da dimensão de canal para a imagem de entrada. Se não definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes:
- “channels_first” ou ChannelDimension.FIRST: imagem no formato (num_channels, height, width).
- “channels_last” ou ChannelDimension.LAST: imagem no formato (altura, largura, num_canais).
- “none” ou ChannelDimension.NONE: imagem no formato (altura, largura).
- device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada.
- return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retorna tensores empilhados se definido como ‘pt’; caso contrário, retorna uma lista de tensores.
- disable_grouping (bool, kwargs, opcional) — Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157
- image_seq_length (int, kwargs, opcional) — O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros.
- max_slice_nums (int, kwargs, opcional, padrão 9) — Número máximo de fatias ao dividir uma imagem de alta resolução.
- scale_resolution (int, kwargs, opcional, padrão 448) — Resolução de destino para os slices individuais.
- patch_size (int, kwargs, opcional, padrão 14) — Tamanho do patch espacial do codificador de visão.
- slice_mode (bool, kwargs, opcional, padrão True) — Se as imagens devem ser divididas em múltiplas fatias para obter maior resolução.
- downsample_mode (str, kwargs, opcional, padrão “16x”) — Modo de redução de amostragem de tokens visuais. “16x” aplica a mesclagem completa; “4x” mantém 4x mais tokens.
- use_image_id (bool, kwargs, opcional, padrão True) —
Indica se deve ser adicionada uma tag de ID de imagem (
<image_id>N</image_id>) antes de cada marcador de posição de imagem. Utilizada pelo Processor para a geração de marcadores de posição, e não pelo próprio pipeline de processamento de imagens.
Retorna
~image_processing_base.BatchFeature
- data (dict) — Dicionário de listas/arrays/tensors retornados pelo método call (‘pixel_values’, etc.).
- tensor_type (Union[None, str, TensorType], opcional) — Você pode fornecer um tensor_type aqui para converter as listas de inteiros em Tensors do PyTorch/Numpy na inicialização.
MiniCPMV4_6ImageProcessorPil
classe transformers.MiniCPMV4_6ImageProcessorPil
< source >( **kwargs: *<class 'transformers.models.minicpmv4_6.image_processing_pil_minicpmv4_6.MiniCPMV4_6ImageProcessorPilKwargs'> )
Constrói um processador de imagem MiniCPMV4_6ImageProcessor.
pré-processamento
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]**kwargs: *<class 'transformers.models.minicpmv4_6.image_processing_pil_minicpmv4_6.MiniCPMV4_6ImageProcessorPilKwargs'> ) → ~image_processing_base.BatchFeature
Parâmetros
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se passar imagens com valores de pixel entre 0 e 1, definado_rescale=False. - return_tensors (
strou TensorType, opcional) — Retorna tensores empilhados se definido como'pt', caso contrário, retorna uma lista de tensores. - **kwargs (
MiniCPMV4_6ImageProcessorPilKwargs, opcional) — Opções adicionais de pré-processamento de imagem. Os kwargs específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados.
Retorna
~image_processing_base.BatchFeature
- data (
dict) — Dicionário de listas/arrays/tensors retornados pelo método call (‘pixel_values’, etc.). - tensor_type (
Union[None, str, TensorType], opcional) — Você pode fornecer um tensor_type aqui para converter as listas de inteiros em Tensors do PyTorch/Numpy na inicialização.
MiniCPMV4_6VideoProcessor
classe transformers.MiniCPMV4_6VideoProcessor
< source >( **kwargs: *<class 'transformers.models.minicpmv4_6.video_processing_minicpmv4_6.MiniCPMV4_6VideoProcessorKwargs'> )
Parâmetros
- do_convert_rgb (bool, kwargs, opcional, padrão True) — Se a imagem deve ser convertida para RGB.
- do_resize (bool, kwargs, opcional, padrão True) — Se deve redimensionar a imagem.
- size (Annotated[int | list[int] | tuple[int, …] | dict[str, int] | None, None], kwargs) — Descreve as dimensões máximas de entrada para o modelo.
- default_to_square (bool, kwargs, opcional, padrão True) — Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro.
- resample (Annotated[Union[int, PILImageRedimensionamento, NoneType], None], kwargs, padrão 3) — Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração PILImageResampling. Tem efeito apenas se do_resize estiver definido como True.
- do_rescale (bool, kwargs, opcional, padrão True) — Se deve reescalar a imagem.
- rescale_factor (float, kwargs, opcional, padrão 0.00392156862745098) — Fator de reescala para reescalar a imagem, caso do_rescale esteja definido como True.
- do_normalize (bool, kwargs, opcional, padrão True) — Se a imagem deve ser normalizada.
- image_mean (Union[float, list[float], tuple[float, …]], kwargs, opcional, padrão [0.5, 0.5, 0.5]) — Média da imagem a ser usada para normalização. Tem efeito apenas se do_normalize estiver definido como True.
- image_std (Union[float, list[float], tuple[float, …]], kwargs, opcional, padrão [0.5, 0.5, 0.5]) — Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se do_normalize estiver definido como True.
- do_center_crop (bool, kwargs, opcional) — Se deve recortar a imagem pelo centro.
- do_pad (bool, kwargs, opcional) — Indica se a imagem deve ser preenchida (padding). O preenchimento é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de preenchimento depende do modelo.
- crop_size (Annotated[int | list[int] | tuple[int, …] | dict[str, int] | None, None], kwargs) — Tamanho da imagem de saída após aplicar center_crop.
- data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — Apenas ChannelDimension.FIRST é suportado. Adicionado para compatibilidade com processadores lentos.
- input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) —
O formato da dimensão de canal para a imagem de entrada. Se não definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes:
- “channels_first” ou ChannelDimension.FIRST: imagem no formato (num_channels, height, width).
- “channels_last” ou ChannelDimension.LAST: imagem no formato (altura, largura, num_canais).
- “none” ou ChannelDimension.NONE: imagem no formato (altura, largura).
- device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada.
- do_sample_frames (bool, kwargs, opcional, padrão True) — Se deve amostrar quadros do vídeo antes do processamento ou processar o vídeo inteiro.
- video_metadata (Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None], kwargs) — Metadados do vídeo contendo informações sobre a duração total, o fps e o número total de quadros. Será usado para amostrar quadros do vídeo ou calcular timestamps. Não passe nenhum metadado, a menos que você esteja tentando decodificar o vídeo manualmente antes do processamento
- fps (Annotated[int | float | None, None], kwargs) — Quantidade de quadros-alvo a amostrar por segundo quando do_sample_frames=True.
- num_frames (Annotated[int | None, None], kwargs) — Número máximo de quadros a amostrar quando do_sample_frames=True.
- return_metadata (bool, kwargs, opcional, padrão False) — Indica se os metadados do vídeo devem ser retornados ou não. Os metadados do vídeo são um objeto contendo informações sobre a duração do vídeo, fps, backend de decodificação, etc.
- return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) —
Se definido, retornará tensors de um framework específico. Os valores aceitos são:
- ‘pt’: Retorna objetos torch.Tensor do PyTorch.
- ‘np’: Retorna objetos np.ndarray do NumPy.
- max_num_frames (int, kwargs, opcional, padrão 128) — Número máximo de quadros principais a serem amostrados por vídeo.
- stack_frames (int, kwargs, opcional, padrão 1) —
Sub-frames por segundo para empilhar.
1desativa o empilhamento. - max_slice_nums (int, kwargs, opcional, padrão 9) — Número máximo de fatias ao dividir uma imagem de alta resolução.
- scale_resolution (int, kwargs, opcional, padrão 448) — Resolução de destino para os slices individuais.
- patch_size (int, kwargs, opcional, padrão 14) — Tamanho do patch espacial do codificador de visão.
- slice_mode (bool, kwargs, opcional, padrão True) — Se as imagens devem ser divididas em múltiplas fatias para obter maior resolução.
- downsample_mode (str, kwargs, opcional, padrão “16x”) — Modo de redução de amostragem de tokens visuais. “16x” aplica a mesclagem completa; “4x” mantém 4x mais tokens.
- use_image_id (bool, kwargs, opcional, padrão True) —
Indica se deve ser adicionada uma tag de ID de imagem (
<image_id>N</image_id>) antes de cada marcador de posição de imagem. Utilizada pelo Processor para a geração de marcadores de posição, e não pelo próprio pipeline de processamento de imagens. - **kwargs ([ProcessingKwargs], opcional) — Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados.
Constrói um processador de vídeo MiniCPMV4_6VideoProcessor.
pré-processamento
< source >( videos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]]]**kwargs: *<class 'transformers.processing_utils.VideosKwargs'> ) → ~image_processing_base.BatchFeature
Parâmetros
- videos (
Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]]) — Vídeo a ser pré-processado. Espera um único vídeo ou um lote de vídeos com valores de pixel variando de 0 a 255. Se passar vídeos com valores de pixel entre 0 e 1, definado_rescale=False. - do_convert_rgb (
bool, kwargs, opcional) — Se a imagem deve ser convertida para RGB. - do_resize (
bool, kwargs, opcional) — Se deve redimensionar a imagem. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Descreve as dimensões máximas de entrada para o modelo. - default_to_square (
bool, kwargs, opcional) — Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeraçãoPILImageResampling. Tem efeito apenas sedo_resizeestiver definido comoTrue. - do_rescale (
bool, kwargs, opcional) — Se deve reescalar a imagem. - rescale_factor (
float, kwargs, opcional) — Fator de redimensionamento para redimensionar a imagem, casodo_rescaleesteja definido comoTrue. - do_normalize (
bool, kwargs, opcional) — Se a imagem deve ser normalizada. - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Média da imagem a ser usada para normalização. Tem efeito apenas sedo_normalizeestiver definido comoTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas sedo_normalizeestiver definido comoTrue. - do_center_crop (
bool, kwargs, opcional) — Se deve recortar a imagem centralmente. - do_pad (
bool, kwargs, opcional) — Indica se a imagem deve ser preenchida (padding). O preenchimento é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de preenchimento depende do modelo. - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Tamanho da imagem de saída após a aplicação decenter_crop. - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — ApenasChannelDimension.FIRSTé suportado. Adicionado para compatibilidade com processadores lentos. - input_data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — O formato da dimensão de canal para a imagem de entrada. Se não definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes:"channels_first"ouChannelDimension.FIRST: imagem no formato (num_channels, height, width)."channels_last"ouChannelDimension.LAST: imagem no formato (altura, largura, num_canais)."none"ouChannelDimension.NONE: imagem no formato (altura, largura).
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — O dispositivo em que os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada. - do_sample_frames (
bool, kwargs, opcional) — Se deve amostrar quadros do vídeo antes do processamento ou processar o vídeo inteiro. - video_metadata (
Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None], kwargs) — Metadados do vídeo contendo informações sobre a duração total, fps e o número total de quadros. Será usado para amostrar quadros do vídeo ou calcular timestamps. Não passe nenhum metadado, a menos que você esteja tentando decodificar o vídeo manualmente antes do processamento - fps (
Annotated[int | float | None, None], kwargs) — Quantidade de quadros-alvo a amostrar por segundo quandodo_sample_frames=True. - num_frames (
Annotated[int | None, None], kwargs) — Número máximo de quadros a amostrar quandodo_sample_frames=True. - return_metadata (
bool, kwargs, opcional) — Se deve retornar ou não os metadados do vídeo. Os metadados do vídeo são um objeto contendo informações sobre a duração do vídeo, fps, backend de decodificação, etc. - return_tensors (
Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retorna tensores empilhados se definido como'pt'; caso contrário, retorna uma lista de tensores.
Retorna
~image_processing_base.BatchFeature
- data (
dict) — Dicionário de listas/arrays/tensors retornados pelo método call (‘pixel_values’, etc.). - tensor_type (
Union[None, str, TensorType], opcional) — Você pode fornecer um tensor_type aqui para converter as listas de inteiros em Tensors do PyTorch/Numpy na inicialização.