# Muse Spark Open ## Aperçu Muse Spark Open est un modèle multimodal de type mixture-of-experts (MoE) développé par Meta, qui accepte du texte, des images, de l'audio et de la vidéo en entrée et génère du texte. Il possède 816 milliards de paramètres au total, dont 42 milliards actifs par jeton, et prend en charge une fenêtre de contexte allant jusqu'à 1 048 576 jetons, partagée entre toutes les modalités d'entrée. Le modèle est entraîné pour des tâches de codage agentique, incluant l'édition de code multi-fichiers, le débogage et l'utilisation d'outils. Le socle linguistique est composé de 62 couches de transformateur, chacune acheminant les jetons vers 8 experts parmi 256. Il utilise une attention à requêtes groupées avec normalisation des requêtes et des clés, un portage et une normalisation de la sortie de l'attention, ainsi que des portes résiduelles apprises. Un encodeur de perception partagé traite les images et les images vidéo, tandis qu'un encodeur audio convolutif génère des représentations audio à 12,5 jetons par seconde. Muse Spark Open partage son tokeniseur et son vocabulaire avec [Muse Glimmer](./muse_glimmer), avec des extensions du modèle de discussion pour les entrées multimodales. Les points de contrôle sont disponibles en BF16 et au format [NVFP4](#nvfp4-weights). ## Ressources - [Collection Hugging Face](https://huggingface.co/collections/meta-models/muse-spark-open) - [Blog Hugging Face](http://hf.co/blog/meta-muse-spark-open) - [Post-entraînement avec TRL](https://github.com/huggingface/trl/tree/main/examples/sft_muse_spark_open) ```python import os from transformers import AutoModelForMultimodalLM, AutoProcessor, DistributedConfig distributed_config = DistributedConfig( tp_size=int(os.environ["WORLD_SIZE"]), # Number of devices across which the dense layers are sharded ep_size=int(os.environ["WORLD_SIZE"]), # Number of devices across which the experts are distributed ) processor = AutoProcessor.from_pretrained("meta-models/Muse-Spark-Open-816B-A42B") model = AutoModelForMultimodalLM.from_pretrained( "meta-models/Muse-Spark-Open-816B-A42B", distributed_config=distributed_config, ) messages = [ {"role": "user", "content": "Explain in one sentence why the sky is usually blue."}, ] inputs = processor.apply_chat_template( messages, reasoning_effort="low", # default: xhigh, options: low/medium/high/xhigh add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt", ).to(model.device).to(model.dtype) input_len = inputs["input_ids"].shape[-1] outputs = model.generate(**inputs, max_new_tokens=512) print(processor.decode(outputs[0][input_len:], skip_special_tokens=False)) # to=self<|message|>Explain in one sentence why the sky is usually blue. # ... # <|eom|><|start|>assistant to=user<|message|>The sky is usually blue because molecules in Earth's atmosphere scatter shorter-wavelength blue sunlight in all directions much more strongly than longer-wavelength red light.<|eot|> ``` ```python import os from transformers import AutoModelForMultimodalLM, AutoProcessor, DistributedConfig distributed_config = DistributedConfig( tp_size=int(os.environ["WORLD_SIZE"]), ep_size=int(os.environ["WORLD_SIZE"]), ) processor = AutoProcessor.from_pretrained("meta-models/Muse-Spark-Open-816B-A42B") model = AutoModelForMultimodalLM.from_pretrained( "meta-models/Muse-Spark-Open-816B-A42B", distributed_config=distributed_config, ) messages = [ { "role": "user", "content": [ {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"}, {"type": "text", "text": "What is shown in this image?"}, ], }, ] inputs = processor.apply_chat_template( messages, reasoning_effort="medium", # default: xhigh, options: low/medium/high/xhigh add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt", ).to(model.device).to(model.dtype) input_len = inputs["input_ids"].shape[-1] outputs = model.generate(**inputs, max_new_tokens=512) response = processor.decode(outputs[0][input_len:], skip_special_tokens=False) print(response) # to=self<|message|>What is shown in this image? # ... # <|eom|><|start|>assistant to=user<|message|>The image shows a **Pallas's cat — also known as a manul, *Otocolobus manul*** — walking through snow. # # It is a small, stocky wild cat recognizable by: # # * **Its extremely dense, long, greyish-brown winter coat** with faint dark stripes and a dusting of snow on its back # * **Its flat, broad face** with low-set ears, a short muzzle, and dark stripes on the cheeks # * **Its short legs and thick, plump body** adapted for cold climates # # The cat is captured mid-stride on a snow-covered surface, with one front paw lifted. In the background are white birch tree trunks with black markings and a chain-link fence on the left, indicating the animal is in a zoo or wildlife enclosure in winter.<|eot|> ``` ```python import os from transformers import AutoModelForMultimodalLM, AutoProcessor, DistributedConfig distributed_config = DistributedConfig( tp_size=int(os.environ["WORLD_SIZE"]), ep_size=int(os.environ["WORLD_SIZE"]), ) processor = AutoProcessor.from_pretrained("meta-models/Muse-Spark-Open-816B-A42B") model = AutoModelForMultimodalLM.from_pretrained( "meta-models/Muse-Spark-Open-816B-A42B", distributed_config=distributed_config, ) messages = [ { "role": "user", "content": [ {"type": "video", "url": "https://huggingface.co/datasets/hf-internal-testing/fixtures_videos/resolve/main/tennis.mp4"}, {"type": "text", "text": "What is happening in this video?"}, ], }, ] inputs = processor.apply_chat_template( messages, reasoning_effort="medium", # default: xhigh, options: low/medium/high/xhigh processor_kwargs={ "fps": 2, # default: 2, number of frames sampled per second "num_frames": 8, # default: 94, maximum number of frames sampled from the video }, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt", ).to(model.device).to(model.dtype) input_len = inputs["input_ids"].shape[-1] outputs = model.generate(**inputs, max_new_tokens=512) print(processor.decode(outputs[0][input_len:], skip_special_tokens=False)) # to=self<|message|>What is happening in this video? # ... # <|eom|><|start|>assistant to=user<|message|>In this video two people are playing tennis on an indoor court. # # The shot is taken from behind one of the players - a man in a white t-shirt, black shorts and white shoes and socks. He is standing near the baseline on an orange hard court with white lines, in a ready position with his knees bent and his racket held in front of him. # # Across the net, on the far side of the court, is his opponent, also dressed in light-colored clothing. # # The sequence shows a short rally: # # * The opponent hits the ball over the net. # * The man in the foreground shuffles to his left, turns his body, and prepares for a shot. # * He executes a two-handed backhand, swinging the racket across his body and following through as he hits the ball back over the net. # # The setting is a large indoor tennis hall with a high, arched ceiling with exposed wooden beams and overhead fluorescent lights. The court is surrounded by a grey run-off area, green windscreening on the walls, and netting that separates it from adjacent courts. On the right side you can see an umpire's chair and a few yellow and black benches. An "Adobe Stock" watermark is visible in the center of the frame.<|eot|> ``` ```python import os from transformers import AutoModelForMultimodalLM, AutoProcessor, DistributedConfig distributed_config = DistributedConfig( tp_size=int(os.environ["WORLD_SIZE"]), ep_size=int(os.environ["WORLD_SIZE"]), ) processor = AutoProcessor.from_pretrained("meta-models/Muse-Spark-Open-816B-A42B") model = AutoModelForMultimodalLM.from_pretrained( "meta-models/Muse-Spark-Open-816B-A42B", distributed_config=distributed_config, ) messages = [ { "role": "user", "content": [ {"type": "audio", "url": "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/glass_breaking.mp3"}, {"type": "text", "text": "What is said in this recording?"}, ], }, ] inputs = processor.apply_chat_template( messages, reasoning_effort="low", # default: xhigh, options: low/medium/high/xhigh processor_kwargs={"sampling_rate": 24000}, # sampling rate the model was trained with add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt", ).to(model.device).to(model.dtype) input_len = inputs["input_ids"].shape[-1] outputs = model.generate(**inputs, max_new_tokens=512) print(processor.decode(outputs[0][input_len:], skip_special_tokens=False)) # to=self<|message|>We need to respond to user request: "What is said in this recording?" # ... # <|eom|><|start|>assistant to=user<|message|>In the recording the person says: # # > "Just picked up this glass and the people at the store told me that if I dropped it it wouldn't break." # # Then the glass is dropped and shatters.<|eot|> ``` ## Poids NVFP4 Les [poids quantifiés](https://huggingface.co/meta-models/Muse-Spark-Open-816B-A42B-NVFP4) NVFP4, qui nécessitent moins de mémoire, sont disponibles sur le hub. Le modèle peut être chargé sur n'importe quel appareil compatible NVFP4 sans modification du code. La configuration de quantification est appliquée automatiquement au chargement. > [!IMPORTANT] > Pour la prise en charge de NVFP4, transformers doit être installé depuis [cette branche](https://github.com/huggingface/transformers/pull/49015). > > ```bash > pip install git+https://github.com/huggingface/transformers.git@finegrained-per-scheme-demo > ``` ```python import os from transformers import AutoModelForMultimodalLM, AutoProcessor, DistributedConfig distributed_config = DistributedConfig( tp_size=int(os.environ["WORLD_SIZE"]), ep_size=int(os.environ["WORLD_SIZE"]), ) processor = AutoProcessor.from_pretrained("meta-models/Muse-Spark-Open-816B-A42B-NVFP4") model = AutoModelForMultimodalLM.from_pretrained( "meta-models/Muse-Spark-Open-816B-A42B-NVFP4", distributed_config=distributed_config, ) # ... ``` ## MuseSparkConfig[[transformers.MuseSparkConfig]] #### transformers.MuseSparkConfig[[transformers.MuseSparkConfig]] ```python transformers.MuseSparkConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, image_token_id: int = 200092, video_token_id: int = 200091, out_hidden_size: int = 6144, projector_hidden_size: int = 4096, projector_hidden_act: str = 'gelu', audio_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, audio_token_id: int = 200038) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/muse_spark/configuration_muse_spark.py#L251) **Paramètres :** text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *facultatif*) : L'objet de configuration ou le dictionnaire du backbone de texte. vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *facultatif*) : L'objet de configuration ou le dictionnaire du backbone visuel. image_token_id (`int`, *facultatif*, valeur par défaut `200092`) : L'index du jeton d'image utilisé comme espace réservé pour les images d'entrée. video_token_id (`int`, *facultatif*, valeur par défaut `200091`) : L'index du jeton vidéo utilisé comme espace réservé pour les vidéos d'entrée. out_hidden_size (`int`, *facultatif*, valeur par défaut 6144) : Dimension de sortie de l'encodeur visuel après fusion des patches (largeur d'entrée de la projection multimodale). projector_hidden_size (`int`, *facultatif*, valeur par défaut 4096) : Dimension intermédiaire de la projection multimodale. projector_hidden_act (`str`, *facultatif*, par défaut `gelu`) : Fonction d'activation utilisée par le projecteur multimodal. audio_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *facultatif*) : L'objet de configuration ou le dictionnaire du backbone audio. audio_token_id (`int`, *facultatif*, valeur par défaut `200038`) : L'index du jeton audio utilisé comme espace réservé pour l'audio en entrée. Il s'agit de la classe de configuration destinée à stocker la configuration d'un MuseSparkModel. Elle est utilisée pour instancier un modèle Muse Spark en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle du [meta-models/Muse-Spark-Open-816B-A42B](https://huggingface.co/meta-models/Muse-Spark-Open-816B-A42B) Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations. Exemple : ```python >>> from transformers import MuseSparkForConditionalGeneration, MuseSparkConfig >>> # Initializing an MuseSpark style configuration >>> configuration = MuseSparkConfig() >>> # Initializing a model from the configuration >>> model = MuseSparkForConditionalGeneration(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## MuseSparkTextConfig[[transformers.MuseSparkTextConfig]] #### transformers.MuseSparkTextConfig[[transformers.MuseSparkTextConfig]] ```python transformers.MuseSparkTextConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 202048, hidden_size: int = 8192, intermediate_size: int = 16384, num_hidden_layers: int = 62, num_attention_heads: int = 128, num_key_value_heads: int = 16, head_dim: int = 64, max_position_embeddings: int = 1048576, initializer_range: float = 0.02, rms_norm_eps: float = 1e-05, use_cache: bool = True, pad_token_id: int | None = None, eos_token_id: int | list[int] | None = 200001, bos_token_id: int | None = 200000, tie_word_embeddings: bool = False, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, attention_bias: bool = False, attention_dropout: int | float | None = 0.0, sliding_window: int | None = 2048, layer_types: list[str] | None = None, final_logit_softcapping: float = 20.0, qk_scale_factor: float = 5.4730064863875, output_multiplier: float = 0.1767766952966369, post_norm_eps: float = 1e-08, layer_rope_theta: list[float | int] | None = None, hidden_act: str = 'silu', moe_intermediate_size: int = 4096, num_local_experts: int = 256, num_experts_per_tok: int = 8, routed_scaling_factor: float = 1.0, moe_hidden_size: int = 4096, mlp_layer_types: list[str] | None = None, residual_gate_temperature: float = 0.3, output_router_logits: bool = False) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/muse_spark/configuration_muse_spark.py#L75) **Paramètres :** vocab_size (`int`, *facultatif*, valeur par défaut `202048`) : Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par `input_ids`. hidden_size (`int`, *facultatif*, valeur par défaut `8192`) : Dimension des représentations cachées. intermediate_size (`int`, *facultatif*, valeur par défaut `16384`) : Dimension des représentations MLP. num_hidden_layers (`int`, *facultatif*, valeur par défaut `62`) : Nombre de couches cachées dans le décodeur Transformer. num_attention_heads (`int`, *facultatif*, valeur par défaut `128`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. num_key_value_heads (`int`, *facultatif*, valeur par défaut `16`) : C'est le nombre de têtes key_value à utiliser pour implémenter l'attention Grouped Query. Si `num_key_value_heads=num_attention_heads`, le modèle utilisera l'attention Multi Head (MHA) ; si `num_key_value_heads=1`, il utilisera l'attention Multi Query (MQA) ; sinon, c'est la GQA qui est utilisée. Lors de la conversion d'un checkpoint multi-têtes vers un checkpoint GQA, chaque tête clé et valeur de groupe doit être construite en effectuant un meanpooling de toutes les têtes d'origine appartenant à ce groupe. Pour plus de détails, consultez [cet article](https://huggingface.co/papers/2305.13245). S'il n'est pas spécifié, la valeur par défaut est `num_attention_heads`. head_dim (`int`, *facultatif*, par défaut `64`) : La dimension des têtes d'attention. Si None, elle est par défaut égale à hidden_size // num_attention_heads max_position_embeddings (`int`, *facultatif*, valeur par défaut `1048576`) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids. rms_norm_eps (`float`, *facultatif*, par défaut `1e-05`) : L'épsilon utilisé par les couches de normalisation rms. use_cache (`bool`, *facultatif*, valeur par défaut `True`) : Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). Pertinent uniquement si `config.is_decoder=True` ou si le modèle est un modèle génératif de type décodeur uniquement. pad_token_id (`int`, *facultatif*) : Identifiant de jeton utilisé pour le bourrage dans le vocabulaire. eos_token_id (`Union[int, list[int]]`, *facultatif*, valeur par défaut `200001`) : Identifiant de jeton utilisé pour la fin de flux dans le vocabulaire. bos_token_id (`int`, *facultatif*, valeur par défaut `200000`) : Identifiant de jeton utilisé pour le début de flux dans le vocabulaire. tie_word_embeddings (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut lier les embeddings de poids selon la correspondance `tied_weights_keys` du modèle. rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *facultatif*) : Dictionnaire contenant les paramètres de configuration pour les embeddings RoPE. Le dictionnaire doit contenir une valeur pour `rope_theta` et, le cas échéant, les paramètres utilisés pour le mise à l'échelle si vous souhaitez utiliser RoPE avec des `max_position_embeddings` plus longs. attention_bias (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut utiliser un biais dans les couches de projection de requête, de clé, de valeur et de sortie lors de l'auto-attention. attention_dropout (`Union[int, float]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout appliqué aux probabilités d'attention. sliding_window (`int`, *facultatif*, valeur par défaut `2048`) : Taille de la fenêtre de l'attention à fenêtre glissante. Si `None`, aucune fenêtre glissante n'est appliquée. layer_types (`list[str]`, *facultatif*) : Une liste qui associe explicitement chaque index de couche à son type de couche. S'il n'est pas fourni, il sera généré automatiquement en fonction des valeurs de configuration. final_logit_softcapping (`float`, *facultatif*, valeur par défaut `20.0`) : Valeur de plafonnement doux appliquée aux logits finaux avant le calcul de la distribution de probabilité. Les logits sont mis à l'échelle par `tanh(logit / cap) * cap`. qk_scale_factor (`float`, *facultatif*, valeur par défaut 5.4730064863875) : Multiplicateur appliqué à Q après la normalisation QK sans échelle, en plus de l'échelle d'attention standard `1/sqrt(head_dim)`. output_multiplier (`float`, *facultatif*, valeur par défaut 0.1767766952966369) : Échelle appliquée aux logits avant le softcap tanh final. Égale à `1/sqrt(hidden_size / 256)` pour le checkpoint publié. post_norm_eps (`float`, *facultatif*, valeur par défaut 1e-8) : Epsilon utilisé pour les normalisations post-attention et post-FFN (situées entre la sortie de la sous-couche et le résidu). layer_rope_theta (`list[float]`, *facultatif*) : Theta de base RoPE par couche ; `0` désactive la rotation (NoPE) pour cette couche. Remplace le `rope_parameters["rope_theta"]` global. Par défaut, le theta global est utilisé partout, sauf pour chaque 4e couche en partant de la dernière, qui est en NoPE. hidden_act (`str`, *facultatif*, par défaut `silu`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc. moe_intermediate_size (`int`, *facultatif*, valeur par défaut `4096`) : Taille intermédiaire des MLP des experts routés. num_local_experts (`int`, *facultatif*, valeur par défaut `256`) : Nombre d'experts locaux sur chaque appareil. `num_experts` doit être divisible par `num_local_experts`. num_experts_per_tok (`int`, *facultatif*, valeur par défaut `8`) : Nombre d'experts auxquels chaque jeton doit être routé. Il s'agit de la valeur top-k pour le routage par choix de jeton. routed_scaling_factor (`float`, *facultatif*, valeur par défaut `1.0`) : Facteur d'échelle ou experts routés. moe_hidden_size (`int`, *facultatif*, valeur par défaut 4096) : Largeur à laquelle le bloc MoE réduit `hidden_size` avant les experts routés, puis la restaure ensuite. Les experts s'exécutent entièrement à cette largeur. mlp_layer_types (`list[str]`, *facultatif*) : Type de MLP par couche — `"dense"` ou `"sparse"`. La longueur doit être égale à `num_hidden_layers`. Par défaut, toutes les couches sont de type sparse. residual_gate_temperature (`float`, *facultatif*, valeur par défaut 0,3) : Température appliquée au paramètre de la porte résiduelle avant la sigmoïde. output_router_logits (`bool`, *facultatif*, valeur par défaut `False`) : Indique si les logits du routeur doivent être renvoyés par le modèle. L'activation de cette option permet également au modèle de produire la perte auxiliaire, incluant la perte d'équilibrage de charge et la perte z du routeur. Il s'agit de la classe de configuration destinée à stocker la configuration d'un MuseSparkModel. Elle est utilisée pour instancier un modèle Muse Spark en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle du [meta-models/Muse-Spark-Open-816B-A42B](https://huggingface.co/meta-models/Muse-Spark-Open-816B-A42B) Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations. ## MuseSparkVisionConfig[[transformers.MuseSparkVisionConfig]] #### transformers.MuseSparkVisionConfig[[transformers.MuseSparkVisionConfig]] ```python transformers.MuseSparkVisionConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, patch_size: int = 14, pos_emb_height: int = 32, pos_emb_width: int = 32, num_attention_heads: int = 16, num_hidden_layers: int = 50, hidden_size: int = 1536, intermediate_size: int = 8960, hidden_act: str = 'gelu', rope_parameters: dict | None = None, patch_temporal: int = 2, merge_size: int = 2, max_position_embeddings: int = 1024, layer_norm_eps: float = 1e-05, layer_types: list[str] | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/muse_spark/configuration_muse_spark.py#L31) **Paramètres :** patch_size (`int`, *facultatif*, valeur par défaut `14`) : La taille (résolution) de chaque patch. pos_emb_height (`int`, *facultatif*) : Hauteur initiale de l'embedding de position. pos_emb_width (`int`, *facultatif*) : Largeur initiale de l'embedding de position. num_attention_heads (`int`, *facultatif*, valeur par défaut `16`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. num_hidden_layers (`int`, *facultatif*, par défaut `50`) : Nombre de couches cachées dans le décodeur Transformer. hidden_size (`int`, *facultatif*, par défaut `1536`) : Dimension des représentations cachées. intermediate_size (`int`, *facultatif*, valeur par défaut `8960`) : Dimension des représentations MLP. hidden_act (`str`, *facultatif*, par défaut `gelu`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc. rope_parameters (`dict`, *facultatif*) : Dictionnaire contenant les paramètres de configuration pour les embeddings RoPE. Le dictionnaire doit contenir une valeur pour `rope_theta` et, le cas échéant, les paramètres utilisés pour le mise à l'échelle si vous souhaitez utiliser RoPE avec des `max_position_embeddings` plus longs. patch_temporal (`int`, *facultatif*) : La taille du patch temporel utilisée pour intégrer les entrées. merge_size (`tuple[int] | list[int]`, *facultatif*) : Taille du noyau pour la fusion de patches. max_position_embeddings (`int`, *facultatif*, valeur par défaut `1024`) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. layer_norm_eps (`float`, *facultatif*, valeur par défaut `1e-05`) : L'épsilon utilisé par les couches de normalisation de couche. layer_types (`list[str]`, *facultatif*) : Une liste qui associe explicitement chaque index de couche à son type de couche. S'il n'est pas fourni, il sera généré automatiquement en fonction des valeurs de configuration. Il s'agit de la classe de configuration destinée à stocker la configuration d'un MuseSparkModel. Elle est utilisée pour instancier un modèle Muse Spark en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle du [meta-models/Muse-Spark-Open-816B-A42B](https://huggingface.co/meta-models/Muse-Spark-Open-816B-A42B) Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations. ## MuseSparkAudioConfig[[transformers.MuseSparkAudioConfig]] #### transformers.MuseSparkAudioConfig[[transformers.MuseSparkAudioConfig]] ```python transformers.MuseSparkAudioConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, patch_sizes: list[int] | tuple[int, ...] = (16, 6, 5, 4), hidden_sizes: list[int] | tuple[int, ...] = (256, 512, 1024, 2048), depths: list[int] | tuple[int, ...] = (2, 2, 2, 2), num_hidden_layers: int = 4, mlp_ratio: float = 4.0, conv_kernel_size: int = 7, hidden_act: str = 'gelu', rms_norm_eps: float = 1e-06, out_hidden_size: int = 8192, initializer_range: float = 0.02) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/muse_spark/configuration_muse_spark.py#L192) **Paramètres :** patch_sizes (`list[int] | tuple[int, ...]`, *facultatif*, valeur par défaut `(16, 6, 5, 4)`) : Facteur de sous-échantillonnage temporel appliqué par l'encodage de patch de chaque étape. Leur produit correspond au nombre d'échantillons de forme d'onde regroupés en un seul jeton de sortie. hidden_sizes (`list[int] | tuple[int, ...]`, *facultatif*, par défaut `(256, 512, 1024, 2048)`) : Largeur cachée de chaque étape. depths (`list[int] | tuple[int, ...]`, *facultatif*, valeur par défaut `(2, 2, 2, 2)`) : Nombre de blocs conv dans chaque couche. num_hidden_layers (`int`, *facultatif*, valeur par défaut : 4) : Nombre de `MuseSparkAudioLayer`, c'est-à-dire les résolutions de la pyramide. Redondant avec `len(hidden_sizes)` et validé par rapport à celui-ci, il faut donc définir les deux pour une pyramide personnalisée. mlp_ratio (`float`, *facultatif*, valeur par défaut 4.0) : Ratio de la largeur intermédiaire du MLP d'une couche par rapport à sa largeur cachée. conv_kernel_size (`int`, *facultatif*, valeur par défaut : 7) : Taille du noyau des convolutions causales en profondeur. hidden_act (`str`, *facultatif*, par défaut `gelu`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc. rms_norm_eps (`float`, *facultatif*, valeur par défaut `1e-06`) : L'épsilon utilisé par les couches de normalisation rms. out_hidden_size (`int`, *facultatif*, valeur par défaut 8192) : Largeur vers laquelle la projection finale est mappée, c'est-à-dire la taille cachée du modèle de texte. initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids. Il s'agit de la classe de configuration destinée à stocker la configuration d'un MuseSparkModel. Elle est utilisée pour instancier un modèle Muse Spark en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle du [meta-models/Muse-Spark-Open-816B-A42B](https://huggingface.co/meta-models/Muse-Spark-Open-816B-A42B) Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations. Exemple : ```python >>> from transformers import MuseSparkAudioConfig, MuseSparkAudioModel >>> configuration = MuseSparkAudioConfig() >>> model = MuseSparkAudioModel(configuration) >>> configuration = model.config ``` ## MuseSparkFeatureExtractor[[transformers.MuseSparkFeatureExtractor]] #### transformers.MuseSparkFeatureExtractor[[transformers.MuseSparkFeatureExtractor]] ```python transformers.MuseSparkFeatureExtractor(feature_size = 1, sampling_rate = 24000, padding_value = 0.0, samples_per_token = 1920, return_attention_mask = True, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/muse_spark/feature_extraction_muse_spark.py#L28) **Paramètres :** feature_size (`int`, *facultatif*, valeur par défaut : 1) : La dimension des caractéristiques des fonctionnalités extraites. Muse Spark Open prend en charge l'audio mono. sampling_rate (`int`, *facultatif*, valeur par défaut : 24000) : Le taux d'échantillonnage, en hertz, auquel l'audio est censé être fourni. Tout audio à un autre taux doit être rééchantillonné avant d'atteindre cette classe. padding_value (`float`, *facultatif*, valeur par défaut 0.0) : valeur utilisée pour l'ajustement à droite. samples_per_token (`int`, *facultatif*, valeur par défaut 1920) : nombre d'échantillons de la forme d'onde que l'encodeur regroupe en un seul embedding — le produit des `patch_sizes` de la configuration audio (16 * 6 * 5 * 4). Les lots sont complétés jusqu'à un multiple de cette valeur. return_attention_mask (`bool`, *facultatif*, valeur par défaut `True`) : Indique si `__call__()` doit retourner `input_values_mask`. La tour audio est entièrement convolutive et n'en consomme pas ; elle est désactivée par défaut. Construit un extracteur de fonctionnalités Muse Spark Open. La tour audio de Muse Spark Opens consomme la forme d'onde brute — il n'y a pas de prétraitement par spectrogramme — elle ne fait donc que regrouper en lots, ajouter des zéros et (facultativement) tronquer. La seule tâche non évidente qu'elle effectue est de compléter chaque lot jusqu'à un multiple de `samples_per_token` : l'encodeur regroupe exactement ce nombre d'échantillons en un seul embedding et lève une erreur dans le cas contraire. Cet extracteur de caractéristiques hérite de [SequenceFeatureExtractor](/docs/transformers/main/fr/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), qui contient la plupart des méthodes principales. Les utilisateurs doivent se reporter à cette superclasse pour plus d'informations sur ces méthodes. ## MuseSparkProcessor[[transformers.MuseSparkProcessor]] #### transformers.MuseSparkProcessor[[transformers.MuseSparkProcessor]] ```python transformers.MuseSparkProcessor(image_processor = None, video_processor = None, tokenizer = None, feature_extractor = None, chat_template = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/muse_spark/processing_muse_spark.py#L28) **Paramètres :** image_processor (`MuseGlimmerImageProcessor`) : le processeur d’images est une entrée obligatoire. video_processor (`MuseGlimmerVideoProcessor`) : le processeur vidéo est une entrée obligatoire. tokenizer (`tokenizer_class`) : Le tokenizer est une entrée obligatoire. feature_extractor (`MuseSparkFeatureExtractor`) : l'extracteur de caractéristiques est une entrée obligatoire. chat_template (`str`) : Un modèle Jinja pour convertir des listes de messages d'une conversation en une chaîne tokenisable. Construit un MuseSparkProcessor qui encapsule un processeur d’images, un processeur de vidéos, un tokenizer et un extracteur de caractéristiques en un seul processeur. [MuseSparkProcessor](/docs/transformers/main/fr/model_doc/muse_spark#transformers.MuseSparkProcessor) offre toutes les fonctionnalités de [MuseGlimmerImageProcessor](/docs/transformers/main/fr/model_doc/muse_glimmer#transformers.MuseGlimmerImageProcessor), [MuseGlimmerVideoProcessor](/docs/transformers/main/fr/model_doc/muse_glimmer#transformers.MuseGlimmerVideoProcessor), `tokenizer_class` et [MuseSparkFeatureExtractor](/docs/transformers/main/fr/model_doc/muse_spark#transformers.MuseSparkFeatureExtractor). Consultez [~MuseGlimmerImageProcessor](/docs/transformers/main/fr/model_doc/muse_glimmer#transformers.MuseGlimmerImageProcessor), [~MuseGlimmerVideoProcessor](/docs/transformers/main/fr/model_doc/muse_glimmer#transformers.MuseGlimmerVideoProcessor), `~tokenizer_class` et [~MuseSparkFeatureExtractor](/docs/transformers/main/fr/model_doc/muse_spark#transformers.MuseSparkFeatureExtractor) pour plus d’informations. ## MuseSparkPreTrainedModel[[transformers.MuseSparkPreTrainedModel]] #### transformers.MuseSparkPreTrainedModel[[transformers.MuseSparkPreTrainedModel]] ```python transformers.MuseSparkPreTrainedModel(config: PreTrainedConfig, *inputs, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/muse_spark/modeling_muse_spark.py#L494) **Paramètres :** config ([PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux. ## MuseSparkTextModel[[transformers.MuseSparkTextModel]] #### transformers.MuseSparkTextModel[[transformers.MuseSparkTextModel]] ```python transformers.MuseSparkTextModel(config: MuseSparkTextConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/muse_spark/modeling_muse_spark.py#L590) **Paramètres :** config ([MuseSparkTextConfig](/docs/transformers/main/fr/model_doc/muse_spark#transformers.MuseSparkTextConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Le modèle de texte Muse Spark brut, produisant des états cachés bruts sans aucune tête spécifique au sommet. Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux. #### forward[[transformers.MuseSparkTextModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/muse_spark/modeling_muse_spark.py#L615) **Paramètres :** input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`. [Que sont les identifiants de position ?](../glossary#position-ids) past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`. Seule une instance de [Cache](/docs/transformers/main/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/main/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut. Le modèle renverra le même format de cache que celui fourni en entrée. Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`). **Retourne :** `MoeModelOutputWithPast` ou `tuple(torch.Tensor)` Un `MoeModelOutputWithPast` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([MuseSparkConfig](/docs/transformers/main/fr/model_doc/muse_spark#transformers.MuseSparkConfig)) et les entrées. La méthode forward du modèle [MuseSparkTextModel](/docs/transformers/main/fr/model_doc/muse_spark#transformers.MuseSparkTextModel) redéfinit la méthode spéciale `__call__`. Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement. - **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle. - **past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [Cache](/docs/transformers/main/fr/internal/generation_utils#transformers.Cache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et, le cas échéant, si `config.is_encoder_decoder=True`, dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel. - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. - **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. - **router_logits** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_router_probs=True` et `config.add_router_probs=True` sont passés ou lorsque `config.output_router_probs=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, sequence_length, num_experts)`. Logits bruts du routeur (après softmax) calculés par les routeurs MoE ; ces termes sont utilisés pour calculer la perte auxiliaire des modèles Mixture of Experts. ## MuseSparkVisionModel[[transformers.MuseSparkVisionModel]] #### transformers.MuseSparkVisionModel[[transformers.MuseSparkVisionModel]] ```python transformers.MuseSparkVisionModel(config: MuseSparkVisionConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/muse_spark/modeling_muse_spark.py#L948) **Paramètres :** config ([MuseSparkVisionConfig](/docs/transformers/main/fr/model_doc/muse_spark#transformers.MuseSparkVisionConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Le modèle Muse Spark brut, produisant des états cachés bruts sans aucune tête spécifique au sommet. Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux. #### forward[[transformers.MuseSparkVisionModel.forward]] ```python forward(pixel_values: Tensor, grid_thw: LongTensor, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/muse_spark/modeling_muse_spark.py#L979) **Paramètres :** pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`) : Les tenseurs correspondant aux images d’entrée. Les valeurs des pixels peuvent être obtenues à l’aide de [MuseGlimmerImageProcessor](/docs/transformers/main/fr/model_doc/muse_glimmer#transformers.MuseGlimmerImageProcessor). Voir [MuseGlimmerImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails ([MuseSparkProcessor](/docs/transformers/main/fr/model_doc/muse_spark#transformers.MuseSparkProcessor) utilise [MuseGlimmerImageProcessor](/docs/transformers/main/fr/model_doc/muse_glimmer#transformers.MuseGlimmerImageProcessor) pour le traitement des images). grid_thw (`torch.LongTensor` de forme `(num_images_or_videos, 3)`) : Dimensions de la grille de patches temporel, hauteur et largeur pour chaque image ou vidéo empilée. **Retourne :** [BaseModelOutputWithPooling](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)` Un [BaseModelOutputWithPooling](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([MuseSparkConfig](/docs/transformers/main/fr/model_doc/muse_spark#transformers.MuseSparkConfig)) et les entrées. La méthode forward du modèle [MuseSparkVisionModel](/docs/transformers/main/fr/model_doc/muse_spark#transformers.MuseSparkVisionModel) redéfinit la méthode spéciale `__call__`. Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement. - **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle. - **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement. - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. - **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. ## MuseSparkAudioModel[[transformers.MuseSparkAudioModel]] #### transformers.MuseSparkAudioModel[[transformers.MuseSparkAudioModel]] ```python transformers.MuseSparkAudioModel(config: MuseSparkAudioConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/muse_spark/modeling_muse_spark.py#L1213) **Paramètres :** config ([MuseSparkAudioConfig](/docs/transformers/main/fr/model_doc/muse_spark#transformers.MuseSparkAudioConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. L'encodeur audio à forme d'onde Muse Spark Open : une pyramide convolutive entièrement causale qui mappe l'audio mono brut à 24 kHz vers un seul embedding par tranche de 1920 échantillons (80 ms, soit 12,5 Hz), déjà dans la taille de représentation cachée du modèle de texte. Il n'utilise ni mécanisme d'attention ni prétraitement par spectrogramme. Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux. #### forward[[transformers.MuseSparkAudioModel.forward]] ```python forward(input_values: Tensor, padding_cache: transformers.models.muse_spark.modeling_muse_spark.MuseSparkAudioConv1dPaddingCache | None = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/muse_spark/modeling_muse_spark.py#L1228) **Paramètres :** input_values (`torch.Tensor` de forme `(batch_size, sequence_length)`) : Valeurs flottantes de la forme d'onde brute de l'entrée audio. Les valeurs peuvent être obtenues en chargeant un fichier audio `.flac` ou `.wav` dans un tableau de type `list[float]`, un `numpy.ndarray` ou un `torch.Tensor`, *par exemple* via la bibliothèque torchcodec (`pip install torchcodec`) ou la bibliothèque soundfile (`pip install soundfile`). Pour préparer le tableau en `input_values`, le [AutoProcessor](/docs/transformers/main/fr/model_doc/auto#transformers.AutoProcessor) doit être utilisé pour le bourrage (padding) et la conversion en un tenseur de type `torch.Tensor`. Voir [MuseSparkProcessor.__call__()](/docs/transformers/main/fr/main_classes/processors#transformers.ProcessorMixin.__call__) pour plus de détails. padding_cache (`MuseSparkAudioConv1dPaddingCache`, *facultatif*) : Cache pour le padding dans les couches de convolution afin de maintenir l'état entre les segments de streaming. **Retourne :** [BaseModelOutput](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou `tuple(torch.Tensor)` Un [BaseModelOutput](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([MuseSparkConfig](/docs/transformers/main/fr/model_doc/muse_spark#transformers.MuseSparkConfig)) et les entrées. La méthode forward du modèle [MuseSparkAudioModel](/docs/transformers/main/fr/model_doc/muse_spark#transformers.MuseSparkAudioModel) redéfinit la méthode spéciale `__call__`. Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement. - **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle. - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. - **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. ## MuseSparkModel[[transformers.MuseSparkModel]] #### transformers.MuseSparkModel[[transformers.MuseSparkModel]] ```python transformers.MuseSparkModel(config: MuseSparkConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/muse_spark/modeling_muse_spark.py#L1269) **Paramètres :** config ([MuseSparkConfig](/docs/transformers/main/fr/model_doc/muse_spark#transformers.MuseSparkConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Le modèle Muse Spark brut, produisant des états cachés bruts sans aucune tête spécifique au sommet. Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux. #### forward[[transformers.MuseSparkModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, pixel_values: typing.Optional[torch.Tensor] = None, image_grid_thw: typing.Optional[torch.LongTensor] = None, pixel_values_videos: typing.Optional[torch.Tensor] = None, video_grid_thw: typing.Optional[torch.LongTensor] = None, input_values: typing.Optional[torch.Tensor] = None, input_values_mask: typing.Optional[torch.Tensor] = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/muse_spark/modeling_muse_spark.py#L1362) **Paramètres :** input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`. [Que sont les identifiants de position ?](../glossary#position-ids) past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`. Seule une instance de [Cache](/docs/transformers/main/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/main/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut. Le modèle renverra le même format de cache que celui fourni en entrée. Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`). pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`, *facultatif*) : Les tenseurs correspondant aux images d’entrée. Les valeurs de pixels peuvent être obtenues à l’aide de [MuseGlimmerImageProcessor](/docs/transformers/main/fr/model_doc/muse_glimmer#transformers.MuseGlimmerImageProcessor). Voir [MuseGlimmerImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails ([MuseSparkProcessor](/docs/transformers/main/fr/model_doc/muse_spark#transformers.MuseSparkProcessor) utilise [MuseGlimmerImageProcessor](/docs/transformers/main/fr/model_doc/muse_glimmer#transformers.MuseGlimmerImageProcessor) pour le traitement des images). image_grid_thw (`torch.LongTensor` de forme `(num_images, 3)`, *facultatif*) : La dimension temporelle, la hauteur et la largeur de la forme des caractéristiques de chaque image dans le LLM. pixel_values_videos (`torch.Tensor` de forme `(batch_size, num_frames, num_channels, frame_size, frame_size)`, *facultatif*) : Les tenseurs correspondant à la vidéo d'entrée. Les valeurs de pixels des vidéos peuvent être obtenues à l'aide de [MuseGlimmerVideoProcessor](/docs/transformers/main/fr/model_doc/muse_glimmer#transformers.MuseGlimmerVideoProcessor). Voir [MuseGlimmerVideoProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) pour plus de détails ([MuseSparkProcessor](/docs/transformers/main/fr/model_doc/muse_spark#transformers.MuseSparkProcessor) utilise [MuseGlimmerVideoProcessor](/docs/transformers/main/fr/model_doc/muse_glimmer#transformers.MuseGlimmerVideoProcessor) pour le traitement des vidéos). video_grid_thw (`torch.LongTensor` de forme `(num_videos, 3)`, *facultatif*) : La dimension temporelle, la hauteur et la largeur de la forme des caractéristiques de chaque vidéo dans le LLM. input_values (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Valeurs flottantes de la forme d'onde brute de l'entrée audio. Les valeurs peuvent être obtenues en chargeant un fichier audio `.flac` ou `.wav` dans un tableau de type `list[float]`, un `numpy.ndarray` ou un `torch.Tensor`, *par exemple* via la bibliothèque torchcodec (`pip install torchcodec`) ou la bibliothèque soundfile (`pip install soundfile`). Pour préparer le tableau en `input_values`, le [AutoProcessor](/docs/transformers/main/fr/model_doc/auto#transformers.AutoProcessor) doit être utilisé pour le bourrage (padding) et la conversion en un tenseur de type `torch.Tensor`. Voir [MuseSparkProcessor.__call__()](/docs/transformers/main/fr/main_classes/processors#transformers.ProcessorMixin.__call__) pour plus de détails. input_values_mask (`torch.Tensor` de forme `(batch_size, num_samples)`, *facultatif*) : Indique quelles entrées de `input_values` correspondent à de l'audio réel plutôt qu'à du bourrage, tel que généré par [MuseSparkFeatureExtractor](/docs/transformers/main/fr/model_doc/muse_spark#transformers.MuseSparkFeatureExtractor). Requis lors du groupement de clips de longueurs différentes. mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *facultatif*) : Dictionnaire dont les clés sont les modalités prises en charge et les valeurs sont les sorties encodées pour cette modalité. Chaque sortie encodée est un tuple composé de (`pooler_output`, *facultatif* : `last_hidden_states`, *facultatif* : `hidden_states`, *facultatif* : `attentions`) `pooler_output` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) est une séquence de fonctionnalités multimodales de l'encodeur fusionnées dans les embeddings de texte. **Retourne :** `MuseSparkModelOutputWithPast` ou `tuple(torch.Tensor)` Un `MuseSparkModelOutputWithPast` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([MuseSparkConfig](/docs/transformers/main/fr/model_doc/muse_spark#transformers.MuseSparkConfig)) et les entrées. La méthode forward du [MuseSparkModel](/docs/transformers/main/fr/model_doc/muse_spark#transformers.MuseSparkModel) redéfinit la méthode spéciale `__call__`. Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement. - **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle. Si `past_key_values` est utilisé, seule la dernière hidden-state des séquences de forme `(batch_size, 1, hidden_size)` est renvoyée. - **past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [Cache](/docs/transformers/main/fr/internal/generation_utils#transformers.Cache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et, le cas échéant, si `config.is_encoder_decoder=True`, dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel. - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. - **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. - **image_hidden_states** (`torch.Tensor`, *facultatif*) -- Un `torch.Tensor` de taille `(batch_size, num_images, sequence_length, hidden_size)`. image_hidden_states du modèle produit par l'encodeur visuel et après projection de l'état caché final. - **router_logits** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_router_logits=True` est passé ou lorsque `config.add_router_probs=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, sequence_length, num_experts)`. Logits du routeur du modèle, utiles pour calculer la perte auxiliaire des modèles Mixture of Experts. Exemple : ```python >>> import os >>> from transformers import AutoProcessor, DistributedConfig, MuseSparkModel >>> distributed_config = DistributedConfig( ... tp_size=int(os.environ["WORLD_SIZE"]), ... ep_size=int(os.environ["WORLD_SIZE"]), ... ) >>> processor = AutoProcessor.from_pretrained("meta-models/Muse-Spark-Open-816B-A42B") >>> model = MuseSparkModel.from_pretrained( ... "meta-models/Muse-Spark-Open-816B-A42B", ... dtype="auto", ... distributed_config=distributed_config, ... ) >>> messages = [ ... { ... "role": "user", ... "content": [ ... {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"}, ... {"type": "text", "text": "What is shown in this image?"}, ... ], ... }, ... ] >>> inputs = processor.apply_chat_template( ... messages, ... reasoning_effort="medium", ... add_generation_prompt=True, ... tokenize=True, ... return_dict=True, ... return_tensors="pt", ... ).to(model.device).to(model.dtype) >>> outputs = model(**inputs) >>> last_hidden_state = outputs.last_hidden_state ``` ## MuseSparkForConditionalGeneration[[transformers.MuseSparkForConditionalGeneration]] #### transformers.MuseSparkForConditionalGeneration[[transformers.MuseSparkForConditionalGeneration]] ```python transformers.MuseSparkForConditionalGeneration(config: MuseSparkConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/muse_spark/modeling_muse_spark.py#L1552) **Paramètres :** config ([MuseSparkConfig](/docs/transformers/main/fr/model_doc/muse_spark#transformers.MuseSparkConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Le modèle Muse Spark pour la génération de jetons conditionnée sur d'autres modalités (par exemple, la génération texte-image-vers-texte). Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux. #### forward[[transformers.MuseSparkForConditionalGeneration.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, image_grid_thw: typing.Optional[torch.LongTensor] = None, pixel_values_videos: typing.Optional[torch.Tensor] = None, video_grid_thw: typing.Optional[torch.LongTensor] = None, input_values: typing.Optional[torch.Tensor] = None, input_values_mask: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/muse_spark/modeling_muse_spark.py#L1590) **Paramètres :** input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`, *facultatif*) : Les tenseurs correspondant aux images d’entrée. Les valeurs de pixels peuvent être obtenues à l’aide de [MuseGlimmerImageProcessor](/docs/transformers/main/fr/model_doc/muse_glimmer#transformers.MuseGlimmerImageProcessor). Voir [MuseGlimmerImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails ([MuseSparkProcessor](/docs/transformers/main/fr/model_doc/muse_spark#transformers.MuseSparkProcessor) utilise [MuseGlimmerImageProcessor](/docs/transformers/main/fr/model_doc/muse_glimmer#transformers.MuseGlimmerImageProcessor) pour le traitement des images). image_grid_thw (`torch.LongTensor` de forme `(num_images, 3)`, *facultatif*) : La dimension temporelle, la hauteur et la largeur de la forme des caractéristiques de chaque image dans le LLM. pixel_values_videos (`torch.Tensor` de forme `(batch_size, num_frames, num_channels, frame_size, frame_size)`, *facultatif*) : Les tenseurs correspondant à la vidéo d'entrée. Les valeurs de pixels des vidéos peuvent être obtenues à l'aide de [MuseGlimmerVideoProcessor](/docs/transformers/main/fr/model_doc/muse_glimmer#transformers.MuseGlimmerVideoProcessor). Voir [MuseGlimmerVideoProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) pour plus de détails ([MuseSparkProcessor](/docs/transformers/main/fr/model_doc/muse_spark#transformers.MuseSparkProcessor) utilise [MuseGlimmerVideoProcessor](/docs/transformers/main/fr/model_doc/muse_glimmer#transformers.MuseGlimmerVideoProcessor) pour le traitement des vidéos). video_grid_thw (`torch.LongTensor` de forme `(num_videos, 3)`, *facultatif*) : La dimension temporelle, la hauteur et la largeur de la forme des caractéristiques de chaque vidéo dans le LLM. input_values (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Valeurs flottantes de la forme d'onde brute de l'entrée audio. Les valeurs peuvent être obtenues en chargeant un fichier audio `.flac` ou `.wav` dans un tableau de type `list[float]`, un `numpy.ndarray` ou un `torch.Tensor`, *par exemple* via la bibliothèque torchcodec (`pip install torchcodec`) ou la bibliothèque soundfile (`pip install soundfile`). Pour préparer le tableau en `input_values`, le [AutoProcessor](/docs/transformers/main/fr/model_doc/auto#transformers.AutoProcessor) doit être utilisé pour le bourrage (padding) et la conversion en un tenseur de type `torch.Tensor`. Voir [MuseSparkProcessor.__call__()](/docs/transformers/main/fr/main_classes/processors#transformers.ProcessorMixin.__call__) pour plus de détails. input_values_mask (`torch.Tensor` de forme `(batch_size, num_samples)`, *facultatif*) : Indique quelles entrées de `input_values` correspondent à de l'audio réel plutôt qu'à du bourrage, tel que généré par [MuseSparkFeatureExtractor](/docs/transformers/main/fr/model_doc/muse_spark#transformers.MuseSparkFeatureExtractor). Requis lors du groupement de clips de longueurs différentes. attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`. [Que sont les identifiants de position ?](../glossary#position-ids) past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`. Seule une instance de [Cache](/docs/transformers/main/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/main/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut. Le modèle renverra le même format de cache que celui fourni en entrée. Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. labels (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être compris dans `[0, ..., config.vocab_size]` ou égaux à -100 (voir la docstring de `input_ids`). Les jetons dont l'indice est défini sur `-100` sont ignorés (masqués) ; la perte n'est calculée que pour les jetons dont l'étiquette est comprise dans `[0, ..., config.vocab_size]`. use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`). logits_to_keep (`Union[int, torch.Tensor]`, *facultatif*, valeur par défaut `0`) : Si c'est un `int`, calcule les logits pour les `logits_to_keep` derniers jetons. Si c'est `0`, calcule les logits pour tous les `input_ids` (cas particulier). Seuls les logits du dernier jeton sont nécessaires pour la génération, et les calculer uniquement pour ce jeton peut faire économiser de la mémoire, ce qui devient assez significatif pour les séquences longues ou les tailles de vocabulaire importantes. Si c'est un `torch.Tensor`, il doit être 1D et correspondre aux indices à conserver dans la dimension de la longueur de la séquence. C'est utile lors de l'utilisation du format de tenseurs empilés (une seule dimension pour le lot et la longueur de la séquence). mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *facultatif*) : Dictionnaire dont les clés sont les modalités prises en charge et les valeurs sont les sorties encodées pour cette modalité. Chaque sortie encodée est un tuple composé de (`pooler_output`, *facultatif* : `last_hidden_states`, *facultatif* : `hidden_states`, *facultatif* : `attentions`) `pooler_output` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) est une séquence de fonctionnalités multimodales de l'encodeur fusionnées dans les embeddings de texte. **Retourne :** `MuseSparkCausalLMOutputWithPast` ou `tuple(torch.Tensor)` Un `MuseSparkCausalLMOutputWithPast` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([MuseSparkConfig](/docs/transformers/main/fr/model_doc/muse_spark#transformers.MuseSparkConfig)) et les entrées. La méthode forward de [MuseSparkForConditionalGeneration](/docs/transformers/main/fr/model_doc/muse_spark#transformers.MuseSparkForConditionalGeneration) redéfinit la méthode spéciale `__call__`. Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement. - **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de modélisation du langage (pour la prédiction du jeton suivant). - **logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.text_config.vocab_size)`) -- Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax). - **past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [Cache](/docs/transformers/main/fr/internal/generation_utils#transformers.Cache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel. - **hidden_states** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. - **attentions** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. - **image_hidden_states** (`torch.Tensor`, *facultatif*) -- Un `torch.Tensor` de taille `(batch_size, num_images, sequence_length, hidden_size)`. image_hidden_states du modèle produit par l'encodeur visuel après projection de l'état caché final. - **router_logits** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_router_logits=True` est passé ou lorsque `config.add_router_probs=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, sequence_length, num_experts)`. Logits du routeur du modèle, utiles pour calculer la perte auxiliaire des modèles Mixture of Experts. Exemple : ```python >>> import os >>> from transformers import AutoProcessor, DistributedConfig, MuseSparkForConditionalGeneration >>> distributed_config = DistributedConfig( ... tp_size=int(os.environ["WORLD_SIZE"]), ... ep_size=int(os.environ["WORLD_SIZE"]), ... ) >>> processor = AutoProcessor.from_pretrained("meta-models/Muse-Spark-Open-816B-A42B") >>> model = MuseSparkForConditionalGeneration.from_pretrained( ... "meta-models/Muse-Spark-Open-816B-A42B", ... dtype="auto", ... distributed_config=distributed_config, ... ) >>> messages = [ ... { ... "role": "user", ... "content": [ ... {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"}, ... {"type": "text", "text": "What is shown in this image?"}, ... ], ... }, ... ] >>> inputs = processor.apply_chat_template( ... messages, ... reasoning_effort="medium", ... add_generation_prompt=True, ... tokenize=True, ... return_dict=True, ... return_tensors="pt", ... ).to(model.device).to(model.dtype) >>> input_len = inputs["input_ids"].shape[-1] >>> outputs = model.generate(**inputs, max_new_tokens=512) >>> response = processor.decode(outputs[0][input_len:], skip_special_tokens=False) >>> print(response) The image shows a **Pallas's cat — also known as a manul, *Otocolobus manul*** — walking through snow. ... ```