Transformers documentation
Apertus 1.5
Este modelo foi contribuído para o Hugging Face Transformers em 16/11/2026.
Apertus 1.5
Visão geral
Apertus 1.5 é um modelo multimodal da Swiss AI Initiative que aceita texto, imagens e áudio e gera texto. Ele estende o modelo de linguagem Apertus com o EMU3.5 vision tokenizer e o WavTokenizer para áudio. O EMU3.5 vision tokenizer é um VQGAN apenas para imagens com o mesmo codificador do Chameleon, ao contrário do tokenizer Emu3, que adiciona camadas temporais para vídeo. Ele atribui códigos pelo maior produto interno com o codebook, em vez da menor distância L2.
Os tokenizadores de mídia convertem imagens e áudio em tokens discretos, que o backbone de linguagem processa junto com o texto em um vocabulário de entrada compartilhado. O vocabulário de saída contém apenas tokens de texto. A integração inclui os codificadores e quantizadores de mídia; ela não suporta a geração de imagens ou áudio, nem o treinamento do tokenizador de visão.
Exemplo de uso
Use o template de chat do processador para preparar uma conversa com imagens e áudio. Ele carrega os mídias referenciados, reamostra o áudio e constrói automaticamente as entradas do modelo.
from transformers import AutoModelForMultimodalLM, AutoProcessor
model = AutoModelForMultimodalLM.from_pretrained(
"swiss-ai/Apertus-v1.5-8B", device_map="auto"
)
processor = AutoProcessor.from_pretrained("swiss-ai/Apertus-v1.5-8B")
messages = [
{
"role": "user",
"content": [
{"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg"},
{"type": "audio", "url": "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/belinda.wav"},
{"type": "text", "text": "Describe the image and transcribe the audio."},
],
}
]
inputs = processor.apply_chat_template(
messages, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt"
).to(model.device)
generated = model.generate(**inputs, max_new_tokens=128)
print(processor.decode(generated[0, inputs["input_ids"].shape[1] :], skip_special_tokens=True))Notas de uso
- Precisão do tokenizador: Ambos os tokenizadores de mídia exigem
float32para atribuições de código estáveis. Ofrom_pretrainedpreserva essa precisão ao carregar o backbone de linguagem em meia precisão. Evite converter o modelo inteiro para uma precisão menor ou executar os tokenizadores sob autocast de precisão mista. Se estiver quantizando o modelo, certifique-se de que o backend exclua ambos os tokenizadores de mídia. - Vocabulário de saída: Os logits retornados cobrem apenas
text_config.output_vocab_sizequando definido, caso contráriotext_config.vocab_size. Tokens multimodais apenas de entrada não podem ser gerados. Mescle esses tokens com-100nos rótulos de treinamento e restrinja as restrições de geração a tokens dentro do vocabulário de saída.
Apertus1p5Config
classe transformers.Apertus1p5Config
< 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.models.apertus1p5.configuration_apertus1p5.Apertus1p5TextConfig | None = Nonevision_config: dict | transformers.models.apertus1p5.configuration_apertus1p5.Apertus1p5VisionTokenizerConfig | None = Noneaudio_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneimage_token_id: int = 131079audio_token_id: int = 131085image_token_offset: int = 131272audio_token_offset: int = 262344tie_word_embeddings: bool = False )
Parâmetros
- text_config (
Union[dict, ~models.apertus1p5.configuration_apertus1p5.Apertus1p5TextConfig], opcional) — O objeto de configuração ou dicionário do backbone de texto. - vision_config (
Union[dict, ~models.apertus1p5.configuration_apertus1p5.Apertus1p5VisionTokenizerConfig], opcional) — O objeto de configuração ou dicionário do backbone de visão. - audio_config (
Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — O objeto de configuração ou dicionário do backbone de áudio. - image_token_id (
int, opcional, padrão131079) — O índice do token de imagem usado como marcador para as imagens de entrada. - audio_token_id (
int, opcional, padrão131085) — O índice do token de áudio usado como marcador para o áudio de entrada. - image_token_offset (
int, opcional, padrão 131272) — Deslocamento que mapeia um índice de codebook visualipara o id de vocabulário de<|visual token i|>. - audio_token_offset (
int, opcional, padrão 262344) — Deslocamento que mapeia um índice de codebook de áudioipara o id de vocabulário de<|audio token i|>. - tie_word_embeddings (
bool, opcional, padrãoFalse) — Se deve vincular as embeddings de pesos de acordo com o mapeamentotied_weights_keysdo modelo.
Esta é a classe de configuração para armazenar a configuração de um Apertus1p5Model. Ela é usada para instanciar um modelo Apertus1P5 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 swiss-ai/Apertus-v1.5-8B
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.
Exemplo:
>>> from transformers import Apertus1p5Config, Apertus1p5ForConditionalGeneration
>>> # Initializing a configuration (Apertus 1.5 backbone + vision/audio tokenizer defaults)
>>> configuration = Apertus1p5Config()
>>> # Initializing a model (with random weights) from the configuration
>>> model = Apertus1p5ForConditionalGeneration(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configApertus1p5TextConfig
classe transformers.Apertus1p5TextConfig
< 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 = Nonevocab_size: int = 266752hidden_size: int = 4096intermediate_size: int = 14336num_hidden_layers: int = 32num_attention_heads: int = 32num_key_value_heads: int | None = Nonehidden_act: str = 'xielu'max_position_embeddings: int = 65536initializer_range: float = 0.02rms_norm_eps: float = 1e-05use_cache: bool = Truepad_token_id: int | None = 3bos_token_id: int | None = 1eos_token_id: int | list[int] | None = 2tie_word_embeddings: bool = Falserope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Noneattention_bias: bool = Falseattention_dropout: float | int = 0.0output_vocab_size: int | None = None )
Parâmetros
- vocab_size (
int, opcional, padrão266752) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelosinput_ids. - hidden_size (
int, opcional, padrão4096) — Dimensão das representações ocultas. - intermediate_size (
int, opcional, padrão14336) — Dimensão das representações do MLP. - num_hidden_layers (
int, opcional, padrão32) — Número de camadas ocultas no decodificador do Transformer. - num_attention_heads (
int, opcional, padrão32) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. - num_key_value_heads (
int, opcional) — Este é o número de cabeças de key_value que devem ser usadas para implementar Grouped Query Attention. Senum_key_value_heads=num_attention_heads, o modelo usará Multi Head Attention (MHA); senum_key_value_heads=1, o modelo usará Multi Query Attention (MQA); caso contrário, será usado GQA. Ao converter um checkpoint multi-head para um checkpoint GQA, cada grupo de cabeças de chave e valor deve ser construído por meio do meanpooling de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte este artigo. Se não for especificado, o valor padrão seránum_attention_heads. - hidden_act (
str, opcional, padrãoxielu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo,"gelu","relu","silu", etc. - max_position_embeddings (
int, opcional, padrão65536) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado. - initializer_range (
float, opcional, padrão0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. - rms_norm_eps (
float, opcional, padrão1e-05) — O epsilon usado pelas camadas de normalização rms. - use_cache (
bool, opcional, padrãoTrue) — Se o modelo deve ou não retornar as últimas chaves/valores de atenção (não usado por todos os modelos). Relevante apenas seconfig.is_decoder=Trueou quando o modelo for um modelo generativo somente decodificador. - pad_token_id (
int, opcional, padrão3) — ID do token usado para preenchimento (padding) no vocabulário. - bos_token_id (
int, opcional, padrão1) — ID do token usado para o início do fluxo no vocabulário. - eos_token_id (
Union[int, list[int]], opcional, padrão2) — ID do token usado para o fim do fluxo no vocabulário. - tie_word_embeddings (
bool, opcional, padrãoFalse) — Se deve vincular as embeddings de pesos de acordo com o mapeamentotied_weights_keysdo modelo. - rope_parameters (
Union[~modeling_rope_utils.RopeParameters, dict], opcional) — Dicionário contendo os parâmetros de configuração para os embeddings RoPE. O dicionário deve conter um valor pararope_thetae, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE commax_position_embeddingsmaiores. - attention_bias (
bool, opcional, padrãoFalse) — Indica se deve ser usado um viés nas camadas de projeção de query, key, value e output durante a autoatenção. - attention_dropout (
Union[float, int], opcional, padrão0.0) — A taxa de dropout para as probabilidades de atenção. - output_vocab_size (
int, opcional) — Número de linhas do LM-head mantidas após o pruning das linhas de tokens multimodais da projeção de saída; os ids de saída retidos são0..output_vocab_size - 1.Nonesignifica que o head não foi podado (vocab_sizelinhas). Os embeddings de entrada sempre usamvocab_size, enquanto os logits retornados usam a largura do LM-head, com ou semlabels. Os checkpoints liberados usamtie_word_embeddings=Falsepara manter o head podado separado dos embeddings de entrada.
Esta é a classe de configuração para armazenar a configuração de um Apertus1p5Model. Ela é usada para instanciar um modelo Apertus1P5 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 swiss-ai/Apertus-v1.5-8B
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.
Exemplo:
>>> from transformers import Apertus1p5TextConfig, Apertus1p5TextForCausalLM
>>> # Initializing an Apertus 1.5 text configuration (extended vocabulary, optionally pruned output head)
>>> configuration = Apertus1p5TextConfig()
>>> # Initializing a model (with random weights) from the configuration
>>> model = Apertus1p5TextForCausalLM(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configApertus1p5VisionTokenizerConfig
classe transformers.Apertus1p5VisionTokenizerConfig
< 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 = Nonecodebook_size: int = 131072embed_dim: int = 256latent_channels: int = 256in_channels: int = 3base_channels: int = 256channel_multiplier: list[int] | tuple[int, ...] = (1, 1, 2, 2, 4)num_res_blocks: int = 4attn_resolutions: list[int] | tuple[int, ...] = (16,)resolution: int = 256dropout: float = 0.0 )
Parâmetros
- codebook_size (
int, opcional, padrão 131072) — Número de entradas no codebook do IBQ. - embed_dim (
int, opcional, padrão 256) — Dimensão dos vetores do codebook (a entrada do quantizador apósquant_conv). - latent_channels (
int, opcional, padrão 256) — Número de canais de saída do codificador (antes dequant_conv). - in_channels (
int, opcional, padrão3) — O número de canais de entrada. - base_channels (
int, opcional, padrão 256) — Número de canais base do codificador; as larguras por estágio sãobase_channels * channel_multiplier[stage]. - channel_multiplier (
list[int], opcional, padrão(1, 1, 2, 2, 4)) — Fator de escala de canais por estágio do codificador. O número de estágios élen(channel_multiplier), resultando em um fator de downsampling espacial de2**(len(channel_multiplier) - 1)(16 por padrão). - num_res_blocks (
int, opcional, padrão 4) — Número de blocos residuais por estágio do codificador. - attn_resolutions (
list[int], opcional, padrão(16,)) — Resoluções dos mapas de recursos (relativas a uma entrada de tamanhoresolution) nas quais os blocos de atenção são inseridos. - resolution (
int, opcional, padrão 256) — Resolução de entrada de referência usada (estaticamente, junto comattn_resolutions) para decidir quais estágios do codificador carregam blocos de atenção. Não restringe o tamanho real da entrada. - dropout (
float, opcional, padrão 0.0) — Dropout dentro dos blocos residuais.
Esta é a classe de configuração para armazenar a configuração de um Apertus1p5Model. Ela é usada para instanciar um modelo Apertus1P5 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 swiss-ai/Apertus-v1.5-8B
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.
Exemplo:
>>> from transformers import Apertus1p5VisionTokenizerConfig, Apertus1p5VisionTokenizerModel
>>> # Initializing a vision tokenizer configuration (Apertus 1.5 defaults)
>>> configuration = Apertus1p5VisionTokenizerConfig()
>>> # Initializing the encode-only tokenizer (with random weights) from the configuration
>>> model = Apertus1p5VisionTokenizerModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configApertus1p5Processor
classe transformers.Apertus1p5Processor
< source >( image_processor = Nonefeature_extractor = Nonetokenizer = Nonechat_template = None**kwargs )
Parâmetros
- image_processor (
Apertus1p5ImageProcessor) — O processador de imagem é uma entrada obrigatória. - feature_extractor (
WavTokenizerFeatureExtractor) — O extrator de recursos é uma entrada obrigatória. - tokenizer (
tokenizer_class) — 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 processador Apertus 1.5 para texto, imagens e áudio.
__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] = Noneaudio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], 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. - audio (
Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]], opcional) — O áudio ou lote de áudios a ser preparado. Cada áudio pode ser um array NumPy ou um tensor PyTorch. No caso de um array NumPy/tensor PyTorch, cada áudio deve ter a forma (C, T), onde C é o número de canais e T é o comprimento de amostras do áudio. - return_mm_token_type_ids (
bool, kwargs) — Se deve retornar os ids de tipo de token multimodal indicando as posições dos tokens placeholder multimodais. - return_text_replacement_offsets (
bool, kwargs) — Se deve retornar os deslocamentos de caracteres para cada placeholder multimodal e sua substituição. - 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.
Apertus1p5ImageProcessor
classe transformers.Apertus1p5ImageProcessor
< source >( **kwargs: *<class 'transformers.models.apertus1p5.image_processing_apertus1p5.Apertus1p5ImageProcessorKwargs'> )
Parâmetros
- do_convert_rgb (
bool, kwargs, opcional, padrãoTrue) — Se a imagem deve ser convertida para RGB. - do_resize (
bool, kwargs, opcional, padrãoTrue) — Se deve redimensionar a imagem. - size (
dict, kwargs, opcional, padrão{"min_pixels" -- 128 * 128, "max_pixels": 1400 * 1400}): Áreas mínimas e máximas de pixels. As imagens são redimensionadas para aproximadamente essa faixa de área. - default_to_square (
bool, kwargs, opcional, padrãoTrue) — 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 a aplicação decenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, padrão3) — 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, padrãoTrue) — Se deve reescalar a imagem. - rescale_factor (
float, kwargs, opcional, padrão0.00392156862745098) — Fator de reescala para reescalar a imagem, casodo_rescaleesteja definido comoTrue. - do_normalize (
bool, kwargs, opcional, padrãoTrue) — 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 sedo_normalizeestiver definido comoTrue. - 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 sedo_normalizeestiver definido comoTrue. - do_pad (
bool, kwargs, opcional, padrãoTrue) — Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding 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 preenchimento das imagens. Deve ser maior que qualquer tamanho de imagem fornecido para o pré-processamento. Sepad_sizenão for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quandodo_pad=True. - do_center_crop (
bool, kwargs, opcional) — Se deve recortar a imagem centralmente. - 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. - 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. - spatial_factor (
int, kwargs, opcional, padrão 16) — Ambos os lados da saída são arredondados para múltiplos deste fator (o fator de redução do tokenizer de visão); cada patch despatial_factor x spatial_factorse torna um código discreto.
Constrói um processador de imagem Apertus 1.5 com a política de redimensionamento do pipeline de treinamento.
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.apertus1p5.image_processing_apertus1p5.Apertus1p5ImageProcessorKwargs'> ) → ~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. - 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 (
dict, kwargs, opcional, padrão{"min_pixels" -- 128 * 128, "max_pixels": 1400 * 1400}): Áreas mínimas e máximas de pixels. As imagens são redimensionadas para aproximadamente essa faixa de área. - 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 a aplicação decenter_crop. - 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_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 preenchimento das imagens. Deve ser maior que qualquer tamanho de imagem fornecido para o pré-processamento. Sepad_sizenão for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quandodo_pad=True. - do_center_crop (
bool, kwargs, opcional) — Se deve recortar a imagem centralmente. - 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. - 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. - spatial_factor (
int, kwargs, opcional, padrão 16) — Ambos os lados da saída são arredondados para múltiplos deste fator (o fator de redução do tokenizer de visão); cada patch despatial_factor x spatial_factorse torna um código discreto.
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.
Apertus1p5VisionTokenizerModel
classe transformers.Apertus1p5VisionTokenizerModel
< source >( config: Apertus1p5VisionTokenizerConfig )
Parâmetros
- config (Apertus1p5VisionTokenizerConfig) — 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.
Tokenizer de visão Encode-only EMU3.5 usado pelo Apertus 1.5: um codificador 2D VQGAN, como no Chameleon, seguido por um quantizador que seleciona a entrada do codebook com o maior produto interno. Ele retorna índices rígidos do codebook; execute-o em float32 para uma atribuição de código estável (o Apertus 1.5 faz isso automaticamente).
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.
encode
< source >( pixel_values: Tensor ) → Apertus1p5VisionTokenizerEncoderOutput
Tokeniza imagens em uma grade de índices discretos do codebook.
Apertus1p5TextModel
classe transformers.Apertus1p5TextModel
< source >( config: Apertus1p5TextConfig )
Parâmetros
- config (Apertus1p5TextConfig) — 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 de texto Apertus1P5 puro, que gera estados ocultos brutos sem nenhum cabeçalho específico no topo.
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] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonecache: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | 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.
- 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]. - cache (
~cache_utils.Cache, 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 nocacheretornado 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 kv. Se nenhum
cachefor passado, DynamicCache será inicializado por padrão.O modelo sairá no mesmo formato de cache que é fornecido como entrada.
Se
cacheforem 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 para 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 e valor decachesão retornados e podem ser usados para acelerar a decodificação (vejacache).
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 (Apertus1p5Config) e das entradas.
O método forward do Apertus1p5TextModel 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
cachefor usado, apenas o último hidden-state das sequências, com forma(batch_size, 1, hidden_size), é retornado.cache (
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 entradacache) 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.
Apertus1p5TextForCausalLM
classe transformers.Apertus1p5TextForCausalLM
< source >( config: Apertus1p5TextConfig )
Parâmetros
- config (Apertus1p5TextConfig) — 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 Apertus1P5 para modelagem de linguagem causal.
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] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonecache: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**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.
- 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]. - cache (
~cache_utils.Cache, 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 nocacheretornado 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 kv. Se nenhum
cachefor passado, DynamicCache será inicializado por padrão.O modelo sairá no mesmo formato de cache que é fornecido como entrada.
Se
cacheforem 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 para 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) — Ids dos tokens alvo.-100ignora uma posição; os outros valores devem estar dentro da faixa física da cabeça do LM. Com uma cabeça podada, use-100para mascarar ids multimodais/que são apenas de entrada. - use_cache (
bool, opcional) — Se definido comoTrue, os estados de chave e valor decachesão retornados e podem ser usados para acelerar a decodificação (vejacache). - logits_to_keep (
Union[int, torch.Tensor], opcional, padrão0) — Se for umint, calcula os logits para os últimoslogits_to_keeptokens. Se for0, calcula os logits para todos osinput_ids(caso especial). Apenas os logits do último token são necessários para a geração, e calculá-los apenas para esse token pode economizar memória, o que se torna bastante significativo para sequências longas ou tamanho de vocabulário grande. Se for umtorch.Tensor, deve ser 1D, correspondendo aos índices a serem mantidos na dimensão de comprimento da sequência. Isso é útil ao usar o formato de tensor empacotado (uma única dimensão para lote e comprimento da sequência).
Retorna
CausalLMOutputWithPast ou tuple(torch.Tensor)
Os logits usam a largura física do LM-head (config.output_vocab_size quando definido, caso contrário
config.vocab_size), com ou sem labels.
O método forward de Apertus1p5TextForCausalLM 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.
Apertus1p5Model
classe transformers.Apertus1p5Model
< source >( config: Apertus1p5Config )
Parâmetros
- config (Apertus1p5Config) — 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 Apertus1P5 puro, que gera estados ocultos brutos sem nenhum cabeçalho específico no topo.
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] = Noneimage_sizes: typing.Optional[torch.Tensor] = Noneinput_values: typing.Optional[torch.Tensor] = Nonepadding_mask: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonecache: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MultimodalBaseModelOutputWithPast 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.Tensorde forma(batch_size, num_channels, image_size, image_size), opcional) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usandoimage_processor_class. Consulteimage_processor_class.__call__para mais detalhes (processor_classusaimage_processor_classpara processar as imagens). - image_sizes (
torch.Tensorde forma(batch_size, 2), opcional) — Os tamanhos das imagens no lote, sendo (altura, largura) para cada imagem. - input_values (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Valores em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio.flacou.wavem um array do tipolist[float], umnumpy.ndarrayou umtorch.Tensor, por exemplo, por meio da biblioteca torchcodec (pip install torchcodec) ou da biblioteca soundfile (pip install soundfile). Para preparar o array parainput_values, o AutoProcessor deve ser usado para padding e conversão para um tensor do tipotorch.Tensor. Consulteprocessor_class.__call__para mais detalhes. - padding_mask (
torch.Tensorde forma(num_clips, max_length), opcional) — Máscara com preenchimento à direita, com 1 para amostras válidas e 0 para preenchimento, obrigatória cominput_values. - 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]. - cache (
~cache_utils.Cache, 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 nocacheretornado 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 kv. Se nenhum
cachefor passado, DynamicCache será inicializado por padrão.O modelo sairá no mesmo formato de cache que é fornecido como entrada.
Se
cacheforem 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 para 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 e valor decachesão retornados e podem ser usados para acelerar a decodificação (vejacache). - 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
MultimodalBaseModelOutputWithPast ou tuple(torch.Tensor)
Um MultimodalBaseModelOutputWithPast 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 (None) e das entradas.
O método forward do Apertus1p5Model sobrescreve 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.FloatTensorde forma(batch_size, sequence_length, hidden_size)) — Sequência de hidden-states na saída da última camada do backbone do modelo de linguagem. Secachefor usado, apenas o último hidden-state das sequências, de forma(batch_size, 1, hidden_size), é retornado. - cache (
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, seconfig.is_encoder_decoder=True, nos blocos de atenção cruzada) que podem ser usados (veja a entradacache) para acelerar a decodificação sequencial. - hidden_states (
tuple(torch.FloatTensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.FloatTensor(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). Hidden-states do backbone do modelo de linguagem na saída de cada camada, além das saídas iniciais opcionais de embedding. - attentions (
tuple(torch.FloatTensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(uma para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length). Pesos de atenção do backbone do modelo de linguagem, após o softmax de atenção. - image_outputs (
BaseModelOutputWithPooling, opcional) — Saída do codificador de imagem:last_hidden_state,pooler_output,hidden_stateseattentions.Nonese nenhuma imagem foi processada. - video_outputs (
BaseModelOutputWithPooling, opcional) — Saída do codificador de vídeo:last_hidden_state,pooler_output,hidden_stateseattentions.Nonese nenhum vídeo foi processado. - audio_outputs (
BaseModelOutputWithPooling, opcional) — Saída do codificador de áudio:last_hidden_state,pooler_output,hidden_stateseattentions.Nonese nenhum áudio foi processado.
Apertus1p5ForConditionalGeneration
classe transformers.Apertus1p5ForConditionalGeneration
< source >( config: Apertus1p5Config )
Parâmetros
- config (Apertus1p5Config) — 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 Apertus1P5 para geração de tokens condicionada 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] = Noneimage_sizes: typing.Optional[torch.Tensor] = Noneinput_values: typing.Optional[torch.Tensor] = Nonepadding_mask: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonecache: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Nonelabels: typing.Optional[torch.LongTensor] = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0mm_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.Tensorde forma(batch_size, num_channels, image_size, image_size), opcional) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usandoimage_processor_class. Consulteimage_processor_class.__call__para mais detalhes (processor_classusaimage_processor_classpara processar as imagens). - image_sizes (
torch.Tensorde forma(batch_size, 2), opcional) — Os tamanhos das imagens no lote, sendo (altura, largura) para cada imagem. - input_values (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Valores em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio.flacou.wavem um array do tipolist[float], umnumpy.ndarrayou umtorch.Tensor, por exemplo, por meio da biblioteca torchcodec (pip install torchcodec) ou da biblioteca soundfile (pip install soundfile). Para preparar o array parainput_values, o AutoProcessor deve ser usado para padding e conversão para um tensor do tipotorch.Tensor. Consulteprocessor_class.__call__para mais detalhes. - padding_mask (
torch.Tensorde forma(num_clips, max_length), opcional) — Máscara de amostras de áudio: 1 para amostras válidas, 0 para preenchimento à direita. Obrigatório cominput_values. - 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]. - cache (
~cache_utils.Cache, 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 nocacheretornado 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 kv. Se nenhum
cachefor passado, DynamicCache será inicializado por padrão.O modelo sairá no mesmo formato de cache que é fornecido como entrada.
Se
cacheforem 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 para 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 e valor decachesão retornados e podem ser usados para acelerar a decodificação (vejacache). - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Rótulos do próximo token em[0, output_vocab_size)(ou[0, text_config.vocab_size)quando não definido). Use-100para tokens multimodais apenas de entrada e outras posições ignoradas. - logits_to_keep (
Union[int, torch.Tensor], opcional, padrão0) — Se for umint, calcula os logits para os últimoslogits_to_keeptokens. Se for0, calcula os logits para todos osinput_ids(caso especial). Apenas os logits do último token são necessários para a geração, e calculá-los apenas para esse token pode economizar memória, o que se torna bastante significativo para sequências longas ou tamanho de vocabulário grande. Se for umtorch.Tensor, deve ser 1D, correspondendo aos índices a serem mantidos na dimensão de comprimento da sequência. Isso é útil ao usar o formato de tensor empacotado (uma única dimensão para lote e comprimento da sequência). - 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)
Os logits têm largura text_config.output_vocab_size, ou text_config.vocab_size quando não definido,
com ou sem labels.
O método forward de Apertus1p5ForConditionalGeneration sobrescreve 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.
get_image_features
< source >( pixel_values: Tensorimage_sizes: LongTensor**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Apertus1p5VisionTokenizerModelOutput 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 Apertus1p5ImageProcessor. Veja Apertus1p5ImageProcessor.call() para detalhes (Apertus1p5Processor usa Apertus1p5ImageProcessor para processar imagens). - image_sizes (
torch.LongTensorde forma(batch_size, 2)) — Os tamanhos das imagens no lote, sendo (altura, largura) para cada imagem.
Retorna
Apertus1p5VisionTokenizerModelOutput ou tuple(torch.Tensor)
Um Apertus1p5VisionTokenizerModelOutput 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 (Apertus1p5Config) e das entradas.
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 (
tuple[torch.Tensor], opcional) — Um tensor(num_tokens, hidden_size)de tokens de imagem incorporados por imagem de entrada.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.
image_tokens (
list[torch.LongTensor], opcional) — Um tensor plano de ids de tokens do vocabulário compartilhado por imagem de entrada: seus(height // factor) * (width // factor)códigos em ordem de linha principal, deslocados porconfig.image_token_offset, ondefactoré ospatial_scale_factordo tokenizador de visão (16 por padrão).
Exemplo:
>>> from PIL import Image
>>> from transformers import AutoProcessor, Apertus1p5ForConditionalGeneration
>>> model = Apertus1p5ForConditionalGeneration.from_pretrained("swiss-ai/Apertus-v1.5-8B")
>>> processor = AutoProcessor.from_pretrained("swiss-ai/Apertus-v1.5-8B")
>>> 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_audio_features
< source >( input_values: Tensorpadding_mask: Tensor**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Apertus1p5AudioTokenizerModelOutput or tuple(torch.Tensor)
Parâmetros
- input_values (
torch.Tensorde forma(batch_size, sequence_length)) — Valores em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio.flacou.wavem um array do tipolist[float], umnumpy.ndarrayou umtorch.Tensor, por exemplo, por meio da biblioteca torchcodec (pip install torchcodec) ou da biblioteca soundfile (pip install soundfile). Para preparar o array parainput_values, o AutoProcessor deve ser usado para padding e conversão para um tensor do tipotorch.Tensor. Consulte Apertus1p5Processor.call() para mais detalhes. - padding_mask (
torch.Tensorde forma(num_clips, max_length)) — Máscara com 1 para amostras válidas e 0 para preenchimento, conforme retornado pelo extrator de recursos.
Retorna
Apertus1p5AudioTokenizerModelOutput ou tuple(torch.Tensor)
Um Apertus1p5AudioTokenizerModelOutput 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 (Apertus1p5Config) e das entradas.
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 (
tuple[torch.Tensor], opcional) — Um tensor(num_tokens, hidden_size)de tokens de áudio incorporados por clipe de entrada.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.
audio_tokens (
list[torch.LongTensor], opcional) — Um tensor deceil(num_valid_samples / hop_length)ids de tokens de vocabulário compartilhado por clipe de entrada, deslocado porconfig.audio_token_offset.
Exemplo:
>>> from PIL import Image
>>> from transformers import AutoProcessor, Apertus1p5ForConditionalGeneration
>>> model = Apertus1p5ForConditionalGeneration.from_pretrained("swiss-ai/Apertus-v1.5-8B")
>>> processor = AutoProcessor.from_pretrained("swiss-ai/Apertus-v1.5-8B")
>>> 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]