§
    Þ˜ºh Í  ã            !       óÜ  — d Z ddlZddlZddlZddlZddlZddlmZ d„ Zd„ Z	d„ Z
d„ ZdZd	Zd
„ Zd„ Zd^d„ZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZeeeeeeeeeeeeeedœZ dZ!dZ"eZ#eZ$d Z%d!Z&d"Z'd"Z(d"Z)d"Z*d"Z+d"Z,eZ-d"Z.d"Z/d"Z0d"Z1eZ2d"Z3d"Z4d"Z5eZ6d"Z7eZ8d"Z9eZ:eZ;eZ<d"Z=d#Z> ed$e!fd%e"fd&e<fd'e#fd(e;fd)e$fd*e>fd+e%fd,e0fd-e&fd.e'fd/e=fd0e2fd1e(fd2e5fd3e3fd4e)fd5e*fd6e1fd7e9fd8e+fd9e6fd:e7fd;e,fd<e-fd=e8fd>e:fd?e4fd@e/fdAe.fg¦  «        Z? eg dB¢¦  «        Z@dCZAdDZBdEZCdFZDdGZEdHZFdIZGdJZHdKZIdLZJdMZKeCeBeAeFeDeGeEeHeIeJeKdNœZLdOZMdPZNdOZOdQZPdRZQdSZRdTZSeOeNeMeRePeQeSdUœZTdV„ ZUdddddWdXdYdddddddZœd[„ZVd_d\„ZWd]„ ZXdS )`z3
Doc utilities: Utilities related to documentation
é    N)ÚOrderedDictc                 óö   — t          j        | ¦  «        rdS t          j        | ¦  «        }|                     ¦   «         d         }t	          |¦  «        t	          |                     ¦   «         ¦  «        z
  }d|z   S )z^Return the indentation level of the start of the docstring of a class or function (or method).é   r   )ÚinspectÚisclassÚ	getsourceÚ
splitlinesÚlenÚlstrip)ÚfuncÚsourceÚ
first_lineÚfunction_def_levels       ú^/var/www/html/services/rag-service/venv/lib/python3.11/site-packages/transformers/utils/doc.pyÚget_docstring_indentation_levelr      sr   € õ „�tÑÔð ØˆqÝÔ˜tÑ$Ô$€FØ×"Ò"Ñ$Ô$ QÔ'€JÝ˜Z™œ­3¨z×/@Ò/@Ñ/BÔ/BÑ+CÔ+CÑCÐØÐ!Ñ!Ð!ó    c                  ó   ‡ — ˆ fd„}|S )Nc                 ó^   •— d                      ‰¦  «        | j        �| j        ndz   | _        | S ©NÚ )ÚjoinÚ__doc__©ÚfnÚdocstrs    €r   Údocstring_decoratorz1add_start_docstrings.<locals>.docstring_decorator&   s,   ø€ Ø—W’W˜V‘_”_°b´jÐ6L¨¬
¨
ÐRTÑUˆŒ
Øˆ	r   © ©r   r   s   ` r   Úadd_start_docstringsr   %   ó$   ø€ ðð ð ð ð ð Ðr   c                  ó   ‡ — ˆ fd„}|S )Nc                 óF  •‡— d| j                              d¦  «        d         › d�}d|› d�}t          | ¦  «        Š| j        �| j        nd}	 t	          d„ |                     ¦   «         D ¦   «         ¦  «        }t          |¦  «        t          |                     ¦   «         ¦  «        z
  }n# t          $ r ‰}Y nw xY w‰	}|d	‰z   k    r8ˆfd
„‰	D ¦   «         }t          j
        t          j        |¦  «        d‰z  ¦  «        }d                     |¦  «        |z   }||z   | _        | S )Nz[`ú.r   z`]z    The aa   forward method, overrides the `__call__` special method.

    <Tip>

    Although the recipe for forward pass needs to be defined within this function, one should call the [`Module`]
    instance afterwards instead of this since the former takes care of running the pre and post processing steps while
    the latter silently ignores them.

    </Tip>
r   c              3   óJ   K  — | ]}|                      ¦   «         d k    ¯|V — ŒdS )r   N)Ústrip)Ú.0Úlines     r   ú	<genexpr>zUadd_start_docstrings_to_model_forward.<locals>.docstring_decorator.<locals>.<genexpr>>   s:   è è € Ð"cÐ"c¨DÐPT×PZÒPZÑP\ÔP\Ð`bÒPbÐPb 4ÐPbÐPbÐPbÐPbÐ"cÐ"cr   r   c                 ód   •— g | ],}t          j        t          j        |¦  «        d ‰z  ¦  «        ‘Œ-S )ú )ÚtextwrapÚindentÚdedent)r&   ÚdocÚcorrect_indentations     €r   ú
<listcomp>zVadd_start_docstrings_to_model_forward.<locals>.docstring_decorator.<locals>.<listcomp>G   s6   ø€ ÐgÐgÐgÐY\•H”O¥H¤O°CÑ$8Ô$8¸#Ð@SÑ:SÑTÔTÐgÐgÐgr   r*   )Ú__qualname__Úsplitr   r   Únextr	   r
   r   ÚStopIterationr+   r,   r-   r   )
r   Ú
class_nameÚintroÚcurrent_docÚfirst_non_emptyÚdoc_indentationÚdocsÚ	docstringr/   r   s
           @€r   r   zBadd_start_docstrings_to_model_forward.<locals>.docstring_decorator.   sV  øø€ Ø;˜"œ/×/Ò/°Ñ4Ô4°QÔ7Ð;Ð;Ð;ˆ
ð	˜jð 	ð 	ð 	ˆõ >¸bÑAÔAÐØ$&¤JÐ$:�b”j�jÀˆð	2Ý"Ð"cÐ"c°K×4JÒ4JÑ4LÔ4LÐ"cÑ"cÔ"cÑcÔcˆOÝ! /Ñ2Ô2µS¸×9OÒ9OÑ9QÔ9QÑ5RÔ5RÑRˆOˆOøÝð 	2ð 	2ð 	2Ø1ˆOˆOˆOð	2øøøð ˆð ˜aÐ"5Ñ5Ò5Ð5ØgÐgÐgÐgÐ`fÐgÑgÔgˆDÝ”O¥H¤O°EÑ$:Ô$:¸CÐBUÑ<UÑVÔVˆEà—G’G˜D‘M”M KÑ/ˆ	Ø˜YÑ&ˆŒ
Øˆ	s   ÁAB* Â*B9Â8B9r   r   s   ` r   Ú%add_start_docstrings_to_model_forwardr<   -   s%   ø€ ðð ð ð ð ð@ Ðr   c                  ó   ‡ — ˆ fd„}|S )Nc                 ó^   •— | j         �| j         ndd                     ‰¦  «        z   | _         | S r   )r   r   r   s    €r   r   z/add_end_docstrings.<locals>.docstring_decoratorR   s+   ø€ Ø$&¤JÐ$:�b”j�jÀÀbÇgÂgÈfÁoÄoÑUˆŒ
Øˆ	r   r   r   s   ` r   Úadd_end_docstringsr?   Q   r    r   a:  
    Returns:
        [`{full_output_type}`] or `tuple(torch.FloatTensor)`: A [`{full_output_type}`] or a tuple of
        `torch.FloatTensor` (if `return_dict=False` is passed or when `config.return_dict=False`) comprising various
        elements depending on the configuration ([`{config_class}`]) and inputs.

a*  
    Returns:
        [`{full_output_type}`] or `tuple(tf.Tensor)`: A [`{full_output_type}`] or a tuple of `tf.Tensor` (if
        `return_dict=False` is passed or when `config.return_dict=False`) comprising various elements depending on the
        configuration ([`{config_class}`]) and inputs.

c                 óh   — t          j        d| ¦  «        }|€dn|                     ¦   «         d         S )z.Returns the indentation in the first line of tz^(\s*)\SNr   r   )ÚreÚsearchÚgroups)ÚtrB   s     r   Ú_get_indentrE   k   s.   € åŒY�{ AÑ&Ô&€FØ�ˆ2ˆ2 V§]¢]¡_¤_°QÔ%7Ð7r   c                 ó(  — t          | ¦  «        }g }d}|                      d¦  «        D ][}t          |¦  «        |k    r6t          |¦  «        dk    r|                     |dd…         ¦  «         |› d�}ŒK||dd…         › d�z  }Œ\|                     |dd…         ¦  «         t	          t          |¦  «        ¦  «        D ]@}t          j        dd||         ¦  «        ||<   t          j        d	d
||         ¦  «        ||<   ŒAd                     |¦  «        S )z,Convert output_args_doc to display properly.r   ú
r   Néÿÿÿÿé   z^(\s+)(\S+)(\s+)z\1- **\2**\3z:\s*\n\s*(\S)z -- \1)rE   r2   r
   ÚappendÚrangerA   Úsubr   )Úoutput_args_docr,   ÚblocksÚcurrent_blockr'   Úis         r   Ú_convert_output_args_docrQ   q   s*  € õ ˜Ñ)Ô)€FØ€FØ€MØ×%Ò% dÑ+Ô+ð 	-ð 	-ˆå�tÑÔ Ò&Ð&Ý�=Ñ!Ô! AÒ%Ð%Ø—’˜m¨C¨R¨CÔ0Ñ1Ô1Ð1Ø#˜K˜K˜KˆMˆMð   Q R R¤˜_˜_˜_Ñ,ˆMˆMØ
‡M‚M�-   Ô$Ñ%Ô%Ð%õ •3�v‘;”;ÑÔð Cð CˆÝ”FÐ.°ÀÈÄÑKÔKˆˆq‰	Ý”FÐ+¨Y¸¸q¼	ÑBÔBˆˆq‰	ˆ	à�9Š9�VÑÔÐr   Tc                 óþ  ‡— | j         }d}|�Õ|                     d¦  «        }d}|t          |¦  «        k     rNt          j        d||         ¦  «        €3|dz  }|t          |¦  «        k     rt          j        d||         ¦  «        ®3|t          |¦  «        k     r0d                     ||dz   d…         ¦  «        }t          |¦  «        }n|rt          d| j        › d�¦  «        ‚|rQ| j	        › d| j        › �}| j         
                    d	¦  «        rt          nt          }	|	                     ||¬
¦  «        }	nt          | ¦  «        }d|› d�}	|�|	dz  }	|	}
|�|
|z  }
|�¡|
                     d¦  «        }d}t          ||         ¦  «        dk    r|dz  }t          ||         ¦  «        dk    °t          t          ||         ¦  «        ¦  «        }||k     r+d||z
  z  Šˆfd„|D ¦   «         }d                     |¦  «        }
|
S )zH
    Prepares the return part of the docstring using `output_type`.
    NrG   r   z^\s*(Args|Parameters):\s*$é   z@No `Args` or `Parameters` section is found in the docstring of `zH`. Make sure it has docstring and contain either `Args` or `Parameters`.r#   ÚTF)Úfull_output_typeÚconfig_classz
Returns:
    `ú`z:
r*   c                 óF   •— g | ]}t          |¦  «        d k    r‰› |› �n|‘ŒS )r   )r
   )r&   r'   Úto_adds     €r   r0   z._prepare_output_docstrings.<locals>.<listcomp>º   s7   ø€ ÐVÐVÐVÈ­3¨t©9¬9°qª=¨=˜Ð' Ð'Ð'Ð'¸dÐVÐVÐVr   )r   r2   r
   rA   rB   r   rQ   Ú
ValueErrorÚ__name__Ú
__module__Ú
startswithÚTF_RETURN_INTRODUCTIONÚPT_RETURN_INTRODUCTIONÚformatÚstrrE   )Úoutput_typerV   Ú
min_indentÚ	add_introÚoutput_docstringÚparams_docstringÚlinesrP   rU   r6   Úresultr,   rY   s               @r   Ú_prepare_output_docstringsri   ‹   sY  ø€ ð #Ô*ÐØÐØÐ#à ×&Ò& tÑ,Ô,ˆØˆØ•#�e‘*”*Šnˆn¥¤Ð+HÈ%ÐPQÌ(Ñ!SÔ!SÐ![Ø�‰FˆAð •#�e‘*”*Šnˆn¥¤Ð+HÈ%ÐPQÌ(Ñ!SÔ!SÐ![à�s�5‰zŒzŠ>ˆ>Ø#Ÿyšy¨°°A±¨y¨yÔ)9Ñ:Ô:ÐÝ7Ð8HÑIÔIÐÐØð 	ÝðGÐS^ÔSgð Gð Gð Gñô ð ð ð Ø)Ô4ÐMÐM°{Ô7KÐMÐMÐØ*5Ô*>×*IÒ*IÈ$Ñ*OÔ*OÐkÕ&Ð&ÕUkˆØ—’Ð.>È\�ÑZÔZˆˆå˜{Ñ+Ô+ÐØ7Ð$4Ð7Ð7Ð7ˆØÐ'Ø�U‰NˆEà€FØÐ#ØÐ"Ñ"ˆð ÐØ—’˜TÑ"Ô"ˆàˆÝ�%˜”(‰mŒm˜qÒ Ð Ø�‰FˆAõ �%˜”(‰mŒm˜qÒ Ð å•[  q¤Ñ*Ô*Ñ+Ô+ˆà�JÒÐØ˜J¨Ñ/Ñ0ˆFØVÐVÐVÐVÐPUÐVÑVÔVˆEØ—Y’Y˜uÑ%Ô%ˆFà€Mr   aJ  
    <Tip warning={true}>

    This example uses a random model as the real ones are all very big. To get proper results, you should use
    {real_checkpoint} instead of {fake_checkpoint}. If you get out-of-memory when loading that checkpoint, you can try
    adding `device_map="auto"` in the `from_pretrained` call.

    </Tip>
a  
    Example:

    ```python
    >>> from transformers import AutoTokenizer, {model_class}
    >>> import torch

    >>> tokenizer = AutoTokenizer.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> inputs = tokenizer(
    ...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
    ... )

    >>> with torch.no_grad():
    ...     logits = model(**inputs).logits

    >>> predicted_token_class_ids = logits.argmax(-1)

    >>> # Note that tokens are classified rather then input words which means that
    >>> # there might be more predicted token classes than words.
    >>> # Multiple token classes might account for the same word
    >>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]
    >>> predicted_tokens_classes
    {expected_output}

    >>> labels = predicted_token_class_ids
    >>> loss = model(**inputs, labels=labels).loss
    >>> round(loss.item(), 2)
    {expected_loss}
    ```
a_  
    Example:

    ```python
    >>> from transformers import AutoTokenizer, {model_class}
    >>> import torch

    >>> tokenizer = AutoTokenizer.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

    >>> inputs = tokenizer(question, text, return_tensors="pt")
    >>> with torch.no_grad():
    ...     outputs = model(**inputs)

    >>> answer_start_index = outputs.start_logits.argmax()
    >>> answer_end_index = outputs.end_logits.argmax()

    >>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
    >>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
    {expected_output}

    >>> # target is "nice puppet"
    >>> target_start_index = torch.tensor([{qa_target_start_index}])
    >>> target_end_index = torch.tensor([{qa_target_end_index}])

    >>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
    >>> loss = outputs.loss
    >>> round(loss.item(), 2)
    {expected_loss}
    ```
a  
    Example of single-label classification:

    ```python
    >>> import torch
    >>> from transformers import AutoTokenizer, {model_class}

    >>> tokenizer = AutoTokenizer.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

    >>> with torch.no_grad():
    ...     logits = model(**inputs).logits

    >>> predicted_class_id = logits.argmax().item()
    >>> model.config.id2label[predicted_class_id]
    {expected_output}

    >>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
    >>> num_labels = len(model.config.id2label)
    >>> model = {model_class}.from_pretrained("{checkpoint}", num_labels=num_labels)

    >>> labels = torch.tensor([1])
    >>> loss = model(**inputs, labels=labels).loss
    >>> round(loss.item(), 2)
    {expected_loss}
    ```

    Example of multi-label classification:

    ```python
    >>> import torch
    >>> from transformers import AutoTokenizer, {model_class}

    >>> tokenizer = AutoTokenizer.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}", problem_type="multi_label_classification")

    >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

    >>> with torch.no_grad():
    ...     logits = model(**inputs).logits

    >>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

    >>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
    >>> num_labels = len(model.config.id2label)
    >>> model = {model_class}.from_pretrained(
    ...     "{checkpoint}", num_labels=num_labels, problem_type="multi_label_classification"
    ... )

    >>> labels = torch.sum(
    ...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
    ... ).to(torch.float)
    >>> loss = model(**inputs, labels=labels).loss
    ```
a   
    Example:

    ```python
    >>> from transformers import AutoTokenizer, {model_class}
    >>> import torch

    >>> tokenizer = AutoTokenizer.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> inputs = tokenizer("The capital of France is {mask}.", return_tensors="pt")

    >>> with torch.no_grad():
    ...     logits = model(**inputs).logits

    >>> # retrieve index of {mask}
    >>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]

    >>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)
    >>> tokenizer.decode(predicted_token_id)
    {expected_output}

    >>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
    >>> # mask labels of non-{mask} tokens
    >>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)

    >>> outputs = model(**inputs, labels=labels)
    >>> round(outputs.loss.item(), 2)
    {expected_loss}
    ```
a�  
    Example:

    ```python
    >>> from transformers import AutoTokenizer, {model_class}
    >>> import torch

    >>> tokenizer = AutoTokenizer.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
    >>> outputs = model(**inputs)

    >>> last_hidden_states = outputs.last_hidden_state
    ```
a•  
    Example:

    ```python
    >>> from transformers import AutoTokenizer, {model_class}
    >>> import torch

    >>> tokenizer = AutoTokenizer.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
    >>> choice0 = "It is eaten with a fork and a knife."
    >>> choice1 = "It is eaten while held in the hand."
    >>> labels = torch.tensor(0).unsqueeze(0)  # choice0 is correct (according to Wikipedia ;)), batch size 1

    >>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
    >>> outputs = model(**{{k: v.unsqueeze(0) for k, v in encoding.items()}}, labels=labels)  # batch size is 1

    >>> # the linear classifier still needs to be trained
    >>> loss = outputs.loss
    >>> logits = outputs.logits
    ```
a½  
    Example:

    ```python
    >>> import torch
    >>> from transformers import AutoTokenizer, {model_class}

    >>> tokenizer = AutoTokenizer.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
    >>> outputs = model(**inputs, labels=inputs["input_ids"])
    >>> loss = outputs.loss
    >>> logits = outputs.logits
    ```
aA  
    Example:

    ```python
    >>> from transformers import AutoProcessor, {model_class}
    >>> import torch
    >>> from datasets import load_dataset

    >>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
    >>> dataset = dataset.sort("id")
    >>> sampling_rate = dataset.features["audio"].sampling_rate

    >>> processor = AutoProcessor.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> # audio file is decoded on the fly
    >>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
    >>> with torch.no_grad():
    ...     outputs = model(**inputs)

    >>> last_hidden_states = outputs.last_hidden_state
    >>> list(last_hidden_states.shape)
    {expected_output}
    ```
a]  
    Example:

    ```python
    >>> from transformers import AutoProcessor, {model_class}
    >>> from datasets import load_dataset
    >>> import torch

    >>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
    >>> dataset = dataset.sort("id")
    >>> sampling_rate = dataset.features["audio"].sampling_rate

    >>> processor = AutoProcessor.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> # audio file is decoded on the fly
    >>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
    >>> with torch.no_grad():
    ...     logits = model(**inputs).logits
    >>> predicted_ids = torch.argmax(logits, dim=-1)

    >>> # transcribe speech
    >>> transcription = processor.batch_decode(predicted_ids)
    >>> transcription[0]
    {expected_output}

    >>> inputs["labels"] = processor(text=dataset[0]["text"], return_tensors="pt").input_ids

    >>> # compute loss
    >>> loss = model(**inputs).loss
    >>> round(loss.item(), 2)
    {expected_loss}
    ```
a²  
    Example:

    ```python
    >>> from transformers import AutoFeatureExtractor, {model_class}
    >>> from datasets import load_dataset
    >>> import torch

    >>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
    >>> dataset = dataset.sort("id")
    >>> sampling_rate = dataset.features["audio"].sampling_rate

    >>> feature_extractor = AutoFeatureExtractor.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> # audio file is decoded on the fly
    >>> inputs = feature_extractor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")

    >>> with torch.no_grad():
    ...     logits = model(**inputs).logits

    >>> predicted_class_ids = torch.argmax(logits, dim=-1).item()
    >>> predicted_label = model.config.id2label[predicted_class_ids]
    >>> predicted_label
    {expected_output}

    >>> # compute loss - target_label is e.g. "down"
    >>> target_label = model.config.id2label[0]
    >>> inputs["labels"] = torch.tensor([model.config.label2id[target_label]])
    >>> loss = model(**inputs).loss
    >>> round(loss.item(), 2)
    {expected_loss}
    ```
aÉ  
    Example:

    ```python
    >>> from transformers import AutoFeatureExtractor, {model_class}
    >>> from datasets import load_dataset
    >>> import torch

    >>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
    >>> dataset = dataset.sort("id")
    >>> sampling_rate = dataset.features["audio"].sampling_rate

    >>> feature_extractor = AutoFeatureExtractor.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> # audio file is decoded on the fly
    >>> inputs = feature_extractor(dataset[0]["audio"]["array"], return_tensors="pt", sampling_rate=sampling_rate)
    >>> with torch.no_grad():
    ...     logits = model(**inputs).logits

    >>> probabilities = torch.sigmoid(logits[0])
    >>> # labels is a one-hot array of shape (num_frames, num_speakers)
    >>> labels = (probabilities > 0.5).long()
    >>> labels[0].tolist()
    {expected_output}
    ```
a  
    Example:

    ```python
    >>> from transformers import AutoFeatureExtractor, {model_class}
    >>> from datasets import load_dataset
    >>> import torch

    >>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
    >>> dataset = dataset.sort("id")
    >>> sampling_rate = dataset.features["audio"].sampling_rate

    >>> feature_extractor = AutoFeatureExtractor.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> # audio file is decoded on the fly
    >>> inputs = feature_extractor(
    ...     [d["array"] for d in dataset[:2]["audio"]], sampling_rate=sampling_rate, return_tensors="pt", padding=True
    ... )
    >>> with torch.no_grad():
    ...     embeddings = model(**inputs).embeddings

    >>> embeddings = torch.nn.functional.normalize(embeddings, dim=-1).cpu()

    >>> # the resulting embeddings can be used for cosine similarity-based retrieval
    >>> cosine_sim = torch.nn.CosineSimilarity(dim=-1)
    >>> similarity = cosine_sim(embeddings[0], embeddings[1])
    >>> threshold = 0.7  # the optimal threshold is dataset-dependent
    >>> if similarity < threshold:
    ...     print("Speakers are not the same!")
    >>> round(similarity.item(), 2)
    {expected_output}
    ```
a‘  
    Example:

    ```python
    >>> from transformers import AutoImageProcessor, {model_class}
    >>> import torch
    >>> from datasets import load_dataset

    >>> dataset = load_dataset("huggingface/cats-image")
    >>> image = dataset["test"]["image"][0]

    >>> image_processor = AutoImageProcessor.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> inputs = image_processor(image, return_tensors="pt")

    >>> with torch.no_grad():
    ...     outputs = model(**inputs)

    >>> last_hidden_states = outputs.last_hidden_state
    >>> list(last_hidden_states.shape)
    {expected_output}
    ```
aÜ  
    Example:

    ```python
    >>> from transformers import AutoImageProcessor, {model_class}
    >>> import torch
    >>> from datasets import load_dataset

    >>> dataset = load_dataset("huggingface/cats-image")
    >>> image = dataset["test"]["image"][0]

    >>> image_processor = AutoImageProcessor.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> inputs = image_processor(image, return_tensors="pt")

    >>> with torch.no_grad():
    ...     logits = model(**inputs).logits

    >>> # model predicts one of the 1000 ImageNet classes
    >>> predicted_label = logits.argmax(-1).item()
    >>> print(model.config.id2label[predicted_label])
    {expected_output}
    ```
)ÚSequenceClassificationÚQuestionAnsweringÚTokenClassificationÚMultipleChoiceÚMaskedLMÚLMHeadÚ	BaseModelÚSpeechBaseModelÚCTCÚAudioClassificationÚAudioFrameClassificationÚAudioXVectorÚVisionBaseModelÚImageClassificationa  
    Example:

    ```python
    >>> from transformers import AutoProcessor, {model_class}, SpeechT5HifiGan

    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> processor = AutoProcessor.from_pretrained("{checkpoint}")
    >>> vocoder = SpeechT5HifiGan.from_pretrained("microsoft/speecht5_hifigan")
    >>> inputs = processor(text="Hello, my dog is cute", return_tensors="pt")

    >>> # generate speech
    >>> speech = model.generate(inputs["input_ids"], speaker_embeddings=speaker_embeddings, vocoder=vocoder)
    ```
az  
    Example:

    ```python
    >>> from transformers import AutoProcessor, {model_class}

    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> processor = AutoProcessor.from_pretrained("{checkpoint}")
    >>> inputs = processor(text="Hello, my dog is cute", return_tensors="pt")

    >>> # generate speech
    >>> speech = model(inputs["input_ids"])
    ```
a  
    Example:

    ```python
    >>> from PIL import Image
    >>> import requests
    >>> from transformers import AutoProcessor, {model_class}

    >>> processor = AutoProcessor.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
    >>> image = Image.open(requests.get(url, stream=True).raw)

    >>> inputs = processor(images=image, return_tensors="pt")

    >>> outputs = model(**inputs)
    ```
aÒ  
    Example:

    ```python
    >>> from transformers import AutoImageProcessor, {model_class}
    >>> import torch
    >>> from PIL import Image
    >>> import requests

    >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
    >>> image = Image.open(requests.get(url, stream=True).raw)

    >>> processor = AutoImageProcessor.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    >>> model.to(device)

    >>> # prepare image for the model
    >>> inputs = processor(images=image, return_tensors="pt").to(device)

    >>> with torch.no_grad():
    ...     outputs = model(**inputs)

    >>> # interpolate to original size
    >>> post_processed_output = processor.post_process_depth_estimation(
    ...     outputs, [(image.height, image.width)],
    ... )
    >>> predicted_depth = post_processed_output[0]["predicted_depth"]
    ```
z%
    Example:

    ```python
    ```
aÞ  
    Example:

    ```python
    >>> from PIL import Image
    >>> import requests
    >>> from transformers import AutoProcessor, {model_class}

    >>> model = {model_class}.from_pretrained("{checkpoint}")
    >>> processor = AutoProcessor.from_pretrained("{checkpoint}")

    >>> messages = [
    ...     {{
    ...         "role": "user", "content": [
    ...             {{"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"}},
    ...             {{"type": "text", "text": "Where is the cat standing?"}},
    ...         ]
    ...     }},
    ... ]

    >>> inputs = processor.apply_chat_template(
    ...     messages,
    ...     tokenize=True,
    ...     return_dict=True,
    ...     return_tensors="pt",
    ...     add_generation_prompt=True
    ... )
    >>> # Generate
    >>> generate_ids = model.generate(**inputs)
    >>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]
    ```
útext-to-audio-spectrogramútext-to-audio-waveformúautomatic-speech-recognitionúaudio-frame-classificationúaudio-classificationúaudio-xvectorúimage-text-to-textúimage-to-textúvisual-question-answeringúdepth-estimationúvideo-classificationúzero-shot-image-classificationúimage-classificationúzero-shot-object-detectionúobject-detectionúimage-segmentationúimage-to-imageúimage-feature-extractionútext-generationútable-question-answeringúdocument-question-answeringúquestion-answeringútext2text-generationúnext-sentence-predictionúmultiple-choiceútext-classificationútoken-classificationú	fill-maskúmask-generationÚpretraining))Ú+MODEL_FOR_TEXT_TO_SPECTROGRAM_MAPPING_NAMESrx   )Ú(MODEL_FOR_TEXT_TO_WAVEFORM_MAPPING_NAMESry   )Ú(MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING_NAMESrz   )ÚMODEL_FOR_CTC_MAPPING_NAMESrz   )Ú2MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING_NAMESr{   )Ú,MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING_NAMESr|   )Ú%MODEL_FOR_AUDIO_XVECTOR_MAPPING_NAMESr}   )Ú*MODEL_FOR_IMAGE_TEXT_TO_TEXT_MAPPING_NAMESr~   )Ú$MODEL_FOR_VISION_2_SEQ_MAPPING_NAMESr   )Ú1MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING_NAMESr€   )Ú(MODEL_FOR_DEPTH_ESTIMATION_MAPPING_NAMESr�   )Ú,MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING_NAMESr‚   )Ú6MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING_NAMESrƒ   )Ú,MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING_NAMESr„   )Ú2MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING_NAMESr…   )Ú(MODEL_FOR_OBJECT_DETECTION_MAPPING_NAMESr†   )Ú*MODEL_FOR_IMAGE_SEGMENTATION_MAPPING_NAMESr‡   )Ú&MODEL_FOR_IMAGE_TO_IMAGE_MAPPING_NAMESrˆ   )ÚMODEL_FOR_IMAGE_MAPPING_NAMESr‰   )Ú!MODEL_FOR_CAUSAL_LM_MAPPING_NAMESrŠ   )Ú0MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING_NAMESr‹   )Ú3MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING_NAMESrŒ   )Ú*MODEL_FOR_QUESTION_ANSWERING_MAPPING_NAMESr�   )Ú,MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING_NAMESrŽ   )Ú0MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING_NAMESr�   )Ú'MODEL_FOR_MULTIPLE_CHOICE_MAPPING_NAMESr�   )Ú/MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING_NAMESr‘   )Ú,MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING_NAMESr’   )Ú!MODEL_FOR_MASKED_LM_MAPPING_NAMESr“   )Ú'MODEL_FOR_MASK_GENERATION_MAPPING_NAMESr”   )Ú#MODEL_FOR_PRETRAINING_MAPPING_NAMESr•   aI  
    Example:

    ```python
    >>> from transformers import AutoTokenizer, {model_class}
    >>> import tensorflow as tf

    >>> tokenizer = AutoTokenizer.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> inputs = tokenizer(
    ...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="tf"
    ... )

    >>> logits = model(**inputs).logits
    >>> predicted_token_class_ids = tf.math.argmax(logits, axis=-1)

    >>> # Note that tokens are classified rather then input words which means that
    >>> # there might be more predicted token classes than words.
    >>> # Multiple token classes might account for the same word
    >>> predicted_tokens_classes = [model.config.id2label[t] for t in predicted_token_class_ids[0].numpy().tolist()]
    >>> predicted_tokens_classes
    {expected_output}
    ```

    ```python
    >>> labels = predicted_token_class_ids
    >>> loss = tf.math.reduce_mean(model(**inputs, labels=labels).loss)
    >>> round(float(loss), 2)
    {expected_loss}
    ```
a‡  
    Example:

    ```python
    >>> from transformers import AutoTokenizer, {model_class}
    >>> import tensorflow as tf

    >>> tokenizer = AutoTokenizer.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

    >>> inputs = tokenizer(question, text, return_tensors="tf")
    >>> outputs = model(**inputs)

    >>> answer_start_index = int(tf.math.argmax(outputs.start_logits, axis=-1)[0])
    >>> answer_end_index = int(tf.math.argmax(outputs.end_logits, axis=-1)[0])

    >>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
    >>> tokenizer.decode(predict_answer_tokens)
    {expected_output}
    ```

    ```python
    >>> # target is "nice puppet"
    >>> target_start_index = tf.constant([{qa_target_start_index}])
    >>> target_end_index = tf.constant([{qa_target_end_index}])

    >>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
    >>> loss = tf.math.reduce_mean(outputs.loss)
    >>> round(float(loss), 2)
    {expected_loss}
    ```
a›  
    Example:

    ```python
    >>> from transformers import AutoTokenizer, {model_class}
    >>> import tensorflow as tf

    >>> tokenizer = AutoTokenizer.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")

    >>> logits = model(**inputs).logits

    >>> predicted_class_id = int(tf.math.argmax(logits, axis=-1)[0])
    >>> model.config.id2label[predicted_class_id]
    {expected_output}
    ```

    ```python
    >>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
    >>> num_labels = len(model.config.id2label)
    >>> model = {model_class}.from_pretrained("{checkpoint}", num_labels=num_labels)

    >>> labels = tf.constant(1)
    >>> loss = model(**inputs, labels=labels).loss
    >>> round(float(loss), 2)
    {expected_loss}
    ```
a4  
    Example:

    ```python
    >>> from transformers import AutoTokenizer, {model_class}
    >>> import tensorflow as tf

    >>> tokenizer = AutoTokenizer.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> inputs = tokenizer("The capital of France is {mask}.", return_tensors="tf")
    >>> logits = model(**inputs).logits

    >>> # retrieve index of {mask}
    >>> mask_token_index = tf.where((inputs.input_ids == tokenizer.mask_token_id)[0])
    >>> selected_logits = tf.gather_nd(logits[0], indices=mask_token_index)

    >>> predicted_token_id = tf.math.argmax(selected_logits, axis=-1)
    >>> tokenizer.decode(predicted_token_id)
    {expected_output}
    ```

    ```python
    >>> labels = tokenizer("The capital of France is Paris.", return_tensors="tf")["input_ids"]
    >>> # mask labels of non-{mask} tokens
    >>> labels = tf.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)

    >>> outputs = model(**inputs, labels=labels)
    >>> round(float(outputs.loss), 2)
    {expected_loss}
    ```
a¦  
    Example:

    ```python
    >>> from transformers import AutoTokenizer, {model_class}
    >>> import tensorflow as tf

    >>> tokenizer = AutoTokenizer.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
    >>> outputs = model(inputs)

    >>> last_hidden_states = outputs.last_hidden_state
    ```
a#  
    Example:

    ```python
    >>> from transformers import AutoTokenizer, {model_class}
    >>> import tensorflow as tf

    >>> tokenizer = AutoTokenizer.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
    >>> choice0 = "It is eaten with a fork and a knife."
    >>> choice1 = "It is eaten while held in the hand."

    >>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="tf", padding=True)
    >>> inputs = {{k: tf.expand_dims(v, 0) for k, v in encoding.items()}}
    >>> outputs = model(inputs)  # batch size is 1

    >>> # the linear classifier still needs to be trained
    >>> logits = outputs.logits
    ```
aŽ  
    Example:

    ```python
    >>> from transformers import AutoTokenizer, {model_class}
    >>> import tensorflow as tf

    >>> tokenizer = AutoTokenizer.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
    >>> outputs = model(inputs)
    >>> logits = outputs.logits
    ```
a
  
    Example:

    ```python
    >>> from transformers import AutoProcessor, {model_class}
    >>> from datasets import load_dataset

    >>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
    >>> dataset = dataset.sort("id")
    >>> sampling_rate = dataset.features["audio"].sampling_rate

    >>> processor = AutoProcessor.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> # audio file is decoded on the fly
    >>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="tf")
    >>> outputs = model(**inputs)

    >>> last_hidden_states = outputs.last_hidden_state
    >>> list(last_hidden_states.shape)
    {expected_output}
    ```
a_  
    Example:

    ```python
    >>> from transformers import AutoProcessor, {model_class}
    >>> from datasets import load_dataset
    >>> import tensorflow as tf

    >>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
    >>> dataset = dataset.sort("id")
    >>> sampling_rate = dataset.features["audio"].sampling_rate

    >>> processor = AutoProcessor.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> # audio file is decoded on the fly
    >>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="tf")
    >>> logits = model(**inputs).logits
    >>> predicted_ids = tf.math.argmax(logits, axis=-1)

    >>> # transcribe speech
    >>> transcription = processor.batch_decode(predicted_ids)
    >>> transcription[0]
    {expected_output}
    ```

    ```python
    >>> inputs["labels"] = processor(text=dataset[0]["text"], return_tensors="tf").input_ids

    >>> # compute loss
    >>> loss = model(**inputs).loss
    >>> round(float(loss), 2)
    {expected_loss}
    ```
aY  
    Example:

    ```python
    >>> from transformers import AutoImageProcessor, {model_class}
    >>> from datasets import load_dataset

    >>> dataset = load_dataset("huggingface/cats-image")
    >>> image = dataset["test"]["image"][0]

    >>> image_processor = AutoImageProcessor.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> inputs = image_processor(image, return_tensors="tf")
    >>> outputs = model(**inputs)

    >>> last_hidden_states = outputs.last_hidden_state
    >>> list(last_hidden_states.shape)
    {expected_output}
    ```
aÑ  
    Example:

    ```python
    >>> from transformers import AutoImageProcessor, {model_class}
    >>> import tensorflow as tf
    >>> from datasets import load_dataset

    >>> dataset = load_dataset("huggingface/cats-image"))
    >>> image = dataset["test"]["image"][0]

    >>> image_processor = AutoImageProcessor.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> inputs = image_processor(image, return_tensors="tf")
    >>> logits = model(**inputs).logits

    >>> # model predicts one of the 1000 ImageNet classes
    >>> predicted_label = int(tf.math.argmax(logits, axis=-1))
    >>> print(model.config.id2label[predicted_label])
    {expected_output}
    ```
)rj   rk   rl   rm   rn   ro   rp   rq   rr   rv   rw   ar  
    Example:

    ```python
    >>> from transformers import AutoTokenizer, {model_class}

    >>> tokenizer = AutoTokenizer.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="jax")

    >>> outputs = model(**inputs)
    >>> logits = outputs.logits
    ```
aì  
    Example:

    ```python
    >>> from transformers import AutoTokenizer, {model_class}

    >>> tokenizer = AutoTokenizer.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
    >>> inputs = tokenizer(question, text, return_tensors="jax")

    >>> outputs = model(**inputs)
    >>> start_scores = outputs.start_logits
    >>> end_scores = outputs.end_logits
    ```
a}  
    Example:

    ```python
    >>> from transformers import AutoTokenizer, {model_class}

    >>> tokenizer = AutoTokenizer.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> inputs = tokenizer("The capital of France is {mask}.", return_tensors="jax")

    >>> outputs = model(**inputs)
    >>> logits = outputs.logits
    ```
a‰  
    Example:

    ```python
    >>> from transformers import AutoTokenizer, {model_class}

    >>> tokenizer = AutoTokenizer.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="jax")
    >>> outputs = model(**inputs)

    >>> last_hidden_states = outputs.last_hidden_state
    ```
a—  
    Example:

    ```python
    >>> from transformers import AutoTokenizer, {model_class}

    >>> tokenizer = AutoTokenizer.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
    >>> choice0 = "It is eaten with a fork and a knife."
    >>> choice1 = "It is eaten while held in the hand."

    >>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="jax", padding=True)
    >>> outputs = model(**{{k: v[None, :] for k, v in encoding.items()}})

    >>> logits = outputs.logits
    ```
a«  
    Example:

    ```python
    >>> from transformers import AutoTokenizer, {model_class}

    >>> tokenizer = AutoTokenizer.from_pretrained("{checkpoint}")
    >>> model = {model_class}.from_pretrained("{checkpoint}")

    >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="np")
    >>> outputs = model(**inputs)

    >>> # retrieve logts for next token
    >>> next_token_logits = outputs.logits[:, -1]
    ```
)rj   rk   rl   rm   rn   rp   ro   c                 ó„   — |                      ¦   «         D ]*\  }}|�Œd|z   dz   }t          j        d|› d�d| ¦  «        } Œ+| S )zo
    Removes the lines testing an output with the doctest syntax in a code sample when it's set to `None`.
    NÚ{Ú}z\n([^\n]+)\n\s+z\nrG   )ÚitemsrA   rL   )r;   ÚkwargsÚkeyÚvalueÚdoc_keys        r   Úfilter_outputs_from_exampler½   ¡  s^   € ð —l’l‘n”nð Lð L‰
ˆˆUØÐØà˜‘)˜c‘/ˆÝ”FÐ9¨gÐ9Ð9Ð9¸4ÀÑKÔKˆ	ˆ	àÐr   z[MASK]é   é   )Úprocessor_classÚ
checkpointrb   rV   ÚmaskÚqa_target_start_indexÚqa_target_end_indexÚ	model_clsÚmodalityÚexpected_outputÚexpected_lossÚreal_checkpointÚrevisionc                 óF   ‡ ‡‡‡‡‡‡‡‡‡	‡
‡‡‡— ˆˆˆˆ
ˆ	ˆˆˆˆˆ ˆˆˆˆfd„}|S )Nc                 ó  •— ‰€ | j                              d¦  «        d         n‰}|d d…         dk    rt          }n|d d…         dk    rt          }nt          }|‰‰‰‰‰‰‰‰‰ddœ}d	|v sd
|v r‰dk    r	|d
         }nÙd	|v r	|d	         }nÌd|v r	|d         }n¿d|v r	|d         }n²d|v r	|d         }n¥d|v s|dv r	|d         }n”d|v sd|v r	|d         }nƒd|v r	|d         }nvd|v r	|d         }nid|v r‰dk    r	|d         }nVd|v r‰dk    r	|d         }nCd|v r‰dk    r	|d         }n0d|v sd|v r	|d         }nd|v r	|d         }nt          d|› �¦  «        ‚t          |‰‰¬¦  «        }‰�
t          |z   }| j        pd d  	                    ‰
¦  «        z   }‰€d nt          ‰‰	¦  «        } |j        d'i |¤Ž}‰�It          j        d!‰¦  «        rt          d"‰› d#�¦  «        ‚|                     d$‰› d%�d$‰› d&‰› d%�¦  «        }||z   |z   | _        | S )(Nr#   r   rI   rT   r   ÚFlaxz{true})Úmodel_classrÀ   rÁ   rÂ   rÃ   rÄ   rÇ   rÈ   rÉ   Úfake_checkpointÚtruerj   rs   Úaudiork   rl   rm   rn   )ÚFlaubertWithLMHeadModelÚXLMWithLMHeadModelro   ÚCausalLMrr   rt   ÚXVectorru   ÚModelrq   Úvisionrv   ÚEncoderrp   rw   z#Docstring can't be built for model )rÇ   rÈ   r   z^refs/pr/\\d+zThe provided revision 'zW' is incorrect. It should point to a pull request reference on the hub like 'refs/pr/6'zfrom_pretrained("z")z", revision="r   )r1   r2   ÚTF_SAMPLE_DOCSTRINGSÚFLAX_SAMPLE_DOCSTRINGSÚPT_SAMPLE_DOCSTRINGSrZ   r½   ÚFAKE_MODEL_DISCLAIMERr   r   ri   r`   rA   ÚmatchÚreplace)r   rÎ   Úsample_docstringsÚ
doc_kwargsÚcode_sampleÚfunc_docÚ
output_docÚ	built_docrÁ   rV   r   rÈ   rÇ   rÂ   rÆ   rÅ   rb   rÀ   rÄ   rÃ   rÉ   rÊ   s           €€€€€€€€€€€€€€r   r   z7add_code_sample_docstrings.<locals>.docstring_decorator¿  sb  ø€ à7@Ð7H�b”o×+Ò+¨CÑ0Ô0°Ô3Ð3Èiˆà�r˜�rŒ?˜dÒ"Ð"Ý 4ÐÐØ˜˜!˜Œ_ Ò&Ð&Ý 6ÐÐå 4Ðð 'Ø.Ø$ØØ%:Ø#6Ø.Ø*Ø.Ø)Øð
ð 
ˆ
ð %¨Ð3Ð3Ð7LÐP[Ð7[Ð7[ÐaiÐmtÒatÐatØ+Ð,AÔBˆKˆKØ%¨Ð4Ð4Ø+Ð,DÔEˆKˆKØ  KÐ/Ð/Ø+Ð,?Ô@ˆKˆKØ" kÐ1Ð1Ø+Ð,AÔBˆKˆKØ Ð,Ð,Ø+Ð,<Ô=ˆKˆKØ˜;Ð&Ð&¨+Ð9jÐ*jÐ*jØ+¨JÔ7ˆKˆKØ˜Ð$Ð$¨
°kÐ(AÐ(AØ+¨HÔ5ˆKˆKØ�kÐ!Ð!Ø+¨EÔ2ˆKˆKØ'¨;Ð6Ð6Ø+Ð,FÔGˆKˆKØ˜+Ð%Ð%¨(°gÒ*=Ð*=Ø+¨NÔ;ˆKˆKØ˜Ð#Ð#¨°GÒ(;Ð(;Ø+Ð,=Ô>ˆKˆKØ˜Ð#Ð#¨°HÒ(<Ð(<Ø+Ð,=Ô>ˆKˆKØ˜Ð#Ð# y°KÐ'?Ð'?Ø+¨KÔ8ˆKˆKØ" kÐ1Ð1Ø+Ð,AÔBˆKˆKåÐPÀ;ÐPÐPÑQÔQÐQå1Ø¨Èð
ñ 
ô 
ˆð Ð&Ý/°+Ñ=ˆKØ”JÐ$ "¨¯ª°©¬Ñ7ˆØ&Ð.�R�RÕ4NÈ{Ð\hÑ4iÔ4iˆ
Ø&�KÔ&Ð4Ð4¨Ð4Ð4ˆ	ØÐÝŒxÐ(¨(Ñ3Ô3ð Ý ðL¨hð Lð Lð Lñô ð ð "×)Ò)Ø2 JÐ2Ð2Ð2Ð4mÈ
Ð4mÐ4mÐaiÐ4mÐ4mÐ4mñô ˆIð  
Ñ*¨YÑ6ˆŒ
Øˆ	r   r   )rÀ   rÁ   rb   rV   rÂ   rÃ   rÄ   rÅ   rÆ   rÇ   rÈ   rÉ   rÊ   r   r   s   `````````````` r   Úadd_code_sample_docstringsrå   ¯  s…   øøøøøøøøøøøøøø€ ð Nð Nð Nð Nð Nð Nð Nð Nð Nð Nð Nð Nð Nð Nð Nð Nð Nð Nð` Ðr   c                 ó   ‡ ‡— ˆˆ fd„}|S )Nc                 óþ  •— | j         }|                     d¦  «        }d}|t          |¦  «        k     rNt          j        d||         ¦  «        €3|dz  }|t          |¦  «        k     rt          j        d||         ¦  «        ®3|t          |¦  «        k     rMt          t          ||         ¦  «        ¦  «        }t          ‰‰|¬¦  «        ||<   d                     |¦  «        }nt          d| › d|› �¦  «        ‚|| _         | S )NrG   r   z^\s*Returns?:\s*$rS   )rc   zThe function ze should have an empty 'Return:' or 'Returns:' in its docstring as placeholder, current docstring is:
)	r   r2   r
   rA   rB   rE   ri   r   rZ   )r   râ   rg   rP   r,   rV   rb   s        €€r   r   z6replace_return_docstrings.<locals>.docstring_decorator  s  ø€ Ø”:ˆØ—’˜tÑ$Ô$ˆØˆØ•#�e‘*”*Šnˆn¥¤Ð+?ÀÀqÄÑ!JÔ!JÐ!RØ�‰FˆAð •#�e‘*”*Šnˆn¥¤Ð+?ÀÀqÄÑ!JÔ!JÐ!Rà�s�5‰zŒzŠ>ˆ>Ý� U¨1¤XÑ.Ô.Ñ/Ô/ˆFÝ1°+¸|ÐX^Ð_Ñ_Ô_ˆE�!‰HØ—y’y Ñ'Ô'ˆHˆHåð5 ð 5ð 5Ø*2ð5ð 5ñô ð ð ˆŒ
Øˆ	r   r   )rb   rV   r   s   `` r   Úreplace_return_docstringsrè     s*   øø€ ðð ð ð ð ð ð$ Ðr   c                 ó¬   — t          j        | j        | j        | j        | j        | j        ¬¦  «        }t          j        || ¦  «        }| j	        |_	        |S )zReturns a copy of a function f.)ÚnameÚargdefsÚclosure)
ÚtypesÚFunctionTypeÚ__code__Ú__globals__r[   Ú__defaults__Ú__closure__Ú	functoolsÚupdate_wrapperÚ__kwdefaults__)ÚfÚgs     r   Ú	copy_funcrø   (  sM   € õ 	Ô˜1œ: q¤}¸1¼:ÈqÌ~ÐghÔgtÐuÑuÔu€AÝÔ   AÑ&Ô&€AØÔ'€AÔØ€Hr   )NT)NN)Yr   ró   r   rA   r+   rí   Úcollectionsr   r   r   r<   r?   r_   r^   rE   rQ   ri   rÜ   ÚPT_TOKEN_CLASSIFICATION_SAMPLEÚPT_QUESTION_ANSWERING_SAMPLEÚ!PT_SEQUENCE_CLASSIFICATION_SAMPLEÚPT_MASKED_LM_SAMPLEÚPT_BASE_MODEL_SAMPLEÚPT_MULTIPLE_CHOICE_SAMPLEÚPT_CAUSAL_LM_SAMPLEÚPT_SPEECH_BASE_MODEL_SAMPLEÚPT_SPEECH_CTC_SAMPLEÚPT_SPEECH_SEQ_CLASS_SAMPLEÚPT_SPEECH_FRAME_CLASS_SAMPLEÚPT_SPEECH_XVECTOR_SAMPLEÚPT_VISION_BASE_MODEL_SAMPLEÚPT_VISION_SEQ_CLASS_SAMPLErÛ   Ú TEXT_TO_AUDIO_SPECTROGRAM_SAMPLEÚTEXT_TO_AUDIO_WAVEFORM_SAMPLEÚ!AUDIO_FRAME_CLASSIFICATION_SAMPLEÚAUDIO_XVECTOR_SAMPLEÚIMAGE_TO_TEXT_SAMPLEÚDEPTH_ESTIMATION_SAMPLEÚVIDEO_CLASSIFICATION_SAMPLEÚ!ZERO_SHOT_OBJECT_DETECTION_SAMPLEÚIMAGE_TO_IMAGE_SAMPLEÚIMAGE_FEATURE_EXTRACTION_SAMPLEÚ"DOCUMENT_QUESTION_ANSWERING_SAMPLEÚNEXT_SENTENCE_PREDICTION_SAMPLEÚMULTIPLE_CHOICE_SAMPLEÚPRETRAINING_SAMPLEÚMASK_GENERATION_SAMPLEÚ VISUAL_QUESTION_ANSWERING_SAMPLEÚTEXT_GENERATION_SAMPLEÚIMAGE_CLASSIFICATION_SAMPLEÚIMAGE_SEGMENTATION_SAMPLEÚFILL_MASK_SAMPLEÚOBJECT_DETECTION_SAMPLEÚQUESTION_ANSWERING_SAMPLEÚTEXT2TEXT_GENERATION_SAMPLEÚTEXT_CLASSIFICATION_SAMPLEÚTABLE_QUESTION_ANSWERING_SAMPLEÚTOKEN_CLASSIFICATION_SAMPLEÚAUDIO_CLASSIFICATION_SAMPLEÚ#AUTOMATIC_SPEECH_RECOGNITION_SAMPLEÚ%ZERO_SHOT_IMAGE_CLASSIFICATION_SAMPLEÚ$IMAGE_TEXT_TO_TEXT_GENERATION_SAMPLEÚ#PIPELINE_TASKS_TO_SAMPLE_DOCSTRINGSÚMODELS_TO_PIPELINEÚTF_TOKEN_CLASSIFICATION_SAMPLEÚTF_QUESTION_ANSWERING_SAMPLEÚ!TF_SEQUENCE_CLASSIFICATION_SAMPLEÚTF_MASKED_LM_SAMPLEÚTF_BASE_MODEL_SAMPLEÚTF_MULTIPLE_CHOICE_SAMPLEÚTF_CAUSAL_LM_SAMPLEÚTF_SPEECH_BASE_MODEL_SAMPLEÚTF_SPEECH_CTC_SAMPLEÚTF_VISION_BASE_MODEL_SAMPLEÚTF_VISION_SEQ_CLASS_SAMPLErÙ   Ú FLAX_TOKEN_CLASSIFICATION_SAMPLEÚFLAX_QUESTION_ANSWERING_SAMPLEÚ#FLAX_SEQUENCE_CLASSIFICATION_SAMPLEÚFLAX_MASKED_LM_SAMPLEÚFLAX_BASE_MODEL_SAMPLEÚFLAX_MULTIPLE_CHOICE_SAMPLEÚFLAX_CAUSAL_LM_SAMPLErÚ   r½   rå   rè   rø   r   r   r   ú<module>r:     s9  ððð ð Ð Ð Ð Ø €€€Ø 	€	€	€	Ø €€€Ø €€€Ø #Ð #Ð #Ð #Ð #Ð #ð"ð "ð "ðð ð ð!ð !ð !ðHð ð ðÐ ðÐ ð8ð 8ð 8ðð ð ð42ð 2ð 2ð 2ðjÐ ð"Ð ðB  Ð ðD8%Ð !ðtÐ ð@Ð ð"Ð ð0Ð ð"Ð ð4!Ð ðF!Ð ðH Ð ð:!Ð ðFÐ ð2Ð ð8 @Ø5Ø9Ø/Ø#Ø!Ø%Ø2ØØ5Ø <Ø,Ø2Ø5ðð Ð ð$$Ð  ð$!Ð ð" %AÐ !ð 0Ð ðÐ ð*Ð ðBÐ ð%Ð !ðÐ ð#Ð ð&Ð "ð#Ð ð 3Ð ðÐ ðÐ ð$Ð  ðÐ ð 9Ð ðÐ ðÐ ðÐ ð 9Ð ðÐ ð ?Ð ð#Ð ð =Ð ð 9Ð ð ';Ð #ð)Ð %ð(Ð $ðD '2 kà	$Ð&FÐGØ	!Ð#@ÐAØ	'Ð)LÐMØ	%Ð'HÐIØ	Ð!<Ð=Ø	Ð.Ð/Ø	ÐCÐDØ	Ð.Ð/Ø	$Ð&FÐGØ	Ð4Ð5Ø	Ð!<Ð=Ø	)Ð+PÐQØ	Ð!<Ð=Ø	%Ð'HÐIØ	Ð4Ð5Ø	Ð8Ð9Ø	Ð0Ð1Ø	#Ð%DÐEØ	Ð2Ð3Ø	#Ð%DÐEØ	&Ð(JÐKØ	Ð8Ð9Ø	Ð!<Ð=Ø	#Ð%DÐEØ	Ð2Ð3Ø	Ð :Ð;Ø	Ð!<Ð=Ø	Ð&Ð'Ø	Ð2Ð3Ø	Ð*Ð+ð=ñ!'ô !'Ð #ðJ !�[ð#ð #ð #ñ%ô %Ð ðP"Ð ðB! Ð ðF%Ð !ð>Ð ðBÐ ð"Ð ð.Ð ð Ð ð0"Ð ðHÐ ð,Ð ð2 @Ø5Ø9Ø/Ø#Ø!Ø%Ø2ØØ2Ø5ðð Ð ð$Ð  ð "Ð ð$'Ð #ð Ð ð Ð ð Ð ð(Ð ð$ BØ7Ø;Ø1Ø%Ø'Ø#ðð Ð ðð ð ð  ØØØØ	ØØØØØØØØð`ð `ð `ð `ð `ðFð ð ð ð,ð ð ð ð r   