Transformers documentation
MuseGlimmer
Ce modèle a été contribué à Hugging Face Transformers le 2026-08-09.
MuseGlimmer
MuseGlimmer est un modèle multimodal de 30B issu du Meta Superintelligence Lab, conçu pour des agents fonctionnant localement sur du matériel grand public. Un décodeur texte dense de 52 couches gère le texte et les images entremêlés, tandis qu’un encodeur de perception ViT-G/14 figé transforme les captures d’écran, les graphiques et les documents en jetons visuels. La sortie est exclusivement du texte.
Trois couches sur quatre du décodeur utilisent l'attention à fenêtre glissante sur une fenêtre de 2048 jetons. La quatrième est une couche d'attention complète avec les embeddings rotationnels désactivés (NoPE), offrant au modèle un contexte de 131K. L'attention applique également un plafonnement doux aux logits finaux et un échelle supplémentaire aux requêtes après la normalisation QK.
Le modèle est livré avec un rédacteur compagnon, MuseGlimmerAssistant, pour le décodage spéculatif DFlash, qui rédige un bloc entier de jetons par passe avant.
from transformers import pipeline
pipeline = pipeline(
task="image-text-to-text",
model="meta-models/Muse-Glimmer-30B",
dtype="auto",
device_map="auto",
)
messages = [
{
"role": "user",
"content": [
{"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
{"type": "text", "text": "What is shown in this image?"},
],
},
]
pipeline(messages, max_new_tokens=64)import torch
from transformers import AutoProcessor, AutoModelForMultimodalLM
processor = AutoProcessor.from_pretrained("meta-models/Muse-Glimmer-30B")
model = AutoModelForMultimodalLM.from_pretrained(
"meta-models/Muse-Glimmer-30B",
device_map="auto",
)
messages = [
{
"role": "user",
"content": [
{"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
{"type": "text", "text": "What is shown in this image?"},
],
},
]
inputs = processor.apply_chat_template(
messages,
add_generation_prompt=True,
tokenize=True,
return_dict=True,
return_tensors="pt",
).to(model.device)
input_len = inputs["input_ids"].shape[-1]
outputs = model.generate(**inputs)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
print(response)Notes
Le modèle de conversation accepte un argument
reasoning_strengthpour arbitrer entre la qualité et la latence. Transmettez-le viaapply_chat_templateavec les définitions d’outils.inputs = processor.apply_chat_template( messages, reasoning_strength="high", add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt", )Les vidéos sont traitées sous forme d’images, et MuseGlimmerProcessor insère un marqueur
Time: <seconds>savant chaque groupe temporel afin que le modèle puisse raisonner sur l’ordre. Les horodatements proviennent des métadonnées de la vidéo ; passez doncvideo_metadatalorsque la fréquence d’images ne peut pas être déduite. Sinon, le processeur émet un avertissement et bascule sur 24 fps, ce qui décale tous les horodatements dans le prompt.Les images et les vidéos sont développées en plages de jetons par le processeur. Une image devient
<|image_start|>suivie d'un<|patch|>par patch fusionné et de<|image_end|>. N'incluez que{"type": "image"}dans les messages de chat.MuseGlimmerTextConfig dérive
layer_typesetlayer_rope_thetaà partir denum_hidden_layersdans son__post_init__, en comptant les couches NoPE à rebours depuis la dernière couche. Définissez les deux explicitement si vous modifiez le nombre de couches et souhaitez un motif différent.Consultez le billet de blog Meta is back with Muse Glimmer: local, agentic, multimodal, and open source! pour plus de détails et des exemples d'utilisation.
MuseGlimmerConfig
classe transformers.MuseGlimmerConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonevision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneimage_token_id: int = 200092video_token_id: int = 200091out_hidden_size: int = 6144projector_hidden_size: int = 4096projector_hidden_act: str = 'gelu' )
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, par défaut200092) — L’index du jeton d’image utilisé comme espace réservé pour les images d’entrée. - video_token_id (
int, facultatif, par défaut200091) — L’index du jeton vidéo utilisé comme espace réservé pour les vidéos d’entrée. - out_hidden_size (
int, facultatif, 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éfautgelu) — La fonction d'activation utilisée par le projecteur multimodal.
Ceci est la classe de configuration destinée à stocker la configuration d'un MuseGlimmerModel. Elle est utilisée pour instancier un modèle Muse Glimmer en fonction des arguments spécifiés, définissant ainsi 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-Glimmer-30B
Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.
Exemple :
>>> from transformers import MuseGlimmerForConditionalGeneration, MuseGlimmerConfig
>>> # Initializing an MuseGlimmer style configuration
>>> configuration = MuseGlimmerConfig()
>>> # Initializing a model from the configuration
>>> model = MuseGlimmerForConditionalGeneration(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configMuseGlimmerTextConfig
classe transformers.MuseGlimmerTextConfig
< 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 = 202048hidden_size: int = 6656intermediate_size: int = 19968num_hidden_layers: int = 52num_attention_heads: int = 32num_key_value_heads: int = 2head_dim: int = 128hidden_activation: str = 'silu'max_position_embeddings: int = 131072initializer_range: float = 0.02rms_norm_eps: float = 1e-05use_cache: bool = Truepad_token_id: int | None = Noneeos_token_id: int | list[int] | None = 200001bos_token_id: int | None = 200000tie_word_embeddings: bool = Falserope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Noneattention_bias: bool = Falseattention_dropout: int | float | None = 0.0sliding_window: int | None = 2048layer_types: list[str] | None = Nonefinal_logit_softcapping: float = 20.0qk_scale_factor: float = 3.87output_multiplier: float = 0.19611613513818404post_norm_eps: float = 1e-08layer_rope_theta: list[float | int] | None = None )
Paramètres
- vocab_size (
int, facultatif, par défaut202048) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés parinput_ids. - hidden_size (
int, facultatif, par défaut6656) — Dimension des représentations cachées. - intermediate_size (
int, facultatif, par défaut19968) — Dimension des représentations MLP. - num_hidden_layers (
int, facultatif, par défaut52) — Nombre de couches cachées dans le décodeur Transformer. - num_attention_heads (
int, facultatif, valeur par défaut32) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - num_key_value_heads (
int, facultatif, valeur par défaut2) — Ceci est le nombre de têtes key_value à utiliser pour implémenter l'attention Grouped Query. Sinum_key_value_heads=num_attention_heads, le modèle utilisera l'attention Multi Head (MHA), sinum_key_value_heads=1le modèle utilisera l'attention Multi Query (MQA), sinon l'attention GQA est utilisée. Lors de la conversion d'un checkpoint multi-têtes en checkpoint GQA, chaque tête clé et valeur de groupe doit être construite en effectuant un meanpooling de toutes les têtes d'origine au sein de ce groupe. Pour plus de détails, consultez ce papier. S'il n'est pas spécifié, la valeur par défaut seranum_attention_heads. - head_dim (
int, facultatif, par défaut128) — La dimension des têtes d'attention. Si None, elle est par défaut égale à hidden_size // num_attention_heads - hidden_activation (
str, facultatif, par défautsilu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple,"gelu","relu","silu", etc. - max_position_embeddings (
int, facultatif, par défaut131072) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. - initializer_range (
float, facultatif, par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - rms_norm_eps (
float, facultatif, valeur par défaut1e-05) — L'épsilon utilisé par les couches de normalisation rms. - use_cache (
bool, facultatif, valeur par défautTrue) — Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). N’est pertinent que siconfig.is_decoder=Trueou si le modèle est un modèle génératif uniquement décodeur. - pad_token_id (
int, facultatif) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire. - eos_token_id (
Union[int, list[int]], facultatif, par défaut200001) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire. - bos_token_id (
int, facultatif, par défaut200000) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire. - tie_word_embeddings (
bool, facultatif, valeur par défautFalse) — Indique s'il faut lier les embeddings de poids selon la correspondancetied_weights_keysdu 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 pourrope_thetaet, le cas échéant, les paramètres utilisés pour le mise à l’échelle si vous souhaitez utiliser RoPE avec desmax_position_embeddingsplus longs. - attention_bias (
bool, facultatif, par défautFalse) — Indique s'il faut utiliser un biais dans les couches de projection des requêtes, des clés, des valeurs et de la sortie lors de l'auto-attention. - attention_dropout (
Union[int, float], facultatif, valeur par défaut0.0) — Le taux de dropout appliqué aux probabilités d'attention. - sliding_window (
int, facultatif, par défaut2048) — Taille de la fenêtre d'attention glissante. SiNone, 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) — facteur d'échelle appliqué lors de l'utilisation du softcapping tanh sur les logits. - qk_scale_factor (
float, facultatif, valeur par défaut 3,87) — Multiplicateur appliqué à Q après la normalisation QK sans échelle, en plus de l'échelle d'attention standard1/sqrt(head_dim). - output_multiplier (
float, facultatif, valeur par défaut 0.19611613513818404) — Échelle appliquée aux logits avant le softcap tanh final. Égal à1/sqrt(hidden_size / 256)pour le point de contrôle 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 ;0désactive la rotation (NoPE) pour cette couche. Remplace le paramètre globalrope_parameters["rope_theta"]. Par défaut, le theta global est utilisé partout, sauf pour chaque 4e couche en partant de la dernière, qui est en NoPE.
Ceci est la classe de configuration destinée à stocker la configuration d'un MuseGlimmerModel. Elle est utilisée pour instancier un modèle Muse Glimmer en fonction des arguments spécifiés, définissant ainsi 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-Glimmer-30B
Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.
MuseGlimmerVisionConfig
classe transformers.MuseGlimmerVisionConfig
< 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 = Nonepatch_size: int = 14pos_emb_height: int = 32pos_emb_width: int = 32num_attention_heads: int = 16num_hidden_layers: int = 50hidden_size: int = 1536intermediate_size: int = 8960hidden_act: str = 'gelu'rope_parameters: dict | None = Nonepatch_temporal: int = 2merge_size: int = 2max_position_embeddings: int = 1024layer_norm_eps: float = 1e-05layer_types: list[str] | None = None )
Paramètres
- patch_size (
int, facultatif, par défaut14) — 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’incorporation de position. - num_attention_heads (
int, facultatif, valeur par défaut16) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - num_hidden_layers (
int, facultatif, par défaut50) — Nombre de couches cachées dans le décodeur Transformer. - hidden_size (
int, facultatif, par défaut1536) — Dimension des représentations cachées. - intermediate_size (
int, facultatif, par défaut8960) — Dimension des représentations du MLP. - hidden_act (
str, facultatif, par défautgelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple,"gelu","relu","silu", etc. - rope_parameters (
dict, facultatif) — Dictionnaire contenant les paramètres de configuration des embeddings RoPE. Le dictionnaire doit contenir une valeur pourrope_thetaet, le cas échéant, les paramètres utilisés pour le mise à l’échelle si vous souhaitez utiliser RoPE avec desmax_position_embeddingsplus 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, par défaut1024) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. - layer_norm_eps (
float, facultatif, valeur par défaut1e-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.
Ceci est la classe de configuration destinée à stocker la configuration d'un MuseGlimmerModel. Elle est utilisée pour instancier un modèle Muse Glimmer en fonction des arguments spécifiés, définissant ainsi 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-Glimmer-30B
Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.
MuseGlimmerImageProcessor
classe transformers.MuseGlimmerImageProcessor
< source >( **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> )
Paramètres
- do_convert_rgb (
bool, kwargs, facultatif, par défautTrue) — Indique s'il faut convertir l'image en RGB. - do_resize (
bool, kwargs, facultatif, valeur par défautTrue) — Indique s'il faut redimensionner l'image. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, par défautNone) — Définit les dimensions maximales des entrées du modèle. - default_to_square (
bool, kwargs, facultatif, valeur par défautFalse) — Indique s'il faut utiliser une image carrée par défaut lors du redimensionnement, si size est un entier. - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Taille de l'image de sortie après application decenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, par défaut1) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enumPILImageResampling. N’a un effet que sido_resizeest défini surTrue. - do_rescale (
bool, kwargs, facultatif, par défautTrue) — Indique s'il faut rééchelonner l'image. - rescale_factor (
float, kwargs, facultatif, valeur par défaut0.00392156862745098) — Facteur de remise à l'échelle appliqué à l'image sido_rescaleest défini surTrue. - do_normalize (
bool, kwargs, facultatif, valeur par défautTrue) — Indique s'il faut normaliser l'image. - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, facultatif, valeur par défaut[0.5, 0.5, 0.5]) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que sido_normalizeest défini surTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, facultatif, valeur par défaut[0.5, 0.5, 0.5]) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que sido_normalizeest défini surTrue. - do_pad (
bool, kwargs, facultatif) — Indique s'il faut effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle. - pad_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — La taille au format{"height": int, "width" int}à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Sipad_sizen'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsquedo_pad=True. - do_center_crop (
bool, kwargs, facultatif) — Indique s'il faut effectuer un recadrage centré de l'image. - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — SeulChannelDimension.FIRSTest pris en charge. Ajouté pour la compatibilité avec les processeurs lents. - input_data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :"channels_first"ouChannelDimension.FIRST: image au format (num_channels, height, width)."channels_last"ouChannelDimension.LAST: image au format (hauteur, largeur, nombre de canaux)."none"ouChannelDimension.NONE: image au format (hauteur, largeur).
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée. - return_tensors (
Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retourne des tenseurs empilés si défini sur'pt', sinon retourne une liste de tenseurs. - disable_grouping (
bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. Retourne des tenseurs empilés si défini sur'pt', sinon retourne une liste de tenseurs. - disable_grouping (
bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. Retourne des tenseurs empilés si défini sur'pt', sinon retourne une liste de tenseurs. - disable_grouping (
bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. Retourne des tenseurs empilés si défini sur'pt', sinon retourne une liste de tenseurs. - disable_grouping (
bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. Retourne des tenseurs empilés si défini sur'pt', sinon retourne une liste de tenseurs. - disable_grouping (
bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. Retourne des tenseurs empilés si défini sur'pt', sinon retourne une liste de tenseurs. - disable_grouping (
bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. Retourne des tenseurs empilés si défini sur'pt', sinon retourne une liste de tenseurs. - disable_grouping (
bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. Retourne des tenseurs empilés si défini sur'pt', sinon retourne une liste de tenseurs. - disable_grouping (
bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. Retourne des tenseurs empilés si défini sur'pt', sinon retourne une liste de tenseurs. - disable_grouping (
bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. Retourne des tenseurs empilés si défini sur'pt', sinon retourne une liste de tenseurs. - disable_grouping (
bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. Retourne des tenseurs empilés si défini sur'pt', sinon retourne une liste de tenseurs. - disable_grouping (
bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. Retourne des tenseurs empilés si défini sur'pt', sinon retourne une liste de tenseurs. - disable_grouping (
bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. Retourne des tenseurs empilés si défini sur'pt', sinon retourne une liste de tenseurs. - disable_grouping (
bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. Retourne des tenseurs empilés si défini sur'pt', sinon retourne une liste de tenseurs. - disable_grouping (
bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. Retourne des tenseurs empilés si défini sur'pt', sinon retourne une liste de tenseurs. - disable_grouping (
bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. - Returns des tenseurs empilés si défini sur
'pt', sinon retourne une liste de tenseurs. —
Construit un processeur d’images MuseGlimmerImageProcessor.
disable_grouping (bool, kwargs, facultatif) :
Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement et non par lots.
Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur
des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 image_seq_length (int, kwargs, facultatif) :
Le nombre de jetons d'image à utiliser pour chaque image de l'entrée.
Ajouté pour la compatibilité ascendante, mais cette valeur devrait être définie comme un attribut du processeur dans les futurs modèles.
get_number_of_image_patches
< source >( height: intwidth: intimages_kwargs = None ) → int
Un utilitaire qui renvoie le nombre de patches d'image pour une taille d'image donnée.
Note : Ne supprimez pas cette méthode ! Elle est utilisée par vLLM pour inférer le nombre de patches et de placeholders sans une entrée d'image.
Patchifie chaque image en un aplati de forme (seq_len, patch_dim) afin de pouvoir concaténer des pixels de forme dynamique.
prétraiter
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]**kwargs: *<class 'transformers.models.muse_glimmer.image_processing_muse_glimmer.MuseGlimmerImageProcessorKwargs'> ) → ~image_processing_base.BatchFeature
Paramètres
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Image à prétraiter. S'attend à une image unique ou à un lot d'images dont les valeurs de pixels vont de 0 à 255. Si vous passez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissezdo_rescale=False. - do_convert_rgb (
bool, kwargs, facultatif) — Indique s'il faut convertir l'image en RGB. - do_resize (
bool, kwargs, facultatif) — Indique s'il faut redimensionner l'image. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Définit les dimensions maximales des entrées du modèle. - default_to_square (
bool, kwargs, facultatif) — Indique s'il faut par défaut redimensionner l'image en carré si la taille est un entier. - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Taille de l'image de sortie après application decenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enumPILImageResampling. N’a un effet que sido_resizeest défini surTrue. - do_rescale (
bool, kwargs, facultatif) — Indique s'il faut rééchelonner l'image. - rescale_factor (
float, kwargs, facultatif) — Facteur de remise à l'échelle à appliquer à l'image sido_rescaleest défini surTrue. - do_normalize (
bool, kwargs, facultatif) — Indique s'il faut normaliser l'image. - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que sido_normalizeest défini surTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que sido_normalizeest défini surTrue. - do_pad (
bool, kwargs, facultatif) — Indique s'il faut effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle. - pad_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — La taille au format{"height": int, "width" int}à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Sipad_sizen'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsquedo_pad=True. - do_center_crop (
bool, kwargs, facultatif) — Indique s'il faut effectuer un recadrage centré de l'image. - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — SeulChannelDimension.FIRSTest pris en charge. Ajouté pour la compatibilité avec les processeurs lents. - input_data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :"channels_first"ouChannelDimension.FIRST: image au format (num_channels, height, width)."channels_last"ouChannelDimension.LAST: image au format (hauteur, largeur, nombre de canaux)."none"ouChannelDimension.NONE: image au format (hauteur, largeur).
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée. - return_tensors (
Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retourne des tenseurs empilés si défini sur'pt', sinon retourne une liste de tenseurs. - disable_grouping (
bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. - patch_size (
int, kwargs, facultatif, valeur par défaut 14) — Taille spatiale des patches de l'encodeur visuel. - temporal_patch_size (
int, kwargs, facultatif, valeur par défaut 2) — La taille des patches temporels de l'encodeur visuel. - merge_size (
int, kwargs, facultatif, valeur par défaut 2) — Taille de fusion de l'encodeur visuel vers l'encodeur LLM. - max_image_tokens (
int, kwargs, facultatif, valeur par défaut 4096) — Le nombre maximal de jetons d'image fusionnés produits pour une image.
Retourne
~image_processing_base.BatchFeature
- data (
dict) — Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode call (« pixel_values », etc.). - tensor_type (
Union[None, str, TensorType], facultatif) — Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation.
redimensionner
< source >( images: Tensorpatch_size: intmerge_size: intmax_tokens: intresample: typing.Union[PIL.Image.Resampling, torchvision.transforms.v2.functional.InterpolationMode, int, NoneType]**kwargs )
Redimensionner dynamiquement en fonction du ratio d'aspect de l'image d'entrée.
MuseGlimmerVideoProcessor
classe transformers.MuseGlimmerVideoProcessor
< source >( **kwargs: *<class 'transformers.models.muse_glimmer.video_processing_muse_glimmer.MuseGlimmerVideoProcessorInitKwargs'> )
Paramètres
- **kwargs (
MuseGlimmerVideoProcessorInitKwargs, facultatif) — Options de traitement supplémentaires pour chaque modalité (texte, images, vidéos, audio). Les paramètres spécifiques au modèle sont répertoriés ci-dessus ; consultez la classe TypedDict pour la liste complète des arguments pris en charge.
Construit un processeur vidéo MuseGlimmerVideoProcessor.
Patchifie chaque vidéo en un aplati de forme (seq_len, patch_dim) afin de pouvoir concaténer des pixels de forme dynamique.
redimensionner
< source >( videos: Tensorresample: typing.Union[PIL.Image.Resampling, torchvision.transforms.v2.functional.InterpolationMode, int, NoneType]patch_size: intmerge_size: intmax_tokens: int**kwargs )
Redimensionner dynamiquement en fonction du ratio d'aspect de la vidéo d'entrée.
sample_frames
< source >( metadata: VideoMetadatatemporal_patch_size: int | None = Nonenum_frames: int | None = Nonefps: int | float | None = None**kwargs ) → torch.Tensor
Paramètres
- metadata (
VideoMetadata) — Métadonnées de la vidéo contenant des informations sur la durée totale, le fps et le nombre total d’images. - temporal_patch_size (
int, facultatif) — Taille du patch temporel de l'encodeur visuel. Le nombre de frames échantillonnées sera arrondi pour être divisible par le facteur de frame. - num_frames (
int, facultatif) — Nombre maximal de frames à échantillonner. Valeur par défaut :self.num_frames. - fps (
intoufloat, facultatif) — Nombre de cibles d'images à échantillonner par seconde. La valeur par défaut estself.fps.
Retourne
torch.Tensor
Indices pour échantillonner les images vidéo.
Fonction d'échantillonnage par défaut qui échantillonne uniformément le nombre de frames souhaité entre 0 et le nombre total de frames.
Si fps est transmis avec les métadonnées, fps frames par seconde sont échantillonnées uniformément. Les arguments num_frames et fps sont mutuellement exclusifs.
MuseGlimmerProcessor
classe transformers.MuseGlimmerProcessor
< source >( image_processor = Nonevideo_processor = Nonetokenizer = Nonechat_template = None**kwargs )
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. - chat_template (
str) — Un modèle Jinja pour convertir des listes de messages d'une conversation en une chaîne tokenisable.
Construit un MuseGlimmerProcessor qui encapsule un processeur d’images, un processeur de vidéos et un tokenizer en un seul processeur.
MuseGlimmerProcessor offre toutes les fonctionnalités de MuseGlimmerImageProcessor, MuseGlimmerVideoProcessor et de tokenizer_class. Consultez ~MuseGlimmerImageProcessor, ~MuseGlimmerVideoProcessor et ~tokenizer_class pour plus d’informations.
MuseGlimmerPreTrainedModel
classe transformers.MuseGlimmerPreTrainedModel
< source >( config: PreTrainedConfig*inputs**kwargs )
Paramètres
- config (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() pour charger les poids du modèle.
Ce modèle hérite de 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, la taille des têtes, etc.)
Ce modèle est également une sous-classe de 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.
MuseGlimmerTextModel
classe transformers.MuseGlimmerTextModel
< source >( config: MuseGlimmerTextConfig )
Paramètres
- config (MuseGlimmerTextConfig) — 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() pour charger les poids du modèle.
Le modèle de texte Muse Glimmer brut, produisant des états cachés bruts sans aucune tête spécifique au sommet.
Ce modèle hérite de 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, la taille des têtes, etc.)
Ce modèle est également une sous-classe de 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
< 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.FloatTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPast or tuple(torch.FloatTensor)
Paramètres
- input_ids (
torch.LongTensorde 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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- attention_mask (
torch.Tensorde 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 masqués.
- position_ids (
torch.LongTensorde 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]. - past_key_values (
~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'est transmis, DynamicCache sera initialisé par défaut.Le modèle produira le même format de cache qui est fourni en entrée.
Si
past_key_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme(batch_size, unprocessed_length)au lieu de tous lesinput_idsde forme(batch_size, sequence_length). - inputs_embeds (
torch.FloatTensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_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 indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - use_cache (
bool, facultatif) — Si défini surTrue, les états clé-valeurpast_key_valuessont renvoyés et peuvent être utilisés pour accélérer le décodage (voirpast_key_values).
Retourne
BaseModelOutputWithPast ou tuple(torch.FloatTensor)
Un BaseModelOutputWithPast ou un tuple de
torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (MuseGlimmerConfig) et des entrées.
La méthode forward du modèle MuseGlimmerTextModel 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
Moduleplutô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.FloatTensorde 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_valuesest 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é lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Il s’agit d’une instance de Cache. Pour plus de détails, consultez notre guide sur le cache kv.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éepast_key_values) pour accélérer le décodage séquentiel.hidden_states (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.FloatTensor(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.FloatTensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
MuseGlimmerVisionModel
classe transformers.MuseGlimmerVisionModel
< source >( config: MuseGlimmerVisionConfig )
Paramètres
- config (MuseGlimmerVisionConfig) — 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() pour charger les poids du modèle.
Le modèle Muse Glimmer brut, produisant des états cachés bruts sans aucune tête spécifique au sommet.
Ce modèle hérite de 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, la taille des têtes, etc.)
Ce modèle est également une sous-classe de 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
< source >( pixel_values: FloatTensorgrid_thw: LongTensor**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.FloatTensor)
Paramètres
- pixel_values (
torch.FloatTensorde forme(batch_size, num_channels, image_size, image_size)) — Les tenseurs correspondant aux images d'entrée. Les valeurs de pixels peuvent être obtenues à l'aide de MuseGlimmerImageProcessor. Voir MuseGlimmerImageProcessor.call() pour plus de détails (MuseGlimmerProcessor utilise MuseGlimmerImageProcessor pour le traitement des images). - grid_thw (
torch.LongTensorde 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 ou tuple(torch.FloatTensor)
Un BaseModelOutputWithPooling ou un tuple de
torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (MuseGlimmerConfig) et des entrées.
La méthode forward du modèle MuseGlimmerVisionModel 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
Moduleplutô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.FloatTensorde 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.FloatTensorde 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 à travers 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.FloatTensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.FloatTensor(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.FloatTensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
MuseGlimmerModel
classe transformers.MuseGlimmerModel
< source >( config: MuseGlimmerConfig )
Paramètres
- config (MuseGlimmerConfig) — 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() pour charger les poids du modèle.
Le modèle Muse Glimmer brut, produisant des états cachés bruts sans aucune tête spécifique au sommet.
Ce modèle hérite de 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, la taille des têtes, etc.)
Ce modèle est également une sous-classe de 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
< 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.FloatTensor] = Noneuse_cache: bool | None = Nonepixel_values: typing.Optional[torch.Tensor] = Noneimage_grid_thw: typing.Optional[torch.LongTensor] = Nonepixel_values_videos: typing.Optional[torch.Tensor] = Nonevideo_grid_thw: typing.Optional[torch.LongTensor] = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MuseGlimmerModelOutputWithPast or tuple(torch.FloatTensor)
Paramètres
- input_ids (
torch.LongTensorde 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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- attention_mask (
torch.Tensorde 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 masqués.
- position_ids (
torch.LongTensorde 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]. - past_key_values (
~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'est transmis, DynamicCache sera initialisé par défaut.Le modèle produira le même format de cache qui est fourni en entrée.
Si
past_key_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme(batch_size, unprocessed_length)au lieu de tous lesinput_idsde forme(batch_size, sequence_length). - inputs_embeds (
torch.FloatTensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_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 indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - use_cache (
bool, facultatif) — Si défini surTrue, les états clé-valeurpast_key_valuessont renvoyés et peuvent être utilisés pour accélérer le décodage (voirpast_key_values). - pixel_values (
torch.Tensorde 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. Voir MuseGlimmerImageProcessor.call() pour plus de détails (MuseGlimmerProcessor utilise MuseGlimmerImageProcessor pour le traitement des images). - image_grid_thw (
torch.LongTensorde 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.Tensorde 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 pour les vidéos peuvent être obtenues à l’aide de MuseGlimmerVideoProcessor. Voir MuseGlimmerVideoProcessor.call() pour plus de détails (MuseGlimmerProcessor utilise MuseGlimmerVideoProcessor pour le traitement des vidéos). - video_grid_thw (
torch.LongTensorde 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. - 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_outputde forme(batch_size, sequence_length, hidden_size), facultatif) est une séquence de fonctions multimodales de l'encodeur fusionnées dans les embeddings de texte.
Retourne
MuseGlimmerModelOutputWithPast ou tuple(torch.FloatTensor)
Un MuseGlimmerModelOutputWithPast ou un tuple de
torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (MuseGlimmerConfig) et des entrées.
La méthode forward du modèle MuseGlimmerModel 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
Moduleplutô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.FloatTensorde 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_valuesest 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é lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Il s’agit d’une instance de Cache. Pour plus de détails, consultez notre guide sur le cache kv.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éepast_key_values) pour accélérer le décodage séquentiel.hidden_states (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.FloatTensor(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.FloatTensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
image_hidden_states (
torch.FloatTensor, facultatif) — Untorch.FloatTensorde 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.
MuseGlimmerForConditionalGeneration
classe transformers.MuseGlimmerForConditionalGeneration
< source >( config: MuseGlimmerConfig )
Paramètres
- config (MuseGlimmerConfig) — 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() pour charger les poids du modèle.
Le modèle Muse Glimmer 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. 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, la taille des têtes, etc.)
Ce modèle est également une sous-classe de 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
< source >( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.FloatTensor] = Noneimage_grid_thw: typing.Optional[torch.LongTensor] = Nonepixel_values_videos: typing.Optional[torch.FloatTensor] = Nonevideo_grid_thw: 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.FloatTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MuseGlimmerCausalLMOutputWithPast or tuple(torch.FloatTensor)
Paramètres
- input_ids (
torch.LongTensorde 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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- pixel_values (
torch.FloatTensorde 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. Voir MuseGlimmerImageProcessor.call() pour plus de détails (MuseGlimmerProcessor utilise MuseGlimmerImageProcessor pour le traitement des images). - image_grid_thw (
torch.LongTensorde 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.FloatTensorde 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 pour les vidéos peuvent être obtenues à l’aide de MuseGlimmerVideoProcessor. Voir MuseGlimmerVideoProcessor.call() pour plus de détails (MuseGlimmerProcessor utilise MuseGlimmerVideoProcessor pour le traitement des vidéos). - video_grid_thw (
torch.LongTensorde 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. - attention_mask (
torch.Tensorde 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 masqués.
- position_ids (
torch.LongTensorde 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]. - past_key_values (
~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'est transmis, DynamicCache sera initialisé par défaut.Le modèle produira le même format de cache qui est fourni en entrée.
Si
past_key_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme(batch_size, unprocessed_length)au lieu de tous lesinput_idsde forme(batch_size, sequence_length). - inputs_embeds (
torch.FloatTensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_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 indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - labels (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être dans[0, ..., config.vocab_size]ou -100 (voir la docstring deinput_ids). Les jetons dont l'indice est défini sur-100sont ignorés (masqués), la perte n'est calculée que pour les jetons dont l'étiquette est dans[0, ..., config.vocab_size]. - use_cache (
bool, facultatif) — Si défini surTrue, les états clé-valeurpast_key_valuessont renvoyés et peuvent être utilisés pour accélérer le décodage (voirpast_key_values). - logits_to_keep (
Union[int, torch.Tensor], facultatif, valeur par défaut0) — Si c'est unint, calcule les logits pour leslogits_to_keepderniers jetons. Si0, calcule les logits pour tous lesinput_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 économiser de la mémoire, ce qui devient assez significatif pour les séquences longues ou les tailles de vocabulaire importantes. Si c'est untorch.Tensor, il doit être 1D et correspondre aux indices à conserver dans la dimension de la longueur de la séquence. Cela 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_outputde forme(batch_size, sequence_length, hidden_size), facultatif) est une séquence de fonctions multimodales de l'encodeur fusionnées dans les embeddings de texte.
Retourne
MuseGlimmerCausalLMOutputWithPast ou tuple(torch.FloatTensor)
Un MuseGlimmerCausalLMOutputWithPast ou un tuple de
torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (MuseGlimmerConfig) et des entrées.
La méthode forward de MuseGlimmerForConditionalGeneration 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
Moduleplutô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.FloatTensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de modélisation du langage (pour la prédiction du jeton suivant).logits (
torch.FloatTensorde 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é lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Il s’agit d’une instance de Cache. Pour plus de détails, consultez notre guide sur le cache kv.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.FloatTensor], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.FloatTensor(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.FloatTensor], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
image_hidden_states (
torch.FloatTensor, facultatif) — Untorch.FloatTensorde 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.
Exemple :
>>> from transformers import AutoProcessor, MuseGlimmerForConditionalGeneration
>>> model = MuseGlimmerForConditionalGeneration.from_pretrained("moonshotai/Kimi-K2.6")
>>> processor = AutoProcessor.from_pretrained("moonshotai/Kimi-K2.6")
>>> messages = [
{
"role": "user",
"content": [
{
"type": "image",
"image": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg",
},
{"type": "text", "text": "Describe the image."},
],
}
]
>>> inputs = processor.apply_chat_template(
messages,
tokenize=True,
add_generation_prompt=True,
return_dict=True,
return_tensors="pt",
)
>>> # Generate
>>> generated_ids = model.generate(**inputs, max_new_tokens=1024)
>>> generated_ids_trimmed = [out_ids[len(in_ids) :] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
>>> output_text = processor.batch_decode(generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
>>> print(output_text)