Transformers documentation
Mixtral
Este modelo se publicó en HF papers el 2024-01-08 y se contribuyó a Hugging Face Transformers el 2023-12-11.
Mixtral
Resumen
Mixtral-8x7B se presentó en el post del blog Mixtral of Experts de Albert Jiang, Alexandre Sablayrolles, Arthur Mensch, Chris Bamford, Devendra Singh Chaplot, Diego de las Casas, Florian Bressand, Gianna Lengyel, Guillaume Lample, Lélio Renard Lavaud, Lucile Saulnier, Marie-Anne Lachaux, Pierre Stock, Teven Le Scao, Thibaut Lavril, Thomas Wang, Timothée Lacroix, William El Sayed.
La introducción de la publicación del blog dice:
Hoy, el equipo se enorgullece de lanzar Mixtral 8x7B, un modelo de alta calidad de mezcla de expertos dispersos (SMoE) con pesos abiertos. Está licenciado bajo Apache 2.0. Mixtral supera a Llama 2 70B en la mayoría de los benchmarks con una inferencia 6 veces más rápida. Es el modelo de pesos abiertos más potente con una licencia permisiva y el mejor modelo en general en cuanto a la relación costo/rendimiento. En particular, iguala o supera a GPT3.5 en la mayoría de los benchmarks estándar.
Mixtral-8x7B es el segundo modelo de lenguaje de gran escala (LLM) publicado por mistral.ai, después de Mistral-7B.
Detalles de la arquitectura
Mixtral-8x7B es un Transformer solo decodificador con las siguientes decisiones arquitectónicas:
- Mixtral es un modelo de Mixture of Experts (MoE) con 8 expertos por MLP, con un total de 45 mil millones de parámetros. Para obtener más información sobre mixture-of-experts, consulte la entrada de blog.
- Aunque el modelo tiene 45 mil millones de parámetros, la potencia de cálculo necesaria para una sola pasada hacia adelante es la misma que la de un modelo de 14 mil millones de parámetros. Esto se debe a que, aunque cada uno de los expertos debe cargarse en la RAM (requerimiento de RAM de 70B), cada token de los estados ocultos se despacha dos veces (enrutamiento top 2) y, por lo tanto, el cálculo (la operación requerida en cada cómputo hacia adelante) es simplemente 2 X sequence_length.
Los siguientes detalles de implementación se comparten con el primer modelo de Mistral AI, Mistral-7B:
- Atención con ventana deslizante - Entrenado con una longitud de contexto de 8k y un tamaño de caché fijo, con un alcance teórico de atención de 128K tokens
- GQA (Grouped Query Attention) - permite una inferencia más rápida y un menor tamaño de caché.
- Tokenizador BPE con respaldo por bytes: garantiza que los caracteres nunca se mapeen a tokens fuera de vocabulario.
Para más detalles, consulte la publicación del blog de la versión.
Licencia
Mixtral-8x7B se publica bajo la licencia Apache 2.0.
Consejos de uso
El equipo de Mistral ha publicado 2 puntos de control:
- un modelo base, Mixtral-8x7B-v0.1, que ha sido preentrenado para predecir el siguiente token en datos a escala de internet.
- un modelo ajustado con instrucciones, Mixtral-8x7B-Instruct-v0.1, que es el modelo base optimizado para fines de chat mediante ajuste fino supervisado (SFT) y optimización de preferencias directas (DPO).
El modelo base se puede utilizar de la siguiente manera:
from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("mistralai/Mixtral-8x7B-v0.1", device_map="auto")
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mixtral-8x7B-v0.1")
prompt = "My favourite condiment is"
model_inputs = tokenizer([prompt], 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]
"My favourite condiment is to ..."El modelo ajustado con instrucciones se puede utilizar de la siguiente manera:
from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("mistralai/Mixtral-8x7B-Instruct-v0.1", device_map="auto")
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mixtral-8x7B-Instruct-v0.1")
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: (...)"Como se puede ver, el modelo ajustado con instrucciones requiere aplicar una plantilla de chat para asegurarse de que las entradas se preparen en el formato correcto.
Acelerar Mixtral usando Flash Attention
Los fragmentos de código anteriores muestran la inferencia sin ningún truco de optimización. Sin embargo, es posible acelerar drásticamente el modelo aprovechando Flash Attention, que es una implementación más rápida del mecanismo de atención utilizado dentro del modelo.
Primero, asegúrate de instalar la última versión de Flash Attention 2 para incluir la función de atención con ventana deslizante.
pip install -U flash-attn --no-build-isolation
Asegúrate también de que dispongas de un hardware compatible con Flash-Attention 2. Consulta más información al respecto en la documentación oficial del repositorio de flash attention. Asegúrate también de cargar tu modelo en media precisión (p. ej. torch.float16)
Para cargar y ejecutar un modelo usando Flash Attention-2, consulte el fragmento de código a continuación:
from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("mistralai/Mixtral-8x7B-v0.1", attn_implementation="flash_attention_2", device_map="auto")
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mixtral-8x7B-v0.1")
prompt = "My favourite condiment is"
model_inputs = tokenizer([prompt], 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"Aceleraciones esperadas
A continuación se muestra un diagrama de la aceleración esperada que compara el tiempo de inferencia puro entre la implementación nativa en transformers que utiliza el punto de control mistralai/Mixtral-8x7B-v0.1 y la versión del modelo con Flash Attention 2.
Atención con ventana deslizante
La implementación actual admite el mecanismo de atención con ventana deslizante y la gestión de caché eficiente en memoria.
Para habilitar la atención con ventana deslizante, asegúrese de tener una versión de flash-attn compatible con la atención con ventana deslizante (>=2.3.0).
El modelo Flash Attention-2 utiliza también un mecanismo de segmentación de caché más eficiente en memoria: tal como se recomienda en la implementación oficial del modelo Mistral, que utiliza un mecanismo de caché deslizante, mantenemos el tamaño de la caché fijo (self.config.sliding_window), solo admitimos la generación por lotes para padding_side="left" y usamos la posición absoluta del token actual para calcular el incrustado posicional.
Reducir Mixtral mediante cuantización
Dado que el modelo Mixtral tiene 45 mil millones de parámetros, esto requeriría aproximadamente 90 GB de RAM de GPU en media precisión (float16), ya que cada parámetro se almacena en 2 bytes. Sin embargo, es posible reducir el tamaño del modelo mediante cuantización. Si el modelo se cuantiza a 4 bits (o medio byte por parámetro), una sola A100 con 40 GB de RAM es suficiente para alojar el modelo completo, ya que en ese caso solo se requieren aproximadamente 27 GB de RAM.
Cuantizar un modelo es tan sencillo como pasar un quantization_config al modelo. A continuación, utilizaremos la biblioteca de cuantización bitsandbytes (pero consulte esta página para métodos de cuantización alternativos):
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/Mixtral-8x7B-Instruct-v0.1", quantization_config=True, device_map="auto")
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mixtral-8x7B-Instruct-v0.1")
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"Este modelo fue aportado por Younes Belkada y Arthur Zucker. El código original se puede encontrar aquí.
Recursos
Una lista de recursos oficiales de Hugging Face y de la comunidad (indicados con 🌎) para ayudarte a empezar con Mixtral. Si te interesa enviar un recurso para que se incluya aquí, no dudes en abrir una Pull Request y lo revisaremos. Lo ideal es que el recurso demuestre algo nuevo en lugar de duplicar un recurso existente.
- Puede encontrar un cuaderno de demostración para realizar el ajuste fino supervisado (SFT) de Mixtral-8x7B aquí. 🌎
- Una entrada de blog sobre el ajuste fino de Mixtral-8x7B usando PEFT. 🌎
- El Alignment Handbook de Hugging Face incluye scripts y recetas para realizar fine-tuning supervisado (SFT) y optimización de preferencias directas con Mistral-7B. Esto incluye scripts para fine-tuning completo, QLoRa en un solo acelerador y fine-tuning multiacelerador.
- Guía de la tarea de modelado de lenguaje causal
MixtralConfig
clase transformers.MixtralConfig
< 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-05use_cache: bool = Truepad_token_id: int | None = Nonebos_token_id: int | None = 1eos_token_id: int | list[int] | None = 2tie_word_embeddings: bool = Falsesliding_window: int | None = Noneattention_dropout: float | int = 0.0num_experts_per_tok: int = 2num_local_experts: int = 8output_router_logits: bool = Falserouter_aux_loss_coef: float = 0.001router_jitter_noise: float = 0.0rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None )
Parámetros
- vocab_size (
int, opcional, valor predeterminado32000) — Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse medianteinput_ids. - hidden_size (
int, opcional, valor predeterminado4096) — Dimensión de las representaciones ocultas. - intermediate_size (
int, opcional, valor predeterminado14336) — Dimensión de las representaciones del MLP. - num_hidden_layers (
int, opcional, valor predeterminado32) — Número de capas ocultas en el decodificador del Transformer. - num_attention_heads (
int, opcional, valor predeterminado32) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer. - num_key_value_heads (
int, opcional, valor predeterminado8) — Este es el número de cabezas key_value que se deben utilizar para implementar Grouped Query Attention. Sinum_key_value_heads=num_attention_heads, el modelo utilizará Multi Head Attention (MHA); sinum_key_value_heads=1, el modelo utilizará Multi Query Attention (MQA); en caso contrario, se utilizará GQA. Al convertir un checkpoint multi-head en un checkpoint GQA, cada cabeza de clave y valor del grupo debe construirse mediante el promediado (meanpooling) de todas las cabezas originales dentro de ese grupo. Para más detalles, consulta este artículo. Si no se especifica, el valor predeterminado seránum_attention_heads. - head_dim (
int, opcional) — La dimensión de la cabeza de atención. Si es None, se establecerá en hidden_size // num_attention_heads - hidden_act (
str, opcional, valor predeterminadosilu) — La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo,"gelu","relu","silu", etc. - max_position_embeddings (
int, opcional, valor predeterminado131072) — La longitud máxima de secuencia con la que podría utilizarse este modelo. - initializer_range (
float, opcional, valor predeterminado0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos. - rms_norm_eps (
float, opcional, valor predeterminado1e-05) — La epsilon utilizada por las capas de normalización rms. - use_cache (
bool, opcional, valor predeterminadoTrue) — Indica si el modelo debe devolver las últimas claves/valores de atención (no utilizado por todos los modelos). Solo es relevante siconfig.is_decoder=Trueo cuando el modelo es un modelo generativo solo de decodificador. - pad_token_id (
int, opcional) — Id del token utilizado para el relleno en el vocabulario. - bos_token_id (
int, opcional, valor predeterminado1) — Id del token utilizado para el inicio de la secuencia en el vocabulario. - eos_token_id (
Union[int, list[int]], opcional, valor predeterminado2) — Identificador de token utilizado para el fin de secuencia en el vocabulario. - tie_word_embeddings (
bool, opcional, valor predeterminadoFalse) — Si se deben vincular las matrices de pesos de embeddings según el mapeotied_weights_keysdel modelo. - sliding_window (
int, opcional) — Tamaño de la ventana de atención deslizante. Si esNone, no se aplica ninguna ventana deslizante. - attention_dropout (
Union[float, int], opcional, valor predeterminado0.0) — La proporción de dropout para las probabilidades de atención. - num_experts_per_tok (
int, opcional, valor predeterminado2) — Número de expertos a los que enrutar cada token. Este es el valor top-k para el enrutamiento de selección de tokens. - num_local_experts (
int, opcional, valor predeterminado8) — Número de expertos locales en cada dispositivo.num_expertsdebe ser divisible entrenum_local_experts. - output_router_logits (
bool, opcional, valor predeterminadoFalse) — Indica si el modelo debe devolver los logits del router. Habilitar esta opción también permite que el modelo devuelva la pérdida auxiliar, que incluye la pérdida de equilibrio de carga y la pérdida z del router. - router_aux_loss_coef (
float, opcional, valor predeterminado0.001) — Coeficiente de la pérdida auxiliar de equilibrado de carga. Se utiliza para penalizar el enrutamiento desigual de expertos en modelos MoE. - router_jitter_noise (
float, opcional, valor predeterminado0.0) — Cantidad de ruido que se añade a los logits del router durante el entrenamiento para mejorar el equilibrio de carga. - rope_parameters (
Union[~modeling_rope_utils.RopeParameters, dict], opcional) — Diccionario que contiene los parámetros de configuración para las incrustaciones RoPE. El diccionario debe contener un valor pararope_thetay, opcionalmente, parámetros utilizados para el escalado en caso de que desee usar RoPE conmax_position_embeddingsmás largos.
Esta es la clase de configuración para almacenar la configuración de un MixtralModel. Se utiliza para instanciar un modelo Mixtral según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de mistralai/Mixtral-8x7B-v0.1
Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.
Ejemplo:
>>> from transformers import MixtralModel, MixtralConfig
>>> # Initializing a Mixtral 7B style configuration
>>> configuration = MixtralConfig()
>>> # Initializing a model from the Mixtral 7B style configuration
>>> model = MixtralModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configMistralCommonBackend
clase 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 )
Clase para envolver los tokenizadores de mistral-common.
mistral-common es la biblioteca de tokenización oficial para los modelos de Mistral AI. Para usarla, debes instalarla con:
pip install transformers[mistral-common]
En caso contrario, el tokenizador recurre a la implementación del tokenizador de Transformers.
Para obtener más información sobre mistral-common, consulte mistral-common.
Esta clase es un envoltorio de mistral_common.tokens.tokenizers.mistral.MistralTokenizer.
Proporciona una interfaz compatible con Hugging Face para tokenizar usando el tokenizador oficial de mistral-common y hereda de la clase PreTrainedTokenizerBase.
Estas son las diferencias clave de comportamiento con la clase PythonBackend:
- No se admiten pares de secuencias. La firma se ha mantenido por compatibilidad, pero se ignoran todos los argumentos relacionados con pares de secuencias. Los valores de retorno para pares se devuelven como
None. - El argumento
is_split_into_wordsno se admite. - No es posible agregar nuevos tokens al tokenizer. Los tokens especiales se manejan de manera diferente en Transformers. En
mistral-common, los tokens especiales nunca se codifican directamente. Esto significa que:tokenizer.encode("<s>")no devolverá el ID del token<s>. En su lugar, devolverá una lista de IDs correspondientes a la tokenización de la cadena"<s>". Para obtener más información, consulte la documentación de mistral-common.
Si tienes sugerencias para mejorar esta clase, abre un issue en el repositorio de GitHub de mistral-common si está relacionado con el tokenizador o en el repositorio de GitHub de Transformers si está relacionado con la interfaz de Hugging Face.
add_special_tokens
< source >( special_tokens_dict: dictreplace_extra_special_tokens: bool = True )
MistralCommonBackend no implementa add_special_tokens por diseño.
Si desea que se implemente este comportamiento, abra un issue en los repositorios Transformers o mistral-common para solicitarlo.
MistralCommonBackend no implementa add_special_tokens por diseño.
Si desea que se implemente este comportamiento, abra un issue en los repositorios Transformers o mistral-common para solicitarlo.
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]]]]) — Una lista de diccionarios con las claves “role” y “content”, que representa el historial de la conversación hasta el momento.
- tools (
List[Union[Dict, Callable]], opcional) — Una lista de herramientas (funciones invocables) que estarán accesibles para el modelo. Si la plantilla no soporta la invocación de funciones, este argumento no tendrá efecto. Cada herramienta debe pasarse como un JSON Schema, indicando el nombre, la descripción y los tipos de argumentos de la herramienta. Consulte nuestra guía de plantillas de chat para obtener más información. - add_generation_prompt (
bool, opcional) — Este argumento no tiene efecto paraMistralCommonBackend. Sin embargo, no puede usarse al mismo tiempo quecontinue_final_messagepara mantener la API consistente. Si alguna conversación termina con un mensaje del asistente, se generará un error. En tales casos, usecontinue_final_messageen su lugar. - continue_final_message (bool, opcional) —
Si se establece, el chat se formateará de modo que el mensaje final del chat sea de final abierto, sin tokens EOS. El modelo continuará este mensaje en lugar de comenzar uno nuevo. Esto le permite “prellenar” parte de la respuesta del modelo. No se puede usar al mismo tiempo que
add_generation_prompt. - tokenize (
bool, por defectoTrue) — Si se debe tokenizar la salida. Si esFalse, la salida será una cadena de texto. - padding (
bool,stro PaddingStrategy, opcional, por defectoFalse) — Seleccione una estrategia para rellenar las secuencias devueltas (según el lado de relleno y el índice de relleno del modelo) entre:Trueo'longest': Rellena hasta la secuencia más larga del lote (o no aplica relleno si solo se proporciona una secuencia).'max_length': Rellena hasta una longitud máxima especificada con el argumentomax_lengtho hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento.Falseo'do_not_pad'(predeterminado): Sin relleno (es decir, puede generar un lote con secuencias de diferentes longitudes).
- truncation (
bool, por defectoFalse) — Si se deben truncar las secuencias en la longitud máxima. No tiene efecto si tokenize esFalse. - max_length (
int, opcional) — Longitud máxima (en tokens) para usar en el relleno o la truncación. No tiene efecto si tokenize esFalse. Si no se especifica, se usará el atributomax_lengthdel tokenizador como valor predeterminado. - return_tensors (
stro TensorType, opcional) — Si se establece, devolverá tensores de un marco de trabajo específico. No tiene efecto si tokenize esFalse. Los valores aceptables son:'pt': Devuelve objetostorch.Tensorde PyTorch.
- return_dict (
bool, por defectoFalse) — Si se debe devolver un diccionario con salidas nombradas. No tiene efecto si tokenize esFalse. Si al menos una conversación contiene una imagen, sus valores de píxel se devolverán en la clavepixel_valuesy los tamaños de imagen en la claveimage_sizes. - reasoning_effort (
ReasoningEffort, opcional) — El esfuerzo de razonamiento a utilizar para la finalización del chat en los modelos que lo admiten. Los valores posibles son:ReasoningEffort.none: El modelo no razonará.ReasoningEffort.high: El modelo utilizará un enfoque de razonamiento. Si no se especifica, se utilizará el esfuerzo de razonamiento predeterminado.
- kwargs (argumentos de palabra clave adicionales, opcional) —
Argumentos adicionales que se pasan al método
ChatCompletionRequest.from_openaide mistral-common.
Devuelve
Union[str, list[int], list[str], list[list[int]], BatchEncoding]
El chat tokenizado hasta ahora, incluidos los tokens de control. Esta salida está lista para pasarse al modelo, ya sea directamente o mediante métodos como generate().
Convierte una lista de diccionarios con las claves "role" y "content" en una 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. Se puede obtener usando el método__call__. - skip_special_tokens (
bool, opcional, valor predeterminadoFalse) — Indica si se deben eliminar los tokens especiales durante la decodificación. - clean_up_tokenization_spaces (
bool, opcional) — Si se deben limpiar los espacios de tokenización. Si esNone, se usará por defectoself.clean_up_tokenization_spaces. - kwargs (argumentos de palabra clave adicionales, opcional) —
No es compatible con
MistralCommonBackend.batch_decode. Lanzará un error si se utiliza.
Devuelve
list[str]
La lista de oraciones decodificadas.
Convierta una lista de listas de ids de tokens en una lista de cadenas de texto llamando a decode.
Este método se proporciona por compatibilidad con versiones anteriores. El método decode ahora maneja la entrada por lotes de forma nativa,
por lo que puede usar decode directamente en lugar de batch_decode.
build_inputs_with_special_tokens
< source >( token_ids_0: listtoken_ids_1: None = None ) → list[int]
Construir las entradas del modelo a partir de una secuencia añadiendo tokens especiales.
Este método construye dinámicamente las entradas en función del mode del tokenizador:
"test": seq0 [EOS]"finetuning": [BOS] seq0
convert_added_tokens
< source >( obj: tokenizers.AddedToken | typing.Anysave: bool = Falseadd_type_field: bool = True )
MistralCommonBackend no implementa convert_added_tokens por diseño.
Si desea que se implemente este comportamiento, abra un issue en los repositorios Transformers o mistral-common para solicitarlo.
create_token_type_ids_from_sequences
< source >( token_ids_0: listtoken_ids_1: None = None ) → list[int]
Cree una máscara de ceros a partir de los ids de tokens con los tokens especiales añadidos.
Se mantiene para coincidir con la implementación de 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]) — Una secuencia única o un lote (lista de secuencias) de ids de entrada tokenizados. Se puede obtener mediante el método__call__. - skip_special_tokens (
bool, opcional, valor predeterminadoFalse) — Indica si se deben eliminar los tokens especiales durante la decodificación. - clean_up_tokenization_spaces (
bool, opcional) — Si se deben limpiar los espacios de tokenización. Si esNone, se usará por defectoself.clean_up_tokenization_spaces. - kwargs (argumentos de palabra clave adicionales, opcional) —
No es compatible con
MistralCommonBackend.decode. Lanzará un error si se utiliza.
Devuelve
Union[str, list[str]]
La cadena decodificada para una secuencia individual, o una lista de cadenas decodificadas para un lote de secuencias.
Convierte una secuencia de ids en una cadena de texto, utilizando el tokenizador y el vocabulario, con opciones para eliminar tokens especiales y limpiar los espacios de tokenización.
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 (
strolist[int]) — La primera secuencia que se codificará. Puede ser una cadena de caracteres o una lista de enteros (ids de cadenas tokenizadas). - text_pair (
None, opcional) — No compatible conMistralCommonBackend.encode. Se mantiene para coincidir con la firma dePreTrainedTokenizerBase.encode. - add_special_tokens (
bool, opcional, valor predeterminadoTrue) — Indica si se deben o no añadir tokens especiales al codificar las secuencias. Esto utilizará la función subyacentePretrainedTokenizerBase.build_inputs_with_special_tokens, que define qué tokens se añaden automáticamente a los ids de entrada. Esto es útil si se desea añadir tokensbosoeosautomáticamente. Cuando el Tokenizer se carga en modofinetuning, añade tantoboscomoeos. En caso contrario, en modo “test”, solo añadebos. - padding (
bool,stro PaddingStrategy, opcional, el valor predeterminado esFalse) — Activa y controla el relleno. Acepta los siguientes valores:Trueo'longest': Rellena hasta la secuencia más larga del lote (o no aplica relleno si solo se proporciona una secuencia).'max_length': Rellena hasta una longitud máxima especificada con el argumentomax_lengtho hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento.Falseo'do_not_pad'(predeterminado): Sin relleno (es decir, puede generar un lote con secuencias de diferentes longitudes).
- truncation (
bool,stro TruncationStrategy, opcional, por defectoFalse) — Activa y controla la truncación. Acepta los siguientes valores:Trueo'longest_first': Trunca a una longitud máxima especificada con el argumentomax_lengtho a la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento.Falseo'do_not_truncate'(predeterminado): sin truncamiento (es decir, se puede generar un lote con longitudes de secuencia mayores que el tamaño máximo de entrada admisible por el modelo).
- max_length (
int, opcional) — Controla la longitud máxima que se utilizará mediante uno de los parámetros de truncamiento/relleno.Si se deja sin definir o se establece en
None, se utilizará la longitud máxima predefinida del modelo si uno de los parámetros de truncamiento/relleno lo requiere. Si el modelo no tiene una longitud máxima de entrada específica (como XLNet), el truncamiento/relleno a una longitud máxima se desactivará. - stride (
int, opcional, valor predeterminado 0) — Si se establece en un número junto conmax_length, los tokens de desbordamiento devueltos cuandoreturn_overflowing_tokens=Truecontendrán algunos tokens del final de la secuencia truncada devuelta para proporcionar cierta superposición entre las secuencias truncadas y las de desbordamiento. El valor de este argumento define el número de tokens superpuestos. - pad_to_multiple_of (
int, opcional) — Si se establece, se rellenará la secuencia hasta un múltiplo del valor proporcionado. Requiere quepaddingesté activado. Esto es especialmente útil para habilitar el uso de Tensor Cores en hardware de NVIDIA con capacidad de cálculo>= 7.5(Volta). - padding_side (
str, opcional) — El lado en el que el modelo debe aplicar el relleno. Debe seleccionarse entre [‘right’, ‘left’]. El valor predeterminado se elige a partir del atributo de clase con el mismo nombre. - return_tensors (
stro TensorType, opcional) — Si se establece, devolverá tensores en lugar de una lista de enteros de Python. Los valores aceptables son:'pt': Devuelve objetostorch.Tensorde PyTorch.
- **kwargs — No compatible con
MistralCommonBackend.encode. Se generará un error si se usa.
Devuelve
list[int], torch.Tensor
Los ids tokenizados del texto.
Convierte una cadena en una secuencia de ids (enteros), utilizando el tokenizador y el vocabulario.
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 (
stroos.PathLike) — Puede ser:- Una cadena de texto, el model id de un tokenizador predefinido alojado en un repositorio de modelos en huggingface.co.
- Una ruta a un directorio que contiene la configuración del tokenizador, por ejemplo, guardada
usando el método
MistralCommonBackend.tokenization_mistral_common.save_pretrained, p. ej.,./my_model_directory/.
- mode (
Union[str, ValidationMode], opcional, por defectoValidationMode.test) — Modo de validación para elMistralTokenizertokenizer. Los valores posibles son:"finetuning"oValidationMode.finetuning: el modo de ajuste fino."test"oValidationMode.test: el modo de prueba. Cambia cómo el tokenizer valida la entrada y prepara la solicitud para el modelo.
- cache_dir (
stroos.PathLike, opcional) — Ruta a un directorio en el que se deben almacenar en caché los archivos de vocabulario de un tokenizador predefinido descargado si no se debe usar la caché estándar. - force_download (
bool, opcional, valor predeterminadoFalse) — Indica si se debe forzar la (re)descarga de los archivos de vocabulario y sobrescribir las versiones en caché si existen. - token (
stro bool, opcional) — El token que se usará como autorización HTTP bearer para archivos remotos. Si esTrue, se usará el token generado al ejecutarhf auth login(almacenado en~/.huggingface). - local_files_only (
bool, opcional, valor predeterminadoFalse) — Indica si se debe confiar únicamente en los archivos locales y no intentar descargar ningún archivo. - revision (
str, opcional, valor predeterminado"main") — La versión específica del modelo que se va a utilizar. Puede ser el nombre de una rama, el nombre de una etiqueta o un id de commit, ya que utilizamos un sistema basado en git para almacenar modelos y otros artefactos en huggingface.co, por lo querevisionpuede ser cualquier identificador permitido por git. - max_length (
int, opcional) — Controla la longitud máxima que se utilizará mediante uno de los parámetros de truncamiento/relleno.Si se deja sin definir o se establece en
None, se utilizará la longitud máxima predefinida del modelo si uno de los parámetros de truncamiento/relleno lo requiere. Si el modelo no tiene una longitud máxima de entrada específica (como XLNet), el truncamiento/relleno a una longitud máxima se desactivará. - padding_side (
str, opcional, valor predeterminado"left") — El lado en el que el modelo debe aplicar el relleno. Debe seleccionarse entre [‘right’, ‘left’]. El valor predeterminado se toma del atributo de clase con el mismo nombre. - truncation_side (
str, opcional, por defecto"right") — El lado en el que el modelo debe aplicar la truncación. Debe seleccionarse entre [‘right’, ‘left’]. - model_input_names (
List[str], opcional) — La lista de entradas aceptadas por la pasada hacia adelante del modelo (como"token_type_ids"o"attention_mask"). El valor predeterminado se toma del atributo de clase con el mismo nombre. - clean_up_tokenization_spaces (
bool, opcional, valor predeterminadoFalse) — Indica si el modelo debe limpiar los espacios que se añadieron al dividir el texto de entrada durante el proceso de tokenización. - kwargs (argumentos de palabra clave adicionales, opcional) —
No es compatible con
MistralCommonBackend.from_pretrained. Lanzará un error si se utiliza.
Instancia un MistralCommonBackend a partir de un
tokenizer predefinido.
MistralCommonBackend no implementa get_chat_template por diseño, ya que mistral-common no utiliza plantillas 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 de la secuencia. - token_ids_1 (
None, opcional) — None, se mantiene para coincidir con la implementación de Transformers. - already_has_special_tokens (
bool, opcional, valor predeterminadoFalse) — Indica si la lista de tokens ya está formateada con tokens especiales para el modelo.
Devuelve
Una lista de enteros en el rango [0, 1]
1 para un token especial, 0 para un token de secuencia.
Obtiene los ids de secuencia de una lista de tokens a la que no se le han añadido tokens especiales. Este método se llama al añadir tokens especiales mediante los métodos prepare_for_model o encode_plus del tokenizer.
Devuelve el vocabulario como un diccionario de token a índice.
Esta es una conversión con pérdida. Puede haber varios ids de token que se decodifican en la misma cadena debido a que las secuencias parciales de bytes UTF-8 se convierten en �.
num_special_tokens_to_add
< source >( pair: typing.Literal[False] = False ) → int
Devuelve el número de tokens añadidos al codificar una secuencia con tokens especiales.
Esto codifica una entrada ficticia y comprueba el número de tokens añadidos, por lo que no es eficiente. No coloque esto dentro de su bucle de entrenamiento.
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 tokenizada de la primera secuencia. - pair_ids (
None, opcional) — No es compatible conMistralCommonBackend. Se mantiene para coincidir con la interfaz dePreTrainedTokenizerBase. - add_special_tokens (
bool, opcional, valor predeterminadoTrue) — Indica si se deben o no añadir tokens especiales al codificar las secuencias. Esto utilizará la función subyacentePretrainedTokenizerBase.build_inputs_with_special_tokens, que define qué tokens se añaden automáticamente a los ids de entrada. Esto es útil si se desea añadir tokensbosoeosautomáticamente. Cuando el Tokenizer se carga en modofinetuning, añade tantoboscomoeos. En caso contrario, en modo “test”, solo añadebos. - padding (
bool,stro PaddingStrategy, opcional, el valor predeterminado esFalse) — Activa y controla el relleno. Acepta los siguientes valores:Trueo'longest': Rellena hasta la secuencia más larga del lote (o no aplica relleno si solo se proporciona una secuencia).'max_length': Rellena hasta una longitud máxima especificada con el argumentomax_lengtho hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento.Falseo'do_not_pad'(predeterminado): Sin relleno (es decir, puede generar un lote con secuencias de diferentes longitudes).
- truncation (
bool,stro TruncationStrategy, opcional, por defectoFalse) — Activa y controla la truncación. Acepta los siguientes valores:Trueo'longest_first': Trunca a una longitud máxima especificada con el argumentomax_lengtho a la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento.Falseo'do_not_truncate'(predeterminado): sin truncamiento (es decir, se puede generar un lote con longitudes de secuencia mayores que el tamaño máximo de entrada admisible por el modelo).
- max_length (
int, opcional) — Controla la longitud máxima que se utilizará mediante uno de los parámetros de truncamiento/relleno.Si se deja sin definir o se establece en
None, se utilizará la longitud máxima predefinida del modelo si uno de los parámetros de truncamiento/relleno lo requiere. Si el modelo no tiene una longitud máxima de entrada específica (como XLNet), el truncamiento/relleno a una longitud máxima se desactivará. - stride (
int, opcional, valor predeterminado 0) — Si se establece en un número junto conmax_length, los tokens de desbordamiento devueltos cuandoreturn_overflowing_tokens=Truecontendrán algunos tokens del final de la secuencia truncada devuelta para proporcionar cierta superposición entre las secuencias truncadas y las de desbordamiento. El valor de este argumento define el número de tokens superpuestos. - pad_to_multiple_of (
int, opcional) — Si se establece, se rellenará la secuencia hasta un múltiplo del valor proporcionado. Requiere quepaddingesté activado. Esto es especialmente útil para habilitar el uso de Tensor Cores en hardware de NVIDIA con capacidad de cálculo>= 7.5(Volta). - padding_side (
str, opcional) — El lado en el que el modelo debe aplicar el relleno. Debe seleccionarse entre [‘right’, ‘left’]. El valor predeterminado se elige a partir del atributo de clase con el mismo nombre. - return_tensors (
stro TensorType, opcional) — Si se establece, devolverá tensores en lugar de una lista de enteros de Python. Los valores aceptables son:'pt': Devuelve objetostorch.Tensorde PyTorch.
- return_token_type_ids (
bool, opcional) — Si se deben devolver los IDs de tipo de token. ParaMistralCommonBackenddevuelve una lista de ceros de la longitud de la secuencia, ya que solo se admite una secuencia. - return_attention_mask (
bool, opcional) — Si se debe devolver la máscara de atención. Si se deja en el valor predeterminado, se devolverá la máscara de atención según el valor predeterminado del tokenizador específico, definido por elreturn_outputsatributo. - return_overflowing_tokens (
bool, opcional, valor predeterminadoFalse) — Indica si se deben devolver las secuencias de tokens que exceden el límite. Si se proporciona un par de secuencias de ids de entrada (o un lote de pares) contruncation_strategy = longest_firstoTrue, se genera un error en lugar de devolver los tokens que exceden el límite. - return_special_tokens_mask (
bool, opcional, valor predeterminadoFalse) — Indica si se debe o no devolver información de la máscara de tokens especiales. - return_length (
bool, opcional, valor predeterminadoFalse) — Indica si se deben devolver las longitudes de las entradas codificadas. - verbose (
bool, opcional, valor predeterminadoTrue) — Si se imprime más información y advertencias. - return_offsets_mapping (
Literal[False], opcional) — False, se mantiene para coincidir con la firma de Transformers. - split_special_tokens (
Literal[False], opcional) — False, se mantiene para coincidir con la firma de Transformers. - **kwargs — se pasan al método
self.tokenize()
Devuelve
Un BatchEncoding con los siguientes campos:
-
input_ids — Lista de ids de tokens que se enviarán a un modelo.
-
attention_mask — Lista de índices que especifica qué tokens deben ser atendidos por el modelo (cuando
return_attention_mask=Trueo si “attention_mask” está enself.model_input_names). -
overflowing_tokens — Lista de secuencias de tokens que exceden el límite (cuando se especifica un
max_lengthyreturn_overflowing_tokens=True). -
num_truncated_tokens — Número de tokens truncados (cuando se especifica un
max_lengthyreturn_overflowing_tokens=True). -
special_tokens_mask — Lista de 0 y 1, donde 1 especifica los tokens especiales añadidos y 0 especifica los tokens regulares de la secuencia (cuando
add_special_tokens=Trueyreturn_special_tokens_mask=True). -
length — La longitud de las entradas (cuando
return_length=True)
Prepara una secuencia de id de entrada para que pueda ser utilizada por el modelo. Añade tokens especiales, trunca las secuencias si se excede el límite teniendo en cuenta los tokens especiales y gestiona una ventana móvil (con un paso definido por el usuario) para los tokens que se exceden.
save_chat_templates
< source >( save_directory: str | os.PathLiketokenizer_config: dictfilename_prefix: str | Nonesave_jinja_files: bool )
MistralCommonBackend no implementa save_chat_templates por diseño, ya que mistral-common no utiliza plantillas de chat.
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) — Directorio donde se guardará el tokenizador. - push_to_hub (
bool, opcional, valor predeterminadoFalse) — Subir al HF Hub después de guardar. - token (
strobool, opcional) — Token para la autenticación en Hub. - commit_message (
str, opcional) — Mensaje de commit al hacer push. - repo_id (
str, opcional) — id del repositorio en Hub. - private (
bool, opcional) — Indica si el repositorio es privado. - save_format (
str, opcional) —"mistral"para guardar en el formato nativo tekken,"hf"para el formato de HuggingFace. None conserva el formato original. - kwargs (
dict, opcional) — No se admite: se generará un error.
Devuelve
tuple[str, ...]
Rutas de los archivos guardados.
Guarde el estado completo del tokenizador.
Cuando save_format es "mistral" (o None para un tokenizador tekken),
el archivo de tokenizador original (p. ej. tekken.json) se escribe en save_directory. Cuando save_format es "hf", se generan en su lugar archivos en formato HF
(tokenizer.json + tokenizer_config.json).
MistralCommonBackend no implementa save_vocabulary por diseño.
Esto se debe a que mistral-common se configura con un solo archivo de tokenizador. Si desea guardar el vocabulario, considere usar el método save_pretrained en su lugar.
tokenize
< source >( text: strreturn_offsets_mapping: typing.Literal[False] = Falsesplit_special_tokens: typing.Literal[False] = False**kwargs ) → list[str]
Parámetros
- text (
str) — La secuencia que se va a codificar. - return_offsets_mapping (
Literal[False], opcional) — False, se mantiene para coincidir con la firma de Transformers. - split_special_tokens (
Literal[False], opcional) — False, se mantiene para coincidir con la firma de Transformers. - **kwargs (argumentos de palabra clave adicionales) —
No es compatible con
MistralCommonBackend.tokenize. Se generará un error si se utiliza.
Devuelve
list[str]
La lista de tokens.
Convierte una cadena en una secuencia de tokens, utilizando el tokenizador.
Divide en palabras para vocabularios basados en palabras o en subpalabras para vocabularios basados en subpalabras.
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. Se pueden obtener a partir de una cadena encadenando los métodostokenizeyconvert_tokens_to_ids. - pair_ids (
None, opcional) — No compatible conMistralCommonBackend. Se mantiene para coincidir con la firma dePreTrainedTokenizerBase.truncate_sequences. - num_tokens_to_remove (
int, opcional, valor predeterminado 0) — Número de tokens que se eliminarán usando la estrategia de truncamiento. - truncation_strategy (
stro TruncationStrategy, opcional, por defecto'longest_first') — La estrategia a seguir para la truncación. Puede ser:'longest_first': Trunca hasta una longitud máxima especificada con el argumentomax_lengtho hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento.'do_not_truncate'(predeterminado): Sin truncamiento (es decir, puede generar un lote con longitudes de secuencia mayores que el tamaño máximo de entrada admisible del modelo).
- stride (
int, opcional, valor predeterminado 0) — Si se establece en un número positivo, los tokens de desbordamiento devueltos contendrán algunos tokens de la secuencia principal devuelta. El valor de este argumento define el número de tokens adicionales.
Devuelve
Tuple[list[int], None, list[int]]
Los ids truncados y la lista de
tokens que exceden el límite. Se devuelve None para coincidir con la firma de Transformers.
Trunca un par de secuencias in situ siguiendo la estrategia.
MixtralModel
clase transformers.MixtralModel
< source >( config: MixtralConfig )
Parámetros
- config (MixtralConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
El modelo Mixtral básico que genera estados ocultos sin ninguna cabeza específica en la parte superior.
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
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'> ) → MoeModelOutputWithPast or tuple(torch.Tensor)
Parámetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - past_key_values (
~cache_utils.Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden usar para acelerar la decodificación secuencial. Esto generalmente consiste en lapast_key_valuesdevuelta por el modelo en una etapa anterior de la decodificación, cuandouse_cache=Trueoconfig.use_cache=True.Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan
past_key_values, DynamicCache se inicializará de forma predeterminada.El modelo generará el mismo formato de caché que se proporciona como entrada.
Si se utilizan
past_key_values, se espera que el usuario introduzca únicamente losinput_idsno procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) con forma(batch_size, unprocessed_length)en lugar de todos losinput_idscon forma(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - use_cache (
bool, opcional) — Si se establece enTrue, se devuelven los estados de clave-valor depast_key_valuesy pueden usarse para acelerar la decodificación (verpast_key_values).
Devuelve
MoeModelOutputWithPast o tuple(torch.Tensor)
Un MoeModelOutputWithPast o una tupla de
torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (MixtralConfig) y las entradas.
El método forward de MixtralModel sobrescribe el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.past_key_values (
Cache, opcional, se devuelve cuando se pasause_cache=Trueo cuandoconfig.use_cache=True) — Es una instancia de Cache. Para más detalles, consulta nuestra guía de caché kv.Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y, opcionalmente, si
config.is_encoder_decoder=True, en los bloques de atención cruzada) que pueden utilizarse (véase la entradapast_key_values) para acelerar la decodificación secuencial.hidden_states (
tuple(torch.Tensor), opcional, devuelto cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
attentions (
tuple(torch.Tensor), opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
router_logits (
tuple(torch.Tensor), opcional, se devuelve cuando se pasaoutput_router_probs=Trueyconfig.add_router_probs=Trueo cuandoconfig.output_router_probs=True) — Tupla detorch.Tensor(uno por cada capa) de forma(batch_size, sequence_length, num_experts).Logits crudos del enrutador (post-softmax) que se calculan mediante los enrutadores de MoE; estos términos se utilizan para calcular la pérdida auxiliar en los modelos Mixture of Experts.
MixtralForCausalLM
clase transformers.MixtralForCausalLM
< source >( config: MixtralConfig )
Parámetros
- config (MixtralConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
El modelo Mixtral para el modelado de lenguaje causal.
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
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 = Noneoutput_router_logits: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MoeCausalLMOutputWithPast or tuple(torch.Tensor)
Parámetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - past_key_values (
~cache_utils.Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden usar para acelerar la decodificación secuencial. Esto generalmente consiste en lapast_key_valuesdevuelta por el modelo en una etapa anterior de la decodificación, cuandouse_cache=Trueoconfig.use_cache=True.Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan
past_key_values, DynamicCache se inicializará de forma predeterminada.El modelo generará el mismo formato de caché que se proporciona como entrada.
Si se utilizan
past_key_values, se espera que el usuario introduzca únicamente losinput_idsno procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) con forma(batch_size, unprocessed_length)en lugar de todos losinput_idscon forma(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en[0, ..., config.vocab_size]o ser -100 (ver la docstring deinput_ids). Los tokens con índices establecidos en-100se ignoran (enmascarados); la pérdida solo se calcula para los tokens con etiquetas en[0, ..., config.vocab_size]. - use_cache (
bool, opcional) — Si se establece enTrue, se devuelven los estados de clave-valor depast_key_valuesy pueden usarse para acelerar la decodificación (verpast_key_values). - output_router_logits (
bool, opcional) — Indica si se deben devolver los logits de todos los routers. Son útiles para calcular la pérdida del router y no deben devolverse durante la inferencia. - logits_to_keep (
Union[int, torch.Tensor], opcional, valor predeterminado0) — Si es unint, calcula los logits para los últimoslogits_to_keeptokens. Si es0, calcula los logits para todos losinput_ids(caso especial). Solo se necesitan los logits del último token para la generación, y calcularlos solo para ese token puede ahorrar memoria, lo cual se vuelve bastante significativo para secuencias largas o un tamaño de vocabulario grande. Si es untorch.Tensor, debe ser de 1D y corresponder a los índices a conservar en la dimensión de longitud de secuencia. Esto es útil al usar el formato de tensor empaquetado (una sola dimensión para el lote y la longitud de secuencia).
Devuelve
MoeCausalLMOutputWithPast o tuple(torch.Tensor)
Un MoeCausalLMOutputWithPast o una tupla de
torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (MixtralConfig) y las entradas.
El método forward de MixtralForCausalLM sobrescribe el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
loss (
torch.Tensorde forma(1,), opcional, se devuelve cuando se proporcionalabels) — Pérdida de modelado de lenguaje (para la predicción del siguiente token).logits (
torch.Tensorde forma(batch_size, sequence_length, config.vocab_size)) — Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).aux_loss (
torch.Tensor, opcional, se devuelve cuando se pasaoutput_router_logits=Trueo cuandoconfig.output_router_logits=True, y el modelo entrena su router con una pérdida de equilibrio de carga) — Pérdida auxiliar de equilibrio de carga para los módulos dispersos. Los modelos que equilibran sus expertos con un sesgo del router en su lugar (DeepSeek-V3 y las arquitecturas derivadas de él) devuelvenNoneaquí, aunque siguen devolviendorouter_logits.router_logits (
tuple(torch.Tensor), opcional, se devuelve cuando se pasaoutput_router_logits=Trueo cuandoconfig.output_router_logits=True) — Tupla detorch.Tensor(una por cada capa dispersa) de forma(batch_size * sequence_length, num_experts).Logits crudos del router calculados por los routers de MoE. Se pueden utilizar para calcular una pérdida de equilibrado de carga o para inspeccionar cómo se distribuyen los tokens entre los expertos.
past_key_values (
Cache, opcional, se devuelve cuando se pasause_cache=Trueo cuandoconfig.use_cache=True) — Es una instancia de Cache. Para más detalles, consulta nuestra guía de caché kv.Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención) que pueden utilizarse (véase la entrada
past_key_values) para acelerar la decodificación secuencial.hidden_states (
tuple(torch.Tensor), opcional, devuelto cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
attentions (
tuple(torch.Tensor), opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
Ejemplo:
>>> from transformers import AutoTokenizer, MixtralForCausalLM
>>> model = MixtralForCausalLM.from_pretrained("mistralai/Mixtral-8x7B-v0.1")
>>> tokenizer = AutoTokenizer.from_pretrained("mistralai/Mixtral-8x7B-v0.1")
>>> 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."MixtralForSequenceClassification
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 de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - past_key_values (
Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden usar para acelerar la decodificación secuencial. Esto generalmente consiste en lospast_key_valuesdevueltos por el modelo en una etapa anterior de la decodificación, cuandouse_cache=Trueoconfig.use_cache=True.Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan
past_key_values, DynamicCache se inicializará de forma predeterminada.El modelo generará el mismo formato de caché que se proporciona como entrada.
Si se utilizan
past_key_values, se espera que el usuario introduzca únicamente losinput_idsno procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) con forma(batch_size, unprocessed_length)en lugar de todos losinput_idscon forma(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - labels (
torch.LongTensorde forma(batch_size,), opcional) — Etiquetas para calcular la pérdida de clasificación/regresión de secuencia. Los índices deben estar en[0, ..., config.num_labels - 1]. Siconfig.num_labels == 1se calcula una pérdida de regresión (pérdida de error cuadrático medio), siconfig.num_labels > 1se calcula una pérdida de clasificación (entropía cruzada). - use_cache (
bool, opcional) — Si se establece enTrue, se devuelven los estados de clave-valor depast_key_valuesy pueden usarse para acelerar la decodificación (verpast_key_values).
Devuelve
SequenceClassifierOutputWithPast
El método forward de GenericForSequenceClassification sobrescribe el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
MixtralForTokenClassification
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 de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - past_key_values (
Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden usar para acelerar la decodificación secuencial. Esto generalmente consiste en lospast_key_valuesdevueltos por el modelo en una etapa anterior de la decodificación, cuandouse_cache=Trueoconfig.use_cache=True.Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan
past_key_values, DynamicCache se inicializará de forma predeterminada.El modelo generará el mismo formato de caché que se proporciona como entrada.
Si se utilizan
past_key_values, se espera que el usuario introduzca únicamente losinput_idsno procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) con forma(batch_size, unprocessed_length)en lugar de todos losinput_idscon forma(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Etiquetas para calcular la pérdida de clasificación de tokens. Los índices deben estar en[0, ..., config.num_labels - 1]. - use_cache (
bool, opcional) — Si se establece enTrue, se devuelven los estados de clave-valor depast_key_valuesy pueden usarse para acelerar la decodificación (verpast_key_values).
Devuelve
TokenClassifierOutput
El método forward de GenericForTokenClassification sobrescribe el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
MixtralForQuestionAnswering
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 de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - past_key_values (
Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden usar para acelerar la decodificación secuencial. Esto generalmente consiste en lospast_key_valuesdevueltos por el modelo en una etapa anterior de la decodificación, cuandouse_cache=Trueoconfig.use_cache=True.Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan
past_key_values, DynamicCache se inicializará de forma predeterminada.El modelo generará el mismo formato de caché que se proporciona como entrada.
Si se utilizan
past_key_values, se espera que el usuario introduzca únicamente losinput_idsno procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) con forma(batch_size, unprocessed_length)en lugar de todos losinput_idscon forma(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - start_positions (
torch.LongTensorde forma(batch_size,), opcional) — Etiquetas para la posición (índice) del inicio del tramo etiquetado para calcular la pérdida de clasificación de tokens. Las posiciones se limitan a la longitud de la secuencia (sequence_length). Las posiciones fuera de la secuencia no se tienen en cuenta para calcular la pérdida. - end_positions (
torch.LongTensorde forma(batch_size,), opcional) — Etiquetas para la posición (índice) del final del tramo etiquetado para calcular la pérdida de clasificación de tokens. Las posiciones se limitan a la longitud de la secuencia (sequence_length). Las posiciones fuera de la secuencia no se tienen en cuenta para calcular la pérdida.
Devuelve
QuestionAnsweringModelOutput
El método forward de GenericForQuestionAnswering sobrescribe el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.