Zj SSKJr SSKrSSKrSSKJr SSKJr SSKJ r SSK J r SSK J r JrJrJr SSKrSSKrSS KJrJrJr SS KJr \ "S 5R55S - r/S QrSSSSSSSS.rSS1rSS1r/SQr Sr!SSSSS S!S"S#S$S%S&. r"\RF"S'5r$\RF"S(5r%\RF"S)5r&\RF"S*5r'\RF"S+\RP5r)\RF"S,5r*\RF"S-5r+\RF"S.\RP\RX-5r-\RF"S/5r.\RF"S05r/\RF"S15r0Sq1"S2S35r2"S4S55r3"S6S75r4"S8S95r5"S:S;5r6"S<S=5r7"S>S?5r81S@kr9SASBSC.r:SDr;SkSEjrSHr?SlSIjr@SmSJjrASKrBSnSLjrCSoSMjrDSpSNjrESqSOjrF\"SPSQ9SrSRj5rGSSrHSsSTjrISUrJSVrKStSuSWjjrLSXrMSYrNStSZjrOS[rPS\rQS]rR\S"1S^k5rTSqUSvS_jrVS`rWSarXSbrYScrZSwSdjr[Ser\Sfr]SxSgjr^SyShjr_StSSSSi.Sjjjr`g)z) annotationsN)Mapping) lru_cache)Path) UnionType)ClassVarUnionget_args get_origin)MODELS_TO_PIPELINE#PIPELINE_TASKS_TO_SAMPLE_DOCSTRINGSPT_SAMPLE_DOCSTRINGS) ModelOutputsrc transformers)zconfiguration_*.pyz modeling_*.pyztokenization_*.pyzprocessing_*.pyzimage_processing_pil_*.pyzimage_processing_*.pyzfeature_extractor_*.py)image_processing_autoIMAGE_PROCESSOR_MAPPING_NAMES)tokenization_autoTOKENIZER_MAPPING_NAMES)video_processing_autoVIDEO_PROCESSOR_MAPPING_NAMES)feature_extraction_autoFEATURE_EXTRACTOR_MAPPING_NAMES)processing_autoPROCESSOR_MAPPING_NAMES)configuration_autoCONFIG_MAPPING_NAMES) modeling_autoMODEL_MAPPING_NAMES)image_processor_classtokenizer_classvideo_processor_classfeature_extractor_classprocessor_class config_class model_class preprocess__call__BaseImageProcessorProcessorMixin) TextKwargs ImagesKwargs VideosKwargs AudioKwargsz , *kwargs*OpenAIGPTConfig XCLIPConfig Kosmos2ConfigKosmos2_5ConfigDonutSwinConfig EsmConfigParakeetCTCConfigOpenAIPrivacyFilterConfig LasrCTCConfigWav2Vec2Config) openaizx-clipkosmos2z kosmos2-5donutesmfoldparakeetzprivacy-filterlasrzwav2vec2-with-lmz*\[(.+?)\]\((https://huggingface\.co/.+?)\)z#(?m)^([ \t]*)(?=Example|Return|```)z(?m)^([ \t]*)(?=Return)z(?m)^([ \t]*)(?=Example|```)z(?:Args:)(\n.*)?(\n)?$z(of shape\s*(?:`.*?`|\(.*?\)))z(defaults to \s*[^)]*)zQ^\s{0,0}(\w+)\s*\(\s*([^, \)]*)(\s*.*?)\s*\)\s*:\s*((?:(?!\n^\s{0,0}\w+\s*\().)*)zForwardRef\('([\w.]+)'\)zOptional\[(.*?)\]z{(.*?)}c\rSrSrSSS.rSSS.rSSS.rSSS.rSSS.rS SS.r S SS.r S SS.r S SS.r S SS.r SSS.rSSS.rSSS.rSSS.rSSS.rSSS.rSSS.rSSS.rSSS.rSSS.rSSS.rSSS.rSSS.rSSS.rSrg)ImageProcessorArgsiz Image to preprocess. Expects a single or batch of images with pixel values ranging from 0 to 255. If passing in images with pixel values between 0 and 1, set `do_rescale=False`. N descriptionshapez Video to preprocess. Expects a single or batch of videos with pixel values ranging from 0 to 255. If passing in videos with pixel values between 0 and 1, set `do_rescale=False`. z& Whether to resize the image. z> Describes the maximum input dimensions to the model. zR The size by which to make sure both the height and width can be divided. zP Whether to default to a square image when resizing, if size is an int. z Resampling filter to use if resizing the image. This can be one of the enum `PILImageResampling`. Only has an effect if `do_resize` is set to `True`. z+ Whether to center crop the image. z@ Size of the output image after applying `center_crop`. z Whether to pad the image. Padding is done either to the largest size in the batch or to a fixed square size per image. The exact padding strategy depends on the model. a The size in `{"height": int, "width" int}` to pad the images to. Must be larger than any image size provided for preprocessing. If `pad_size` is not provided, images will be padded to the largest height and width in the batch. Applied only when `do_pad=True.` z' Whether to rescale the image. zR Rescale factor to rescale the image by if `do_rescale` is set to `True`. z) Whether to normalize the image. ze Image mean to use for normalization. Only has an effect if `do_normalize` is set to `True`. zw Image standard deviation to use for normalization. Only has an effect if `do_normalize` is set to `True`. z. Whether to convert the image to RGB. zX Returns stacked tensors if set to `'pt'`, otherwise returns a list of tensors. zc Only `ChannelDimension.FIRST` is supported. Added for compatibility with slow processors. a The channel dimension format for the input image. If unset, the channel dimension format is inferred from the input image. Can be one of: - `"channels_first"` or `ChannelDimension.FIRST`: image in (num_channels, height, width) format. - `"channels_last"` or `ChannelDimension.LAST`: image in (height, width, num_channels) format. - `"none"` or `ChannelDimension.NONE`: image in (height, width) format. zf The device to process the images on. If unset, the device is inferred from the input images. a5 Whether to disable grouping of images by size to process them individually and not in batches. If None, will be set to True if the images are on CPU, and False otherwise. This choice is based on empirical observations, as detailed here: https://github.com/huggingface/transformers/pull/38157 z The number of image tokens to be used for each image in the input. Added for backward compatibility but this should be set as a processor attribute in future models. z Additional image preprocessing options. Model-specific kwargs are listed above; see the TypedDict class for the complete list of supported arguments. )__name__ __module__ __qualname____firstlineno__imagesvideos do_resizesize size_divisordefault_to_squareresampledo_center_crop crop_sizedo_padpad_size do_rescalerescale_factor do_normalize image_mean image_stddo_convert_rgbreturn_tensors data_formatinput_data_formatdevicedisable_groupingimage_seq_length __kwargs____static_attributes__rFr/root/GenerationalWealth/GenerationalWealth/venv/lib/python3.13/site-packages/transformers/utils/auto_docstring.pyrArAis F F I  D L  H N I F  H J N L J I N N K  F    JrdrAc:\rSrSrSSS.rSSS.rSSS.rS S S.rS S S.rS SS.r SS0r SS0r SS0r SSS.r SSS.rSSS.rSSS.rSSS.rSSS.rSSS.rSSS.rS SS.rS!SS.rS"SS.rS#SS.rS$SS.rS%SS.rS&S'S.rS(S)S.rS(S)S.rS*SS.rS+S,S.rS-S.S.r S/SS.r!S0r"g)1 ProcessorArgsi#z2 The image processor is a required input. z{image_processor_class})rDtypez, The tokenizer is a required input. z{tokenizer_class}z2 The video processor is a required input. z{video_processor_class}z2 The audio processor is a required input. z{audio_processor_class}z4 The feature extractor is a required input. z{feature_extractor_class}z\ A Jinja template to convert lists of messages in a chat into a tokenizable string. strrDz The sequence or batch of sequences to be encoded. Each sequence can be a string or a list of strings (pretokenized string). If you pass a pretokenized input, set `is_split_into_words=True` to avoid ambiguity with batched inputs. a  The audio or batch of audios to be prepared. Each audio can be a NumPy array or PyTorch tensor. In case of a NumPy array/PyTorch tensor, each audio should be of shape (C, T), where C is a number of channels, and T is the sample length of the audio. z If set, will return tensors of a particular framework. Acceptable values are: - `'pt'`: Return PyTorch `torch.Tensor` objects. - `'np'`: Return NumPy `np.ndarray` objects. NrCaG Whether or not to add special tokens when encoding the sequences. This will use the underlying [`PretrainedTokenizerBase.build_inputs_with_special_tokens`] function, which defines which tokens are automatically added to the input ids. This is useful if you want to add `bos` or `eos` tokens automatically. boola Activates and controls padding. Accepts the following values: - `True` or `'longest'`: Pad to the longest sequence in the batch (or no padding if only a single sequence is provided). - `'max_length'`: Pad to a maximum length specified with the argument `max_length` or to the maximum acceptable input length for the model if that argument is not provided. - `False` or `'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of different lengths). z'bool, str or [`~utils.PaddingStrategy`]a Activates and controls truncation. Accepts the following values: - `True` or `'longest_first'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum acceptable input length for the model if that argument is not provided. This will truncate token by token, removing a token from the longest sequence in the pair if a pair of sequences (or a batch of pairs) is provided. - `'only_first'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum acceptable input length for the model if that argument is not provided. This will only truncate the first sequence of a pair if a pair of sequences (or a batch of pairs) is provided. - `'only_second'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum acceptable input length for the model if that argument is not provided. This will only truncate the second sequence of a pair if a pair of sequences (or a batch of pairs) is provided. - `False` or `'do_not_truncate'` (default): No truncation (i.e., can output batch with sequence lengths greater than the model maximum admissible input size). z= 7.5` (Volta). z Whether to return token type IDs. If left to the default, will return the token type IDs according to the specific tokenizer's default, defined by the `return_outputs` attribute. [What are token type IDs?](../glossary#token-type-ids) a Whether to return the attention mask. If left to the default, will return the attention mask according to the specific tokenizer's default, defined by the `return_outputs` attribute. [What are attention masks?](../glossary#attention-mask) z Whether or not to return overflowing token sequences. If a pair of sequences of input ids (or a batch of pairs) is provided with `truncation_strategy = longest_first` or `True`, an error is raised instead of returning overflowing tokens. zC Whether or not to return special tokens mask information. z Whether or not to return `(char_start, char_end)` for each token. This is only available on fast tokenizers inheriting from [`PreTrainedTokenizerFast`], if using Python's tokenizer, this method will raise `NotImplementedError`. zE Whether or not to return the lengths of the encoded inputs. z@ Whether or not to print more information and warnings. z Optional second sequence to be encoded. This can be a string, a list of strings (tokenized string using the `tokenize` method) or a list of integers (tokenized string ids using the `convert_tokens_to_ids` method). zstr, list[str] or list[int]a The sequence or batch of sequences to be encoded as target texts. Each sequence can be a string or a list of strings (pretokenized string). If you pass pretokenized input, set `is_split_into_words=True` to avoid ambiguity with batched inputs. z!str, list[str] or list[list[str]]a! Whether or not the input is already pre-tokenized (e.g., split into words). If set to `True`, the tokenizer assumes the input is already split into words (for instance, by splitting it on whitespace) which it will tokenize. This is useful for NER or token classification. zd Word-level bounding boxes. Each bounding box should be normalized to be on a 0-1000 scale. z(list[list[int]] or list[list[list[int]]]zY Word-level integer labels (for token classification tasks such as FUNSD, CORD). zlist[int] or list[list[int]]z Additional processing options for each modality (text, images, videos, audio). Model-specific parameters are listed above; see the TypedDict class for the complete list of supported arguments. rF)#rGrHrIrJimage_processor tokenizervideo_processoraudio_processorfeature_extractor chat_templatetextaudioaudiosr\add_special_tokenspadding truncation max_lengthstridepad_to_multiple_ofreturn_token_type_idsreturn_attention_maskreturn_overflowing_tokensreturn_special_tokens_maskreturn_offsets_mapping return_lengthverbose text_pair text_targettext_pair_targetis_split_into_wordsboxes word_labelsrbrcrFrdrergrg#s * O$ I* O* O,  M  D  E F N  : G O#J* J F      ! "  M G . I 4 K 4   ;  E/ K Jrdrgc\rSrSrSS0rSS0rSS0rSS0rSS0rSS0r SS 0r SS 0r SS 0r SS 0r SS 0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0r SS 0r!SS!0r"SS"0r#SS#0r$SS$0r%SS%0r&SS&0r'SS'0r(SS(0r)SS)0r*SS0r+SS*0r,SS+0r-SS,0r.SS-0r/SS.0r0SS/0r1SS00r2SS10r3SS20r4SS30r5SS40r6SS50r7SS60r8SS70r9SS80r:SS90r;SS:0rSS=0r?SS>0r@SS?0rASS@0rBSSA0rCSSB0rDSSC0rESSD0rFSSE0rGSSF0rHSSG0rISSH0rJSSI0rKSSJ0rLSSK0rMSSL0rNSSM0rOSSN0rPSSO0rQSSP0rRSSQ0rSSSR0rTSSS0rUSST0rVSSU0rWSSV0rXSSW0rYSSX0rZSSY0r[SSZ0r\SS[0r]SS\0r^SS]0r_SSZ0r`SS^0raSS_0rbSS`0rcSSa0rdSSb0reSSc0rfSSd0rgSSe0rhSSf0riSSg0rjSSh0rkSSi0rlSSj0rmSSk0rnSSl0roSSm0rpSSn0rqSSo0rrSSp0rsSSq0rtSSr0ruSSs0rvSSq0rwSSt0rxSSu0rySSv0rzSSr0r{SSw0r|SSx0r}SSy0r~SSs0rSSz0rSS{0rSS|0rSS}0rSS~0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0rSS0r\r\r\r\Yr\Yr\Yr\Yr\Yr\1r\r\r\r\&r\`r\`r\ar\ar\ar\\r\\r\'r\'r\r\r\r\r\r\?r\r\ r\+r\*r\+r\+r\*r\*r\%r\$r\$r\%r\ r\ r\ r\ r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\ r\r\ r\r\r\r\r\GGr\HGr\IGr\JGr\_Gr\_Gr\DGr\(Gr\Gr\(Gr \(Gr \(Gr \qGr \qGr \^Gr\Gr\ Gr\ Gr\ Gr\ Gr\GrG\Gr\Gr\Gr\Gr\Gr\Gr\Gr\Gr\TGrG\GrG\GrG\Gr \iGr!\iGr"\7Gr#\[Gr$\ Gr%SGr&g) ConfigArgsi4rDzC Whether or not the model should return all hidden-states. a] The `dtype` of the weights. This attribute can be used to initialize the model to a non-default `dtype` (which is normally `float32`) and thus allow for optimal storage allocation. For example, if the saved model is `float16`, ideally we want to load it back using the minimal amount of memory needed to load `float16` weights. a The chunk size of all feed forward layers in the residual attention blocks. A chunk size of `0` means that the feed forward layer is not chunked. A chunk size of n means that the feed forward layer processes `n` < sequence_length embeddings at a time. For more information on feed forward chunking, see [How does Feed Forward Chunking work?](../glossary.html#feed-forward-chunking). zU A map from index (for instance prediction index, or target index) to label. z2 A map from label to index for the model. z Problem type for `XxxForSequenceClassification` models. Can be one of `"regression"`, `"single_label_classification"` or `"multi_label_classification"`. z. The class name of model's tokenizer. zz Vocabulary size of the model. Defines the number of different tokens that can be represented by the `input_ids`. z2 Dimension of the hidden representations. z/ Dimension of the MLP representations. zf The attention head dimension. If None, it will default to hidden_size // num_attention_heads z= Number of hidden layers in the Transformer decoder. zX Number of attention heads for each attention layer in the Transformer decoder. a| This is the number of key_value heads that should be used to implement Grouped Query Attention. If `num_key_value_heads=num_attention_heads`, the model will use Multi Head Attention (MHA), if `num_key_value_heads=1` the model will use Multi Query Attention (MQA) otherwise GQA is used. When converting a multi-head checkpoint to a GQA checkpoint, each group key and value head should be constructed by meanpooling all the original heads within that group. For more details, check out [this paper](https://huggingface.co/papers/2305.13245). If it is not specified, will default to `num_attention_heads`. z The non-linear activation function (function or string) in the decoder. For example, `"gelu"`, `"relu"`, `"silu"`, etc. zN The maximum sequence length that this model might ever be used with. zj The standard deviation of the truncated_normal_initializer for initializing all weight matrices. z; The epsilon used by the rms normalization layers. z Whether or not the model should return the last key/values attentions (not used by all models). Only relevant if `config.is_decoder=True` or when the model is a decoder-only generative model. a Dictionary containing the configuration parameters for the RoPE embeddings. The dictionary should contain a value for `rope_theta` and optionally parameters used for scaling in case you want to use RoPE with longer `max_position_embeddings`. zl Whether to use a bias in the query, key, value and output projection layers during self-attention. z] Whether to use a bias in up_proj, down_proj and gate_proj layers in the MLP layers. z< The dropout ratio for the attention probabilities. a Experimental feature. Tensor parallelism rank used during pretraining. Please refer to [this document](https://huggingface.co/docs/transformers/main/perf_train_gpu_many#tensor-parallelism) to understand more about it. This value is necessary to ensure exact reproducibility of the pretraining results. Please refer to [this issue](https://github.com/pytorch/pytorch/issues/76232). z6 Token id used for padding in the vocabulary. z< Token id used for end-of-stream in the vocabulary. zB Token id used for beginning-of-stream in the vocabulary. z8 Token id used for separator in the vocabulary. z2 Token id used for CLS in the vocabulary. z\ Whether to tie weight embeddings according to model's `tied_weights_keys` mapping. z: Size of the encoder layers and the pooler layer. z Size of the key, query, value projections per attention head. The `inner_dim` of the projection layer will be defined as `num_heads * d_kv`. zq Number of hidden layers in the Transformer decoder. Will use the same value as `num_layers` if not set. zq Number of hidden layers in the Transformer encoder. Will use the same value as `num_layers` if not set. z+ The ratio for all dropout layers. z+ The dropout ratio for classifier. z= The epsilon used by the layer normalization layers. z~ A factor for initializing all weight matrices (should be kept to 1, used internally for initialization testing). zX Number of attention heads for each attention layer in the Transformer encoder. z[ Dimensionality of the "intermediate" (often named feed-forward) layer in decoder. z[ Dimensionality of the "intermediate" (often named feed-forward) layer in encoder. zM The dropout ratio for activations inside the fully connected layer. z The LayerDrop probability for the encoder. See the [LayerDrop paper](see https://huggingface.co/papers/1909.11556) for more details. z The LayerDrop probability for the decoder. See the [LayerDrop paper](see https://huggingface.co/papers/1909.11556) for more details. zC Whether to scale embeddings by dividing by sqrt(d_model). z The id of the token to force as the last generated token when `max_length` is reached. Usually set to `eos_token_id`. z6 Intermediate size of the routed expert MLPs. z2 Number of routed experts in MoE layers. zi Number of experts to route each token to. This is the top-k value for the token-choice routing. zL Number of shared experts that are always activated for all tokens. z A list that explicitly maps each layer index with its layer type. If not provided, it will be automatically generated based on config values. zB Whether to normalize the weights of the routed experts. z Number of selected groups for each token (for each token, ensuring the selected experts is only within `topk_group` groups). zO Dimension of the query/key heads that use rotary position embeddings. z' Dimension of the value heads. zU Dimension of the query/key heads that don't use rotary position embeddings. zB Rank of the LoRA matrices for key and value projections. z: Rank of the LoRA matrices for query projections. z+ Scaling factor or routed experts. z# Number of routed experts. z# Number of shared experts. zA The config object or dictionary of the vision backbone. z? The config object or dictionary of the text backbone. zC The activation function used by the multimodal projector. zd The feature selection strategy used to select the vision feature from the vision backbone. The index of the layer to select the vision feature. If multiple indices are provided, the vision feature of the corresponding indices will be concatenated to form the vision features. z: Whether to use bias in the multimodal projector. zG The image token index used as a placeholder for input images. zG The video token index used as a placeholder for input videos. zF The audio token index used as a placeholder for input audio. z1 Sequence length of one image embedding. z1 Sequence length of one video embedding. zF Whether cross-attention layers should be added to the model. ze Whether the model is used as a decoder or not. If `False`, the model is used as an encoder. zX Sliding window attention window size. If `None`, no sliding window is applied. z2 Whether to use sliding window attention. z6 Intermediate size of the shared expert MLPs. zv The frequency of adding a sparse MoE layer. The default is 1, which means all decoder layers are sparse MoE. z Whether or not the router logits should be returned by the model. Enabling this will also allow the model to output the auxiliary loss, including load balancing loss and router z-loss. zj Auxiliary load balancing loss coefficient. Used to penalize uneven expert routing in MoE models. z Indices of the intermediate hidden states (feature maps) to return from the backbone. Each index corresponds to one stage of the model. z Names of the intermediate hidden states (feature maps) to return from the backbone. One of `"stem"`, `"stage1"`, `"stage2"`, etc. z. The size (resolution) of each image. z. The size (resolution) of each patch. z' The number of input channels. z Number of mel features used per input frame. Should correspond to the value used in the `AutoFeatureExtractor` class. zc The sampling rate at which the audio files should be digitalized expressed in hertz (Hz). zh The dropout probability for all fully connected layers in the embeddings, encoder, and pooler. z; Ratio of the MLP hidden dim to the embedding dim. z@ Whether to add a bias to the queries, keys and values. z= Dimensionality of the embeddings and hidden states. z/ The dropout ratio for the embeddings. zc If not `None`, cap the absolute value of the query, key, and value tensors to this value. z6 The vocabulary size of the `token_type_ids`. z@ The config object or dictionary of the audio backbone. z The LayerDrop probability. See the [LayerDrop paper](see https://huggingface.co/papers/1909.11556) for more details. z The number of tokens that each expert can process. If `None`, `expert_capacity` will be set to `(sequence_length / num_experts) * capacity_factor`. zn If an encoder-decoder model starts decoding with a different token than `bos`, the id of that token. zA Whether the model is used as an encoder/decoder or not. z= The number of parallel codebooks used by the model. z; Dimensionality of each codebook embedding vector. zB Dimensionality (hidden size) at each stage of the model. z1 Depth of each layer in the Transformer. z0 Patch size at each stage of the model. z, Stride at each stage of the model. z` Amount of noise to add to the router logits during training for better load balancing. zk Number of local experts on each device. `num_experts` should be divisible by `num_local_experts`. zB Whether to use query-key normalization in the attention. z2 The configuration of the backbone model. z] Relative classification weight of the no-object class in the object detection loss. zU Relative weight of the classification error in the Hungarian matching cost. zN Relative weight of the focal loss in the panoptic segmentation loss. zM Relative weight of the dice loss in the panoptic segmentation loss. zV Relative weight of the L1 bounding box error in the Hungarian matching cost. zU Relative weight of the generalized IoU loss in the Hungarian matching cost. z, Alpha parameter in the focal loss. zX Relative weight of the generalized IoU loss in the panoptic segmentation loss. zX Relative weight of the L1 bounding box loss in the panoptic segmentation loss. zW Relative weight of the classification loss in the panoptic segmentation loss. z\ The index that is ignored by the loss function of the semantic segmentation model. z> Dimensionality of text and vision projection layers. z; The initial value of the *logit_scale* parameter. z Number of initial dense layers before MoE layers begin. Layers with index < num_dense_layers will use standard dense MLPs instead of MoE. z. Drop path rate for the patch fusion. z; Configuration dict of the vector quantize module. z( Number of codebook embeddings. z+ Whether to use double z channels. z2 Number of channels for the latent space. z4 Configuration dict of the Q-Former module. z/ The size of the convolutional kernel. zX The ratio between the spatial resolution of the input and output feature maps. z Shrinks or expands the number of channels in each layer. This is sometimes also called "alpha" or "width multiplier". z6 Whether to use absolute position embeddings. zM Whether to use relative position bias in the self-attention layers. zp Scale to use in the self-attention layers. 0.1 for base, 1e-6 for large. Set 0 to disable layer scale. zJ The config object or dictionary of the vision-language backbone. z_ The scaling factor used for the Xavier initialization of the cross-attention weights. zZ Whether auxiliary decoding losses (losses at each decoder layer) are to be used. zB The config object or dictionary of the encoder backbone. zB The config object or dictionary of the decoder backbone. zr Scaling factor applied to the word embeddings. Used to scale the embeddings relative to the hidden size. zd Scaling factor applied to the output logits before computing the probability distribution. z= Scaling factor applied to the residual connections. z: Scaling factor applied to the attention weights. z> The activation function for the classification head. zQ Whether to return a `ModelOutput` (dataclass) instead of a plain tuple. zo Coefficient for the router z-loss, which penalizes large router logits to improve training stability. z Soft-capping value applied to the final logits before computing the probability distribution. Logits are scaled by `tanh(logit / cap) * cap`. z Hidden size of the encoder outputs projected into the cross-attention key/value space of the decoder. Used when the encoder and decoder have different hidden sizes. zb Dimensionality of the input acoustic features (e.g., number of mel-filterbank channels). z\ Whether to calculate loss using intermediate predictions from transformer decoder. z= The epsilon used by the batch normalization layers. z The number of layers using full attention. The first `max_window_layers` layers will use full attention, while any additional layer afterwards will use SWA (Sliding Window Attention). zl Specifies the reduction to apply to the output of `torch.nn.CTCLoss`. Only relevant when training. a2 Percentage (between 0 and 1) of all feature vectors along the feature axis which will be masked. The masking procedure generates `mask_feature_prob*len(feature_axis)/mask_time_length` independent masks over the axis. If reasoning from the probability of each feature vector to be chosen as the start of the vector span to be masked, *mask_feature_prob* should be `prob_vector_start*mask_feature_length`. Note that overlap may decrease the actual percentage of masked vectors. This is only relevant if `apply_spec_augment` is `True`. z_ Relative classification weight of the 'no-object' class in the object detection loss. zl Number of labels to use in the last layer added to the model, typically for a classification task. z= Number of Transformer layers in the vision encoder. zN Temporal patch size used in the 3D patch embedding for video inputs. z} The size of the spatial merge window used to reduce the number of visual tokens by merging neighboring patches. z] Token ID that marks the start of a visual segment in the multimodal input sequence. z[ Token ID that marks the end of a visual segment in the multimodal input sequence. zB The number of mamba heads used in the v2 implementation. z' Head embedding dimension size zG The number of the mamba groups used in the v2 implementation. z2 The size of the mamba convolution kernel zb Expanding factor (relative to hidden_size) used to determine the mamba intermediate size zO The chunks in which to break the sequence when doing prefill/training zg Flag indicating whether or not to use bias in the convolution layer of the mamba mixer block. z Flag indicating whether or not to use bias in the input and output projections (["in_proj", "out_proj"]) of the mamba mixer block z; Minimum `time_step` used to bound `dt_proj.bias`. z; Maximum `time_step` used to bound `dt_proj.bias`. z: Accepted range of time step values for clamping. zE Expand ratio to set the output dimensions for the expansion zM Size of the SSM state (latent state dimension) in the Mamba layers. z\ Rank of the delta (time step) projection. Can be `"auto"` to set it automatically. z[ Minimum allowed value for the discrete time step delta after softplus activation. zE Scale applied to the time step delta before discretization. zZ Initialization scheme for the time step delta. Can be `"random"` or `"uniform"`. zZ Inner state size of the SSM (state-space model) in the Mamba layers of FalconH1. zX Whether to apply normalization before the gating mechanism in the Mamba mixer. zb Whether to use RMS normalization in the Mamba layers (as opposed to standard LayerNorm). rFN('rGrHrIrJoutput_hidden_stateschunk_size_feed_forwarddtypeid2labellabel2id problem_typer" vocab_size hidden_sizeintermediate_sizehead_dimnum_hidden_layersnum_attention_headsnum_key_value_heads hidden_actmax_position_embeddingsinitializer_range rms_norm_eps use_cacherope_parametersattention_biasmlp_biasattention_dropoutpretraining_tp pad_token_id eos_token_id bos_token_id sep_token_id cls_token_idtie_word_embeddingsd_modeld_kvnum_decoder_layersnum_encoder_layers dropout_rateclassifier_dropoutlayer_norm_epsinitializer_factorencoder_attention_headsdecoder_attention_headsdecoder_ffn_dimencoder_ffn_dimactivation_dropoutencoder_layerdropdecoder_layerdropscale_embeddingforced_eos_token_idmoe_intermediate_size num_expertsnum_experts_per_toknum_shared_experts layer_typesnorm_topk_prob topk_groupqk_rope_head_dim v_head_dimqk_nope_head_dim kv_lora_rank q_lora_rankrouted_scaling_factorn_routed_expertsn_shared_experts vision_config text_configprojector_hidden_actvision_feature_select_strategyvision_feature_layermultimodal_projector_biasimage_token_idvideo_token_idaudio_token_idravideo_seq_lengthadd_cross_attention is_decodersliding_windowuse_sliding_windowshared_expert_intermediate_sizedecoder_sparse_stepoutput_router_logitsrouter_aux_loss_coef out_indices out_features image_size patch_size num_channels num_mel_bins sampling_ratehidden_dropout mlp_ratioqkv_biasn_embd resid_pdrop embd_pdropclip_qkvtype_vocab_size audio_config layerdropexpert_capacitydecoder_start_token_idis_encoder_decoder num_codebooks codebook_dim hidden_sizesdepths patch_sizesstridesrouter_jitter_noisenum_local_experts qk_layernormbackbone_configno_object_weight class_weight mask_weight dice_weight class_cost bbox_cost giou_cost focal_alphamask_loss_coefficientgiou_loss_coefficientbbox_loss_coefficientcls_loss_coefficientdice_loss_coefficientsemantic_loss_ignore_indexprojection_dimlogit_scale_init_valuenum_dense_layersdrop_path_rate vq_confignum_embeddings double_latentlatent_channelsqformer_configconv_kernel_size output_stridedepth_multiplier use_absolute_position_embeddingsuse_relative_position_biaslayer_scale_init_value vlm_configinit_xavier_stdauxiliary_lossencoder_configdecoder_configembedding_multiplierlogits_scalingresidual_multiplierattention_multiplierclassifier_activation return_dictrouter_z_loss_coeffinal_logit_softcappingcross_attention_hidden_size input_dimuse_auxiliary_lossbatch_norm_epsmax_window_layersctc_loss_reductionmask_feature_probeos_coefficient num_labelsdepthtemporal_patch_sizespatial_merge_sizevision_start_token_idvision_end_token_id mamba_n_heads mamba_d_headmamba_n_groups mamba_d_conv mamba_expandmamba_chunk_sizemamba_conv_biasmamba_proj_bias time_step_min time_step_maxtime_step_limit expand_ratio state_sizetime_step_ranktime_step_floortime_step_scaletime_step_init_scheme mamba_d_ssmmamba_norm_before_gatemamba_rms_norm mamba_d_statemamba_num_headsmamba_head_dimnum_input_channelsaudio_channelsinput_channels in_channelsin_chansscale_attn_weightsattention_probs_dropout_prob attn_pdrop attn_dropoutdropout resid_dropoutresidual_dropout emb_pdrop embed_dropoutembedding_dropouthidden_dropout_probhidden_dropout_rateclassifier_dropout_probclassifier_dropout_rate dropout_prob dropout_pdecoder_attention_dropoutdecoder_dropoutencoder_dropout route_scaleactivation_function hidden_dimnum_decoder_attention_headsnum_encoder_attention_headsdecoder_num_headsdecoder_num_attention_headsencoder_num_headsencoder_num_attention_headsencoder_layersdecoder_layersdecoder_num_layersencoder_num_layersd_ffdim_ffn_innerdecoder_intermediate_size num_kv_heads num_layersn_layersn_layerlayersencoder_num_hidden_layersdecoder_num_hidden_layers num_headsn_headsn_headhidden_activation activationmlp_hidden_actd_headd_innerdim_headffn_dimattention_heads n_positionsinit_stdinitializer_stdprojector_biasimage_token_indexvideo_token_indexaudio_token_indexembedding_size embed_dimprojection_hidden_actlayer_norm_epsilonrms_normnorm_epseps norm_epsilon qk_layernorms use_qk_norm use_qkv_biasdecoder_hidden_actdecoder_hidden_dimdecoder_hidden_sizeencoder_hidden_dimencoder_hidden_sizelayer_scale_initial_scalemulti_modal_projector_biasprojector_hidden_sizeprojection_size kernel_size conv_kerneluse_absolute_embeddings use_abs_pos use_rel_pos aux_loss_coefembedding_dimension embedding_dimemb_dim n_codebooks codebook_sizelayers_block_type sample_ratetext_vocab_sizercrFrdrerr4s   E H H L O J K  H     J   L I O N H  N L L L L L  G  D   L  N    O O    O   K   K N J  J  L K    M K  &"  ! N N N    J N  '#    K L J J L L M N I H F K J H O L I O   M L L F K G   L O  L K K J I I K      " N   N I N M O N  M  ($ "  J O N N N  N    K   # I  N     O J  E     M L N L L  O O M M O L J N O O  K  N M#O!N%!N!NKH(#4 "J$LGM"IM"((00LI 1OO'K$J"9"9/"9/"9'N'N++ D FG 1&L"J HG F . .#I!G F"JN FGHG)O)K H'O.N&&&NI0'HH C!L MKL#$%$% 6!/*$O"K"K>2K,K(M#MGK!M#K Ordrcr\rSrSrSSS.rSSS.rSSS.rSSS.rS SS.rS S S.r S S S.r SSS.r SSS.r SSS.r SSS.rSSS.rSS S.rSS S.rSSS.rSSS.rSSS.rSSS.rSSS.rSSS.rSSS.rSSS.rSSS.rSS S.rS!S S.rS"SS.rS#SS.rS$SS.rS%S&S.r S'S(S.r!S)SS.r"S*SS.r#S+S,S.r$S-S.S.r%S/S0S.r&S1r'g)2 ModelArgsi.a7 Labels for computing the masked language modeling loss. Indices should either be in `[0, ..., config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`. (of shape `(batch_size, sequence_length)`rCaC Calculate logits for the last `num_logits_to_keep` tokens. If `0`, calculate logits for all `input_ids` (special case). Only last token logits are needed for generation, and calculating them only for that token can save memory, which becomes pretty significant for long sequences or large vocabulary size. Na" Indices of input sequence tokens in the vocabulary. Padding will be ignored by default. Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and [`PreTrainedTokenizer.__call__`] for details. [What are input IDs?](../glossary#input-ids) a Float values of input raw speech waveform. Values can be obtained by loading a `.flac` or `.wav` audio file into an array of type `list[float]`, a `numpy.ndarray` or a `torch.Tensor`, *e.g.* via the torchcodec library (`pip install torchcodec`) or the soundfile library (`pip install soundfile`). To prepare the array into `input_values`, the [`AutoProcessor`] should be used for padding and conversion into a tensor of type `torch.FloatTensor`. See [`{processor_class}.__call__`] for details. z Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`: - 1 for tokens that are **not masked**, - 0 for tokens that are **masked**. [What are attention masks?](../glossary#attention-mask) z Mask to avoid performing attention on certain token indices. By default, a causal mask will be used, to make sure the model can only look at previous inputs in order to predict the future. z/of shape `(batch_size, target_sequence_length)`z Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if the model is configured as a decoder. 5of shape `(batch_size, sequence_length, hidden_size)`a, Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used in the cross-attention if the model is configured as a decoder. Mask values selected in `[0, 1]`: - 1 for tokens that are **not masked**, - 0 for tokens that are **masked**. a  Segment token indices to indicate first and second portions of the inputs. Indices are selected in `[0, 1]`: - 0 corresponds to a *sentence A* token, - 1 corresponds to a *sentence B* token. [What are token type IDs?](../glossary#token-type-ids) z Indices of input sequence tokens matching each modality. For example text (0), image (1), video (2). Multimodal token type ids can be obtained using [`AutoProcessor`]. See [`ProcessorMixin.__call__`] for details. z Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0, config.n_positions - 1]`. [What are position IDs?](../glossary#position-ids) a Pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention blocks) that can be used to speed up sequential decoding. This typically consists in the `past_key_values` returned by the model at a previous stage of decoding, when `use_cache=True` or `config.use_cache=True`. Only [`~cache_utils.Cache`] instance is allowed as input, see our [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache). If no `past_key_values` are passed, [`~cache_utils.DynamicCache`] will be initialized by default. The model will output the same cache format that is fed as input. If `past_key_values` are used, the user is expected to input only unprocessed `input_ids` (those that don't have their past key value states given to this model) of shape `(batch_size, unprocessed_length)` instead of all `input_ids` of shape `(batch_size, sequence_length)`. a Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This is useful if you want more control over how to convert `input_ids` indices into associated vectors than the model's internal embedding lookup matrix. a Indices of decoder input sequence tokens in the vocabulary. Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and [`PreTrainedTokenizer.__call__`] for details. [What are decoder input IDs?](../glossary#decoder-input-ids) a( Optionally, instead of passing `decoder_input_ids` you can choose to directly pass an embedded representation. If `past_key_values` is used, optionally only the last `decoder_inputs_embeds` have to be input (see `past_key_values`). This is useful if you want more control over how to convert `decoder_input_ids` indices into associated vectors than the model's internal embedding lookup matrix. If `decoder_input_ids` and `decoder_inputs_embeds` are both unset, `decoder_inputs_embeds` takes the value of `inputs_embeds`. z