Transformers documentation
Mistral
Este modelo foi publicado nos HF papers em 2023-10-10 e contribuído para o Hugging Face Transformers em 2023-09-27.
Mistral
Mistral é um modelo de linguagem com 7B parâmetros, disponível em uma variante pré-treinada e em uma variante ajustada por instruções, com foco em equilibrar os custos de escala de modelos grandes com o desempenho e a inferência eficiente. Este modelo usa atenção de janela deslizante (SWA) treinada com um comprimento de contexto de 8K e um tamanho de cache fixo para lidar com sequências mais longas de forma mais eficaz. A atenção de consulta agrupada (GQA) acelera a inferência e reduz os requisitos de memória. O Mistral também possui um tokenizador BPE com fallback de bytes para melhorar o processamento e a eficiência dos tokens, garantindo que os caracteres nunca sejam mapeados para tokens fora do vocabulário.
Você pode encontrar todos os checkpoints originais do Mistral na organização Mistral AI_.
Clique nos modelos Mistral na barra lateral à direita para ver mais exemplos de como aplicar o Mistral a diferentes tarefas de linguagem.
Defina
use_kernels=Trueem from_pretrained() para substituir camadas compatíveis por kernels otimizados do Hub. Consulte Carregando kernels para saber mais.
O exemplo abaixo demonstra como conversar com o Pipeline ou com o AutoModel, e a partir da linha de comando.
from transformers import pipeline
messages = [
{"role": "user", "content": "What is your favourite condiment?"},
{"role": "assistant", "content": "Well, I'm quite partial to a good squeeze of fresh lemon juice. It adds just the right amount of zesty flavour to whatever I'm cooking up in the kitchen!"},
{"role": "user", "content": "Do you have mayonnaise recipes?"}
]
chatbot = pipeline("text-generation", model="mistralai/Mistral-7B-Instruct-v0.3", device=0)
chatbot(messages)from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-Instruct-v0.3", attn_implementation="sdpa", device_map="auto")
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.3")
messages = [
{"role": "user", "content": "What is your favourite condiment?"},
{"role": "assistant", "content": "Well, I'm quite partial to a good squeeze of fresh lemon juice. It adds just the right amount of zesty flavour to whatever I'm cooking up in the kitchen!"},
{"role": "user", "content": "Do you have mayonnaise recipes?"}
]
model_inputs = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device)
generated_ids = model.generate(**model_inputs, max_new_tokens=100, do_sample=True)
tokenizer.batch_decode(generated_ids)[0]
"Mayonnaise can be made as follows: (...)"echo -e "My favorite condiment is" | transformers chat mistralai/Mistral-7B-v0.3 --dtype auto --device 0 --attn_implementation flash_attention_2A quantização reduz a carga de memória de modelos grandes ao representar os pesos em uma precisão menor. Consulte a visão geral de Quantização para mais backends de quantização disponíveis.
O exemplo abaixo usa bitsandbytes para quantizar apenas os pesos para 4 bits.
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
# specify how to quantize the model
quantization_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.float16,
)
model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-Instruct-v0.3", quantization_config=quantization_config, device_map="auto")
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.3")
prompt = "My favourite condiment is"
messages = [
{"role": "user", "content": "What is your favourite condiment?"},
{"role": "assistant", "content": "Well, I'm quite partial to a good squeeze of fresh lemon juice. It adds just the right amount of zesty flavour to whatever I'm cooking up in the kitchen!"},
{"role": "user", "content": "Do you have mayonnaise recipes?"}
]
model_inputs = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device)
generated_ids = model.generate(**model_inputs, max_new_tokens=100, do_sample=True)
tokenizer.batch_decode(generated_ids)[0]
"The expected output"Use o AttentionMaskVisualizer para entender melhor quais tokens o modelo pode e não pode observar.
from transformers.utils.attention_visualizer import AttentionMaskVisualizer
visualizer = AttentionMaskVisualizer("mistralai/Mistral-7B-Instruct-v0.3")
visualizer("Do you have mayonnaise recipes?")
MistralConfig
classe transformers.MistralConfig
< 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 = 32000hidden_size: int = 4096intermediate_size: int = 14336num_hidden_layers: int = 32num_attention_heads: int = 32num_key_value_heads: int = 8head_dim: int | None = Nonehidden_act: str = 'silu'max_position_embeddings: int = 131072initializer_range: float = 0.02rms_norm_eps: float = 1e-06use_cache: bool = Truepad_token_id: int | None = Nonebos_token_id: int | None = 1eos_token_id: int | list[int] | None = 2tie_word_embeddings: bool = Falserope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Nonesliding_window: int | None = 4096attention_dropout: float | int = 0.0 )
Parâmetros
- vocab_size (
int, opcional, padrão32000) — 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, padrão8) — 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. - head_dim (
int, opcional) — A dimensão da cabeça de atenção. Se for None, o valor padrão será hidden_size // num_attention_heads - hidden_act (
str, opcional, padrãosilu) — 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ão131072) — 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-06) — 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) — ID do token usado para preenchimento 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. - sliding_window (
int, opcional, padrão4096) — Tamanho da janela de atenção deslizante. SeNone, nenhuma janela deslizante é aplicada. - attention_dropout (
Union[float, int], opcional, padrão0.0) — A taxa de dropout para as probabilidades de atenção.
Esta é a classe de configuração para armazenar a configuração de um MistralModel. Ela é usada para instanciar um modelo Mistral 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 mistralai/Mistral-7B-v0.1
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 MistralModel, MistralConfig
>>> # Initializing a Mistral 7B style configuration
>>> configuration = MistralConfig()
>>> # Initializing a model from the Mistral 7B style configuration
>>> model = MistralModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configMistralCommonBackend
classe transformers.MistralCommonBackend
< source >( tokenizer_path: str | os.PathLike | pathlib.Pathmode: str | ValidationMode = 'test'model_max_length: int = 1000000000000000019884624838656padding_side: str = 'left'truncation_side: str = 'right'model_input_names: list[str] | None = Noneclean_up_tokenization_spaces: bool = False**kwargs )
Classe para encapsular tokenizadores do mistral-common.
mistral-common é a biblioteca oficial de tokenização para os modelos da Mistral AI. Para usá-la, você precisa instalá-la com:
pip install transformers[mistral-common]
Caso contrário, o tokenizer recorre à implementação do tokenizer da Transformers.
Para mais informações sobre mistral-common, consulte mistral-common.
Esta classe é um wrapper em torno de um mistral_common.tokens.tokenizers.mistral.MistralTokenizer.
Ela fornece uma interface compatível com o Hugging Face para tokenizar usando o tokenizador oficial mistral-common e herda da classe PreTrainedTokenizerBase.
Aqui estão as principais diferenças de comportamento em relação à classe PythonBackend:
- Pares de sequências não são suportados. A assinatura foi mantida por compatibilidade, mas todos os argumentos relacionados a pares de sequências são ignorados. Os valores de retorno para pares são retornados como
None. - O argumento
is_split_into_wordsnão é suportado. - Não é possível adicionar novos tokens ao tokenizer. Os tokens especiais são tratados de forma diferente em Transformers. Em
mistral-common, os tokens especiais nunca são codificados diretamente. Isso significa que:tokenizer.encode("<s>")não retornará o ID do token<s>. Em vez disso, retornará uma lista de IDs correspondente à tokenização da string"<s>". Para mais informações, consulte a documentação do mistral-common.
Se você tiver sugestões para melhorar esta classe, abra uma issue no repositório GitHub mistral-common se estiver relacionada ao tokenizer ou no repositório GitHub Transformers se estiver relacionada à interface do Hugging Face.
add_special_tokens
< source >( special_tokens_dict: dictreplace_extra_special_tokens: bool = True )
MistralCommonBackend não implementa add_special_tokens por design.
Se você deseja que esse comportamento seja implementado, abra uma issue nos repositórios Transformers ou mistral-common para solicitá-lo.
MistralCommonBackend não implementa add_special_tokens por design.
Se você deseja que esse comportamento seja implementado, abra uma issue nos repositórios Transformers ou mistral-common para solicitá-lo.
apply_chat_template
< source >( conversation: list[dict[str, str]] | list[list[dict[str, str]]]tools: list[dict | collections.abc.Callable] | None = Noneadd_generation_prompt: bool = Falsecontinue_final_message: bool = Falsetokenize: bool = Truepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool = Falsemax_length: int | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonereturn_dict: bool = Truereasoning_effort: ReasoningEffort | None = None**kwargs ) → Union[str, list[int], list[str], list[list[int]], BatchEncoding]
Parâmetros
- conversation (Union[List[Dict[str, str]], List[List[Dict[str, str]]]]) — Uma lista de dicts com as chaves “role” e “content”, representando o histórico do chat até o momento.
- tools (
List[Union[Dict, Callable]], opcional) — Uma lista de ferramentas (funções chamáveis) que estarão acessíveis ao modelo. Se o template não suportar function calling, este argumento não terá efeito. Cada ferramenta deve ser passada como um JSON Schema, fornecendo o nome, a descrição e os tipos de argumentos da ferramenta. Consulte nosso guia de chat templating para mais informações. - add_generation_prompt (
bool, opcional) — Este argumento é um no-op paraMistralCommonBackend. No entanto, ele não pode ser usado ao mesmo tempo quecontinue_final_messagepara manter a API consistente. Se alguma conversa terminar com uma mensagem do assistente, será gerado um erro. Nesses casos, usecontinue_final_messageem vez disso. - continue_final_message (bool, opcional) —
Se definido, o chat será formatado de modo que a mensagem final
do chat seja aberta, sem tokens EOS. O modelo continuará essa mensagem
em vez de iniciar uma nova. Isso permite “preencher” parte da
resposta do modelo. Não pode ser usado ao mesmo tempo que
add_generation_prompt. - tokenize (
bool, padrãoTrue) — Se deve tokenizar a saída. SeFalse, a saída será uma string. - padding (
bool,strou PaddingStrategy, opcional, padrão éFalse) — Selecione uma estratégia para aplicar padding às sequências retornadas (de acordo com o lado de padding e o índice de padding do modelo) entre:Trueou'longest': Preenche até a sequência mais longa do lote (ou não aplica preenchimento se apenas uma sequência for fornecida).'max_length': Preenche até o comprimento máximo especificado com o argumentomax_lengthou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido.Falseou'do_not_pad'(padrão): Sem padding (ou seja, pode gerar um lote com sequências de comprimentos diferentes).
- truncation (
bool, padrãoFalse) — Se as sequências devem ser truncadas no comprimento máximo. Não tem efeito se tokenize forFalse. - max_length (
int, opcional) — Comprimento máximo (em tokens) a ser usado para padding ou truncamento. Não tem efeito se tokenize forFalse. Se não for especificado, o atributomax_lengthdo tokenizer será usado como padrão. - return_tensors (
strou TensorType, opcional) — Se definido, retornará tensors de um framework específico. Não tem efeito se tokenize forFalse. Valores aceitos:'pt': Retorna objetostorch.Tensordo PyTorch.
- return_dict (
bool, padrãoFalse) — Indica se deve retornar um dicionário com saídas nomeadas. Não tem efeito se tokenize forFalse. Se pelo menos uma conversa contiver uma imagem, seus valores de pixel serão retornados na chavepixel_valuese os tamanhos das imagens na chaveimage_sizes. - reasoning_effort (
ReasoningEffort, opcional) — O esforço de raciocínio a ser usado para a conclusão do chat em modelos que o suportam. Os valores possíveis são:ReasoningEffort.none: O modelo não realizará raciocínio.ReasoningEffort.high: O modelo utilizará uma abordagem de raciocínio. Se não for especificado, o esforço de raciocínio padrão será utilizado.
- kwargs (argumentos de palavra-chave adicionais, opcional) —
Argumentos adicionais passados para o método
ChatCompletionRequest.from_openaido mistral-common.
Retorna
Union[str, list[int], list[str], list[list[int]], BatchEncoding]
O chat tokenizado até o momento, incluindo os tokens de controle. Esta saída está pronta para ser passada ao modelo, seja diretamente ou por meio de métodos como generate().
Converte uma lista de dicionários com as chaves "role" e "content" em uma lista de ids de tokens.
batch_decode
< source >( sequences: typing.Union[list[int], list[list[int]], numpy.ndarray, ForwardRef('torch.Tensor')]skip_special_tokens: bool = Falseclean_up_tokenization_spaces: bool | None = None**kwargs ) → list[str]
Parâmetros
- sequences (
Union[list[int], list[list[int]], np.ndarray, torch.Tensor]) — Lista de ids de entrada tokenizados. Pode ser obtida usando o método__call__. - skip_special_tokens (
bool, opcional, padrãoFalse) — Indica se os tokens especiais devem ser removidos durante a decodificação. - clean_up_tokenization_spaces (
bool, opcional) — Indica se os espaços de tokenização devem ser limpos. Se forNone, o valor padrão seráself.clean_up_tokenization_spaces. - kwargs (argumentos de palavra-chave adicionais, opcional) —
Não é suportado por
MistralCommonBackend.batch_decode. Acionará um erro se for usado.
Retorna
list[str]
A lista de frases decodificadas.
Converta uma lista de listas de ids de tokens em uma lista de strings chamando decode.
Este método é fornecido para compatibilidade reversa. O método decode agora processa entradas em lote nativamente,
então você pode usar decode diretamente em vez de batch_decode.
build_inputs_with_special_tokens
< source >( token_ids_0: listtoken_ids_1: None = None ) → list[int]
Construa as entradas do modelo a partir de uma sequência adicionando tokens especiais.
Este método constrói dinamicamente as entradas com base no mode do tokenizer:
"test": seq0 [EOS]"finetuning": [BOS] seq0
convert_added_tokens
< source >( obj: tokenizers.AddedToken | typing.Anysave: bool = Falseadd_type_field: bool = True )
MistralCommonBackend não implementa convert_added_tokens por design.
Se você deseja que esse comportamento seja implementado, abra uma issue nos repositórios Transformers ou mistral-common para solicitá-lo.
create_token_type_ids_from_sequences
< source >( token_ids_0: listtoken_ids_1: None = None ) → list[int]
Crie uma máscara de zeros a partir dos ids de tokens com os tokens especiais adicionados.
Mantido para corresponder à implementação do Transformers.
decode
< source >( token_ids: typing.Union[int, list[int], list[list[int]], numpy.ndarray, ForwardRef('torch.Tensor')]skip_special_tokens: bool = Falseclean_up_tokenization_spaces: bool | None = None**kwargs ) → Union[str, list[str]]
Parâmetros
- token_ids (
Union[int, list[int], list[list[int]], np.ndarray, torch.Tensor]) — Uma única sequência ou um lote (lista de sequências) de ids de entrada tokenizados. Pode ser obtido usando o método__call__. - skip_special_tokens (
bool, opcional, padrãoFalse) — Indica se os tokens especiais devem ser removidos durante a decodificação. - clean_up_tokenization_spaces (
bool, opcional) — Indica se os espaços de tokenização devem ser limpos. Se forNone, o valor padrão seráself.clean_up_tokenization_spaces. - kwargs (argumentos de palavra-chave adicionais, opcional) —
Não é suportado por
MistralCommonBackend.decode. Acionará um erro se for usado.
Retorna
Union[str, list[str]]
A string decodificada para uma única sequência, ou uma lista de strings decodificadas para um lote de sequências.
Converte uma sequência de ids em uma string, usando o tokenizer e o vocabulário, com opções para remover tokens especiais e limpar os espaços de tokenização.
encode
< source >( text: str | list[int]text_pair: None = Noneadd_special_tokens: bool = Truepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = Nonemax_length: int | None = Nonestride: int = 0pad_to_multiple_of: int | None = Nonepadding_side: str | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Noneverbose: bool = Truereturn_offsets_mapping: typing.Literal[False] = Falsesplit_special_tokens: typing.Literal[False] = False**kwargs ) → list[int], torch.Tensor
Parâmetros
- text (
stroulist[int]) — A primeira sequência a ser codificada. Pode ser uma string ou uma lista de inteiros (ids de string tokenizada). - text_pair (
None, opcional) — Não é suportado porMistralCommonBackend.encode. Mantido para corresponder à assinatura dePreTrainedTokenizerBase.encode. - add_special_tokens (
bool, opcional, padrãoTrue) — Indica se tokens especiais devem ser adicionados ao codificar as sequências. Isso utiliza a função subjacentePretrainedTokenizerBase.build_inputs_with_special_tokens, que define quais tokens são adicionados automaticamente aos ids de entrada. Isso é útil se você deseja adicionar tokensbosoueosautomaticamente. Quando o Tokenizer é carregado no modofinetuning, ele adiciona tantobosquantoeos. Caso contrário, no modo “test”, ele adiciona apenasbos. - padding (
bool,strou PaddingStrategy, opcional, padrão éFalse) — Ativa e controla o padding. Aceita os seguintes valores:Trueou'longest': Preenche até a sequência mais longa do lote (ou não aplica preenchimento se apenas uma sequência for fornecida).'max_length': Preenche até o comprimento máximo especificado com o argumentomax_lengthou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido.Falseou'do_not_pad'(padrão): Sem padding (ou seja, pode gerar um lote com sequências de comprimentos diferentes).
- truncation (
bool,strou TruncationStrategy, opcional, padrão éFalse) — Ativa e controla a truncagem. Aceita os seguintes valores:Trueou'longest_first': Trunca para um comprimento máximo especificado com o argumentomax_lengthou para o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido.Falseou'do_not_truncate'(padrão): Sem truncamento (ou seja, pode gerar um lote com comprimentos de sequência maiores que o tamanho máximo de entrada aceitável pelo modelo).
- max_length (
int, opcional) — Controla o comprimento máximo a ser usado por um dos parâmetros de truncamento/preenchimento.Se não for definido ou for definido como
None, isso usará o comprimento máximo predefinido do modelo, caso um dos parâmetros de truncamento/preenchimento exija um comprimento máximo. Se o modelo não tiver um comprimento máximo de entrada específico (como o XLNet), o truncamento/preenchimento para um comprimento máximo será desativado. - stride (
int, opcional, padrão 0) — Se definido como um número junto commax_length, os tokens excedentes retornados quandoreturn_overflowing_tokens=Trueconterão alguns tokens do final da sequência truncada retornada para fornecer alguma sobreposição entre as sequências truncadas e excedentes. O valor deste argumento define o número de tokens sobrepostos. - pad_to_multiple_of (
int, opcional) — Se definido, a sequência será preenchida até um múltiplo do valor fornecido. Exige quepaddingesteja ativado. Isso é especialmente útil para habilitar o uso de Tensor Cores em hardware NVIDIA com capacidade de computação>= 7.5(Volta). - padding_side (
str, opcional) — O lado em que o modelo deve ter o padding aplicado. Deve ser selecionado entre [‘right’, ‘left’]. O valor padrão é obtido do atributo de classe com o mesmo nome. - return_tensors (
strou TensorType, opcional) — Se definido, retornará tensors em vez de uma lista de inteiros do Python. Os valores aceitos são:'pt': Retorna objetostorch.Tensordo PyTorch.
- **kwargs — Não suportado por
MistralCommonBackend.encode. Acionará um erro se for usado.
Retorna
list[int], torch.Tensor
Os ids tokenizados do texto.
Converte uma string em uma sequência de ids (inteiros), usando o tokenizer e o vocabulário.
from_pretrained
< source >( pretrained_model_name_or_path: str | os.PathLike*init_inputsmode: str | ValidationMode = 'test'cache_dir: str | os.PathLike | None = Noneforce_download: bool = Falselocal_files_only: bool = Falsetoken: str | bool | None = Nonerevision: str = 'main'model_max_length: int = 1000000000000000019884624838656padding_side: str = 'left'truncation_side: str = 'right'model_input_names: list[str] | None = Noneclean_up_tokenization_spaces: bool = False**kwargs )
Parâmetros
- pretrained_model_name_or_path (
strouos.PathLike) — Pode ser:- Uma string, o model id de um tokenizer predefinido hospedado em um repositório de modelos no huggingface.co.
- Um caminho para um diretório contendo a configuração do tokenizer, por exemplo, salvo
usando o método
MistralCommonBackend.tokenization_mistral_common.save_pretrained, por exemplo,./my_model_directory/.
- mode (
Union[str, ValidationMode], opcional, padrão éValidationMode.test) — Modo de validação para oMistralTokenizertokenizer. Os valores possíveis são:"finetuning"ouValidationMode.finetuning: o modo de ajuste fino."test"ouValidationMode.test: o modo de teste. Ele altera a forma como o tokenizer valida a entrada e prepara a solicitação ao modelo.
- cache_dir (
strouos.PathLike, opcional) — Caminho para um diretório em que os arquivos de vocabulário de um tokenizer predefinido baixado devem ser armazenados em cache, caso o cache padrão não deva ser usado. - force_download (
bool, opcional, padrãoFalse) — Se deve forçar o (re-)download dos arquivos de vocabulário e substituir as versões em cache, caso existam. - token (
strou bool, opcional) — O token a ser usado como autorização de bearer HTTP para arquivos remotos. SeTrue, usará o token gerado ao executarhf auth login(armazenado em~/.huggingface). - local_files_only (
bool, opcional, padrãoFalse) — Indica se deve-se confiar apenas em arquivos locais e não tentar baixar nenhum arquivo. - revision (
str, opcional, padrão"main") — A versão específica do modelo a ser usada. Pode ser o nome de um branch, o nome de uma tag ou um id de commit, pois utilizamos um sistema baseado em git para armazenar modelos e outros artefatos no huggingface.co, de modo querevisionpode ser qualquer identificador permitido pelo git. - max_length (
int, opcional) — Controla o comprimento máximo a ser usado por um dos parâmetros de truncamento/preenchimento.Se não for definido ou for definido como
None, isso usará o comprimento máximo predefinido do modelo, caso um dos parâmetros de truncamento/preenchimento exija um comprimento máximo. Se o modelo não tiver um comprimento máximo de entrada específico (como o XLNet), o truncamento/preenchimento para um comprimento máximo será desativado. - padding_side (
str, opcional, padrão"left") — O lado em que o modelo deve ter o padding aplicado. Deve ser selecionado entre [‘right’, ‘left’]. O valor padrão é obtido do atributo de classe com o mesmo nome. - truncation_side (
str, opcional, padrão"right") — O lado em que o modelo deve ter a truncagem aplicada. Deve ser selecionado entre [‘right’, ‘left’]. - model_input_names (
List[str], opcional) — A lista de entradas aceitas pela passagem direta do modelo (como"token_type_ids"ou"attention_mask"). O valor padrão é obtido do atributo de classe com o mesmo nome. - clean_up_tokenization_spaces (
bool, opcional, padrãoFalse) — Se o modelo deve ou não limpar os espaços que foram adicionados ao dividir o texto de entrada durante o processo de tokenização. - kwargs (argumentos de palavra-chave adicionais, opcional) —
Não é suportado por
MistralCommonBackend.from_pretrained. Acionará um erro se for usado.
Instancie um MistralCommonBackend a partir de um
tokenizer predefinido.
MistralCommonBackend não implementa get_chat_template por design, pois mistral-common não utiliza modelos de chat.
get_special_tokens_mask
< source >( token_ids_0: listtoken_ids_1: None = Nonealready_has_special_tokens: bool = False ) → A list of integers in the range [0, 1]
Parâmetros
- token_ids_0 (
list[int]) — Lista de ids da sequência. - token_ids_1 (
None, opcional) — None, mantido para corresponder à implementação do Transformers. - already_has_special_tokens (
bool, opcional, padrãoFalse) — Indica se a lista de tokens já está formatada com tokens especiais para o modelo.
Retorna
Uma lista de inteiros no intervalo [0, 1]
1 para um token especial, 0 para um token de sequência.
Recupera os ids de sequência de uma lista de tokens que não possui tokens especiais adicionados. Este método é chamado ao adicionar tokens especiais usando os métodos prepare_for_model ou encode_plus do tokenizer.
Retorna o vocabulário como um dicionário de token para índice.
Esta é uma conversão com perda de dados. Pode haver vários ids de token que decodificam para a mesma string, devido a sequências parciais de bytes UTF-8 sendo convertidas em �.
num_special_tokens_to_add
< source >( pair: typing.Literal[False] = False ) → int
Retorna o número de tokens adicionados ao codificar uma sequência com tokens especiais.
Isso codifica uma entrada fictícia e verifica o número de tokens adicionados, e portanto não é eficiente. Não coloque isso dentro do seu loop de treinamento.
prepare_for_model
< source >( ids: listpair_ids: None = Noneadd_special_tokens: bool = Truepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = Nonemax_length: int | None = Nonestride: int = 0pad_to_multiple_of: int | None = Nonepadding_side: str | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonereturn_token_type_ids: bool | None = Nonereturn_attention_mask: bool | None = Nonereturn_overflowing_tokens: bool = Falsereturn_special_tokens_mask: bool = Falsereturn_length: bool = Falseverbose: bool = Trueprepend_batch_axis: bool = Falsereturn_offsets_mapping: typing.Literal[False] = Falsesplit_special_tokens: typing.Literal[False] = False**kwargs ) → BatchEncoding
Parâmetros
- ids (
list[int]) — IDs de entrada tokenizados da primeira sequência. - pair_ids (
None, opcional) — Não é suportado peloMistralCommonBackend. Mantido para corresponder à interface doPreTrainedTokenizerBase. - add_special_tokens (
bool, opcional, padrãoTrue) — Indica se tokens especiais devem ser adicionados ao codificar as sequências. Isso utiliza a função subjacentePretrainedTokenizerBase.build_inputs_with_special_tokens, que define quais tokens são adicionados automaticamente aos ids de entrada. Isso é útil se você deseja adicionar tokensbosoueosautomaticamente. Quando o Tokenizer é carregado no modofinetuning, ele adiciona tantobosquantoeos. Caso contrário, no modo “test”, ele adiciona apenasbos. - padding (
bool,strou PaddingStrategy, opcional, padrão éFalse) — Ativa e controla o padding. Aceita os seguintes valores:Trueou'longest': Preenche até a sequência mais longa do lote (ou não aplica preenchimento se apenas uma sequência for fornecida).'max_length': Preenche até o comprimento máximo especificado com o argumentomax_lengthou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido.Falseou'do_not_pad'(padrão): Sem padding (ou seja, pode gerar um lote com sequências de comprimentos diferentes).
- truncation (
bool,strou TruncationStrategy, opcional, padrão éFalse) — Ativa e controla a truncagem. Aceita os seguintes valores:Trueou'longest_first': Trunca para um comprimento máximo especificado com o argumentomax_lengthou para o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido.Falseou'do_not_truncate'(padrão): Sem truncamento (ou seja, pode gerar um lote com comprimentos de sequência maiores que o tamanho máximo de entrada aceitável pelo modelo).
- max_length (
int, opcional) — Controla o comprimento máximo a ser usado por um dos parâmetros de truncamento/preenchimento.Se não for definido ou for definido como
None, isso usará o comprimento máximo predefinido do modelo, caso um dos parâmetros de truncamento/preenchimento exija um comprimento máximo. Se o modelo não tiver um comprimento máximo de entrada específico (como o XLNet), o truncamento/preenchimento para um comprimento máximo será desativado. - stride (
int, opcional, padrão 0) — Se definido como um número junto commax_length, os tokens excedentes retornados quandoreturn_overflowing_tokens=Trueconterão alguns tokens do final da sequência truncada retornada para fornecer alguma sobreposição entre as sequências truncadas e excedentes. O valor deste argumento define o número de tokens sobrepostos. - pad_to_multiple_of (
int, opcional) — Se definido, a sequência será preenchida até um múltiplo do valor fornecido. Exige quepaddingesteja ativado. Isso é especialmente útil para habilitar o uso de Tensor Cores em hardware NVIDIA com capacidade de computação>= 7.5(Volta). - padding_side (
str, opcional) — O lado em que o modelo deve ter o padding aplicado. Deve ser selecionado entre [‘right’, ‘left’]. O valor padrão é obtido do atributo de classe com o mesmo nome. - return_tensors (
strou TensorType, opcional) — Se definido, retornará tensors em vez de uma lista de inteiros do Python. Os valores aceitos são:'pt': Retorna objetostorch.Tensordo PyTorch.
- return_token_type_ids (
bool, opcional) — Se deve retornar os IDs de tipo de token. ParaMistralCommonBackendele retorna uma lista de zeros com o comprimento da sequência, pois apenas uma sequência é suportada. - return_attention_mask (
bool, opcional) — Se deve retornar a attention mask. Se mantido o valor padrão, a attention mask será retornada de acordo com o padrão do tokenizer específico, definido pelo atributoreturn_outputs. - return_overflowing_tokens (
bool, opcional, padrãoFalse) — Indica se as sequências de tokens excedentes devem ser retornadas. Se um par de sequências de ids de entrada (ou um lote de pares) for fornecido comtruncation_strategy = longest_firstouTrue, um erro será lançado em vez de retornar os tokens excedentes. - return_special_tokens_mask (
bool, opcional, padrãoFalse) — Indica se a máscara de tokens especiais deve ser retornada. - return_length (
bool, opcional, padrãoFalse) — Indica se as comprimentos das entradas codificadas devem ser retornados. - verbose (
bool, opcional, padrãoTrue) — Se deve ou não exibir mais informações e avisos. - return_offsets_mapping (
Literal[False], opcional) — False, mantido para corresponder à assinatura do Transformers. - split_special_tokens (
Literal[False], opcional) — False, mantido para corresponder à assinatura do Transformers. - **kwargs — passados para o método
self.tokenize()
Retorna
Um BatchEncoding com os seguintes campos:
-
input_ids — Lista de ids de tokens a serem fornecidos a um modelo.
-
attention_mask — Lista de índices que especifica quais tokens devem ser considerados pelo modelo (quando
return_attention_mask=Trueou se “attention_mask” estiver emself.model_input_names). -
overflowing_tokens — Lista de sequências de tokens excedentes (quando um
max_lengthé especificado ereturn_overflowing_tokens=True). -
num_truncated_tokens — Número de tokens truncados (quando um
max_lengthé especificado ereturn_overflowing_tokens=True). -
special_tokens_mask — Lista de 0s e 1s, em que 1 especifica tokens especiais adicionados e 0 especifica tokens regulares da sequência (quando
add_special_tokens=Trueereturn_special_tokens_mask=True). -
length — O comprimento das entradas (quando
return_length=True)
Prepara uma sequência de ids de entrada para que possa ser usada pelo modelo. Adiciona tokens especiais, truncando sequências em caso de estouro, considerando os tokens especiais, e gerencia uma janela móvel (com passo definido pelo usuário) para tokens que excedem o limite.
save_chat_templates
< source >( save_directory: str | os.PathLiketokenizer_config: dictfilename_prefix: str | Nonesave_jinja_files: bool )
MistralCommonBackend não implementa save_chat_templates por design, pois mistral-common não utiliza chat templates.
save_pretrained
< source >( save_directory: str | os.PathLike | pathlib.Pathpush_to_hub: bool = Falsetoken: str | bool | None = Nonecommit_message: str | None = Nonerepo_id: str | None = Noneprivate: bool | None = Nonesave_format: str | None = None**kwargs ) → tuple[str, ...]
Parâmetros
- save_directory (
str | os.PathLike | Path) — Diretório onde o tokenizer será salvo. - push_to_hub (
bool, opcional, padrãoFalse) — Envia para o HF Hub após salvar. - token (
stroubool, opcional) — Token para autenticação no Hub. - commit_message (
str, opcional) — Mensagem de commit ao fazer push. - repo_id (
str, opcional) — ID do repositório no Hub. - private (
bool, opcional) — Indica se o repositório é privado. - save_format (
str, opcional) —"mistral"para salvar no formato nativo tekken,"hf"para o formato HuggingFace. None preserva o formato original. - kwargs (
dict, opcional) — Não suportado — lançará um erro.
Retorna
tuple[str, ...]
Caminhos dos arquivos salvos.
Salve o estado completo do tokenizer.
Quando save_format é "mistral" (ou None para um tokenizer tekken),
o arquivo original do tokenizer (por exemplo, tekken.json) é gravado em save_directory. Quando save_format é "hf", os arquivos em formato HF
(tokenizer.json + tokenizer_config.json) são gerados em vez disso.
MistralCommonBackend não implementa save_vocabulary por design.
Isso ocorre porque o mistral-common é configurado por um único arquivo de tokenizer. Se você deseja salvar o vocabulário, considere usar o método save_pretrained em vez disso.
tokenize
< source >( text: strreturn_offsets_mapping: typing.Literal[False] = Falsesplit_special_tokens: typing.Literal[False] = False**kwargs ) → list[str]
Parâmetros
- text (
str) — A sequência a ser codificada. - return_offsets_mapping (
Literal[False], opcional) — False, mantido para corresponder à assinatura do Transformers. - split_special_tokens (
Literal[False], opcional) — False, mantido para corresponder à assinatura do Transformers. - **kwargs (argumentos de palavra-chave adicionais) —
Não suportado por
MistralCommonBackend.tokenize. Acionará um erro se for usado.
Retorna
list[str]
A lista de tokens.
Converte uma string em uma sequência de tokens, usando o tokenizer.
Divida em palavras para vocabulários baseados em palavras ou em subpalavras para vocabulários baseados em subpalavras.
truncate_sequences
< source >( ids: listpair_ids: None = Nonenum_tokens_to_remove: int = 0truncation_strategy: str | transformers.tokenization_utils_base.TruncationStrategy = 'longest_first'stride: int = 0**kwargs ) → Tuple[list[int], None, list[int]]
Parâmetros
- ids (
list[int]) — IDs de entrada tokenizados. Podem ser obtidos a partir de uma string encadeando os métodostokenizeeconvert_tokens_to_ids. - pair_ids (
None, opcional) — Não é suportado peloMistralCommonBackend. Mantido para corresponder à assinatura dePreTrainedTokenizerBase.truncate_sequences. - num_tokens_to_remove (
int, opcional, padrão 0) — Número de tokens a serem removidos usando a estratégia de truncamento. - truncation_strategy (
strou TruncationStrategy, opcional, padrão é'longest_first') — A estratégia a ser seguida para a truncagem. Pode ser:'longest_first': Trunca para o comprimento máximo especificado com o argumentomax_lengthou para o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido.'do_not_truncate'(padrão): Sem truncamento (ou seja, pode gerar um lote com comprimentos de sequência maiores que o tamanho máximo de entrada aceito pelo modelo).
- stride (
int, opcional, padrão 0) — Se definido como um número positivo, os tokens de estouro retornados incluirão alguns tokens da sequência principal retornada. O valor deste argumento define o número de tokens adicionais.
Retorna
Tuple[list[int], None, list[int]]
Os ids truncados e a lista de
tokens que excedem o limite. None é retornado para corresponder à assinatura do Transformers.
Trunca um par de sequências no local, seguindo a estratégia.
MistralModel
classe transformers.MistralModel
< source >( config: MistralConfig )
Parâmetros
- config (MistralConfig) — 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 Mistral puro, que gera os hidden-states brutos sem nenhum head 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] = Nonepast_key_values: 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]. - past_key_values (
~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 nopast_key_valuesretornado 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).
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 (MistralConfig) e das entradas.
O método forward do MistralModel 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.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.
MistralForCausalLM
classe transformers.MistralForCausalLM
< source >( config: MistralConfig )
Parâmetros
- config (MistralConfig) — 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 Mistral 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] = Nonepast_key_values: 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]. - past_key_values (
~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 nopast_key_valuesretornado 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). - 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)
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 (MistralConfig) e das entradas.
O método forward de MistralForCausalLM 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 transformers import AutoTokenizer, MistralForCausalLM
>>> model = MistralForCausalLM.from_pretrained("meta-mistral/Mistral-2-7b-hf")
>>> tokenizer = AutoTokenizer.from_pretrained("meta-mistral/Mistral-2-7b-hf")
>>> prompt = "Hey, are you conscious? Can you talk to me?"
>>> inputs = tokenizer(prompt, return_tensors="pt")
>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=30)
>>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"Hey, are you conscious? Can you talk to me?\nI'm not conscious, but I can talk to you."MistralForSequenceClassification
forward
< source >( input_ids: torch.LongTensor | None = Noneattention_mask: torch.Tensor | None = Noneposition_ids: torch.LongTensor | None = Nonepast_key_values: Cache | None = Noneinputs_embeds: torch.Tensor | None = Nonelabels: torch.LongTensor | None = Noneuse_cache: bool | None = None**kwargs: Unpack[TransformersKwargs] ) → SequenceClassifierOutputWithPast
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]. - past_key_values (
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 nopast_key_valuesretornado 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,), opcional) — Rótulos para o cálculo da perda de classificação/regressão de sequência. Os índices devem estar em[0, ..., config.num_labels - 1]. Seconfig.num_labels == 1, uma perda de regressão é calculada (perda de erro quadrático médio). Seconfig.num_labels > 1, uma perda de classificação é calculada (entropia cruzada). - 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).
Retorna
SequenceClassifierOutputWithPast
O método forward da GenericForSequenceClassification 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.
MistralForTokenClassification
forward
< source >( input_ids: torch.LongTensor | None = Noneattention_mask: torch.Tensor | None = Noneposition_ids: torch.LongTensor | None = Nonepast_key_values: Cache | None = Noneinputs_embeds: torch.Tensor | None = Nonelabels: torch.LongTensor | None = Noneuse_cache: bool | None = None**kwargs: Unpack[TransformersKwargs] ) → TokenClassifierOutput
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]. - past_key_values (
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 nopast_key_valuesretornado 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 classificação de tokens. Os índices devem estar em[0, ..., config.num_labels - 1]. - 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).
Retorna
TokenClassifierOutput
O método forward de GenericForTokenClassification 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.
MistralForQuestionAnswering
forward
< source >( input_ids: torch.LongTensor | None = Noneattention_mask: torch.Tensor | None = Noneposition_ids: torch.LongTensor | None = Nonepast_key_values: Cache | None = Noneinputs_embeds: torch.Tensor | None = Nonestart_positions: torch.LongTensor | None = Noneend_positions: torch.LongTensor | None = None**kwargs: Unpack[TransformersKwargs] ) → QuestionAnsweringModelOutput
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]. - past_key_values (
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 nopast_key_valuesretornado 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. - start_positions (
torch.LongTensorde forma(batch_size,), opcional) — Rótulos para a posição (índice) do início do trecho rotulado para o cálculo da perda de classificação de tokens. As posições são limitadas ao comprimento da sequência (sequence_length). Posições fora da sequência não são consideradas no cálculo da perda. - end_positions (
torch.LongTensorde forma(batch_size,), opcional) — Rótulos para a posição (índice) do final do trecho rotulado, para o cálculo da perda de classificação de tokens. As posições são limitadas ao comprimento da sequência (sequence_length). Posições fora da sequência não são consideradas no cálculo da perda.
Retorna
QuestionAnsweringModelOutput
O método GenericForQuestionAnswering forward 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.