o
    Eôj9¥  ã                   @   sˆ  d Z ddlZddlZddlZddlZddlZdd„ Zdd„ Zdd„ Zd	d
„ Z	dZ
dZdd„ Zdd„ ZdBd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 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)d.œZ*d/Z+d0Z,d/Z-d1Z.d2Z/d3Z0d4Z1e-e,e+e0e.e/e1d5œZ2d6d7„ Z3ddddd8d9d:ddddddd;œd<d=„Z4dCd>d?„Z5d@dA„ Z6dS )Dz3
Doc utilities: Utilities related to documentation
é    Nc                 C   s@   t  | ¡rdS t  | ¡}| ¡ d }t|ƒt| ¡ ƒ }d| 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_lineZfunction_def_level© r   úi/var/www/html/academy/tools/voices/clone/cosy-venv/lib/python3.10/site-packages/transformers/utils/doc.pyÚget_docstring_indentation_level   s   

r   c                     ó   ‡ fdd„}|S )Nc                    s$   d  ˆ ¡| jd ur| jnd | _| S ©NÚ )ÚjoinÚ__doc__©Úfn©Údocstrr   r   Údocstring_decorator%   ó    z1add_start_docstrings.<locals>.docstring_decoratorr   ©r   r   r   r   r   Úadd_start_docstrings$   ó   r   c                     r   )Nc                    sÚ   d| j  d¡d › d�}d|› d�}t| ƒ‰ | jd ur| jnd}ztdd	„ | ¡ D ƒƒ}t|ƒt| ¡ ƒ }W n tyB   ˆ }Y nw ˆ}|d
ˆ  kr_‡ fdd„ˆD ƒ}t	 
t	 |¡dˆ  ¡}d |¡| }|| | _| 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                 s   s    � | ]}|  ¡ d kr|V  qdS )r   N)Ústrip©Ú.0Úliner   r   r   Ú	<genexpr>=   s   € zUadd_start_docstrings_to_model_forward.<locals>.docstring_decorator.<locals>.<genexpr>r   c                    s"   g | ]}t  t  |¡d ˆ  ¡‘qS )ú )ÚtextwrapÚindentÚdedent)r    Údoc©Zcorrect_indentationr   r   Ú
<listcomp>F   s   " zVadd_start_docstrings_to_model_forward.<locals>.docstring_decorator.<locals>.<listcomp>r#   )Ú__qualname__Úsplitr   r   Únextr   r   r   ÚStopIterationr$   r%   r&   r   )r   Ú
class_nameÚintroZcurrent_docZfirst_non_emptyZdoc_indentationÚdocsÚ	docstringr   r(   r   r   -   s"   ÿ
zBadd_start_docstrings_to_model_forward.<locals>.docstring_decoratorr   r   r   r   r   Ú%add_start_docstrings_to_model_forward,   s    r2   c                     r   )Nc                    s$   | j d ur| j ndd ˆ ¡ | _ | S r   )r   r   r   r   r   r   r   Q   r   z/add_end_docstrings.<locals>.docstring_decoratorr   r   r   r   r   Úadd_end_docstringsP   r   r3   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                 C   s$   t  d| ¡}|du rdS | ¡ d S )z.Returns the indentation in the first line of tz^(\s*)\SNr   r   )ÚreÚsearchÚgroups)Útr5   r   r   r   Ú_get_indentj   s   r8   c                 C   sÆ   t | ƒ}g }d}|  d¡D ](}t |ƒ|kr*t|ƒdkr$| |dd… ¡ |› d�}q||dd… › d�7 }q| |dd… ¡ tt|ƒƒD ]}t dd|| ¡||< t d	d
|| ¡||< qEd |¡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)r8   r+   r   ÚappendÚranger4   Úsubr   )Zoutput_args_docr%   ÚblocksZcurrent_blockr!   Úir   r   r   Ú_convert_output_args_docp   s   
rA   c                    sX  | j }| d¡}d}|t|ƒk r.t d|| ¡du r.|d7 }|t|ƒk r.t d|| ¡du s|t|ƒk rDd ||d d… ¡}t|ƒ}n	td| j› d�ƒ‚| j	› d| j› �}| j 
d	¡r^tnt}|j||d
�}|| }	|durª|	 d¡}d}t|| ƒdkrŠ|d7 }t|| ƒdks~tt|| ƒƒ}
|
|k rªd||
  ‰ ‡ fdd„|D ƒ}d |¡}	|	S )zH
    Prepares the return part of the docstring using `output_type`.
    r9   r   z^\s*(Args|Parameters):\s*$Né   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_classr#   c                    s(   g | ]}t |ƒd krˆ › |› �n|‘qS )r   )r   r   ©Zto_addr   r   r)   ¯   s   ( z._prepare_output_docstrings.<locals>.<listcomp>)r   r+   r   r4   r5   r   rA   Ú
ValueErrorÚ__name__Ú
__module__Ú
startswithÚTF_RETURN_INTRODUCTIONÚPT_RETURN_INTRODUCTIONÚformatr8   )Úoutput_typerE   Ú
min_indentZoutput_docstringÚlinesr@   Zparams_docstringrD   r/   Úresultr%   r   rF   r   Ú_prepare_output_docstringsŠ   s8   
  ÿ
ÿ
ÿ
rR   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
    ```
aY  
    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", trust_remote_code=True)
    >>> 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}
    ```
au  
    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", trust_remote_code=True)
    >>> 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", trust_remote_code=True)
    >>> 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", trust_remote_code=True)
    >>> 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", trust_remote_code=True)
    >>> 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", trust_remote_code=True)
    >>> 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", trust_remote_code=True)
    >>> 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ÚImageClassificationaI  
    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", trust_remote_code=True)
    >>> 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}
    ```
aw  
    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", trust_remote_code=True)
    >>> 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}
    ```
aq  
    Example:

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

    >>> dataset = load_dataset("huggingface/cats-image", trust_remote_code=True)
    >>> 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", trust_remote_code=True)
    >>> 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}
    ```
)rS   rT   rU   rV   rW   rX   rY   rZ   r[   r_   r`   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]
    ```
)rS   rT   rU   rV   rW   rY   rX   c                 K   sB   |  ¡ D ]\}}|durqd| d }t d|› d�d| ¡} q| 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\nr9   )Úitemsr4   r>   )r1   ÚkwargsÚkeyÚvalueZdoc_keyr   r   r   Úfilter_outputs_from_example5  s   rg   z[MASK]é   é   )Úprocessor_classÚ
checkpointrN   rE   ÚmaskÚqa_target_start_indexÚqa_target_end_indexÚ	model_clsÚmodalityÚexpected_outputÚexpected_lossÚreal_checkpointÚrevisionc                    s*   ‡ ‡‡‡‡‡‡‡‡‡	‡
‡‡‡fdd„}|S )Nc                    sf  ˆd u r| 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 rEˆdkrE|d
 }n”d	|v rN|d	 }n‹d|v rW|d }n‚d|v r`|d }nyd|v ri|d }npd|v sq|dv rv|d }ncd|v s~d|v rƒ|d }nVd|v rŒ|d }nMd|v r•|d }nDd|v r¢ˆdkr¢|d }n7d|v r¯ˆdkr¯|d }n*d|v r¼ˆdkr¼|d }nd|v sÄd|v rÉ|d }nd|v rÒ|d }ntd|› �ƒ‚t|ˆˆd�}ˆd urèt| }| jpìd d  	ˆ¡ }ˆd u rød nt
ˆˆƒ}|jd'i |¤Ž}ˆd u�r*t d!ˆ¡�rtd"ˆ› d#�ƒ‚| d$ˆ › d%�d$ˆ › d&ˆ› d%�¡}|| | | _| S )(Nr   r   r;   rC   r   ZFlaxz{true})Úmodel_classrj   rk   rl   rm   rn   rq   rr   rs   Zfake_checkpointÚtruerS   r\   ÚaudiorT   rU   rV   rW   )ÚFlaubertWithLMHeadModelÚXLMWithLMHeadModelrX   ZCausalLMr[   r]   ZXVectorr^   ÚModelrZ   Úvisionr_   ÚEncoderrY   r`   z#Docstring can't be built for model )rq   rr   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   )r*   r+   ÚTF_SAMPLE_DOCSTRINGSÚFLAX_SAMPLE_DOCSTRINGSÚPT_SAMPLE_DOCSTRINGSrG   rg   ÚFAKE_MODEL_DISCLAIMERr   r   rR   rM   r4   ÚmatchÚreplace)r   ru   Zsample_docstringsZ
doc_kwargsZcode_sampleÚfunc_docZ
output_docZ	built_doc©rk   rE   r   rr   rq   rl   rp   ro   rN   rj   rn   rm   rs   rt   r   r   r   S  s‚   õ













ÿ

ÿÿz7add_code_sample_docstrings.<locals>.docstring_decoratorr   )rj   rk   rN   rE   rl   rm   rn   ro   rp   rq   rr   rs   rt   r   r   r   r„   r   Úadd_code_sample_docstringsC  s   &Pr…   c                    s   ‡ ‡fdd„}|S )Nc                    s´   | j }| d¡}d}|t|ƒk r.t d|| ¡d u r.|d7 }|t|ƒk r.t d|| ¡d u s|t|ƒk rKtt|| ƒƒ}tˆˆ |d�||< d |¡}n
td| › d|› �ƒ‚|| _ | S )Nr9   r   z^\s*Returns?:\s*$rB   )rO   zThe function ze should have an empty 'Return:' or 'Returns:' in its docstring as placeholder, current docstring is:
)	r   r+   r   r4   r5   r8   rR   r   rG   )r   rƒ   rP   r@   r%   ©rE   rN   r   r   r   §  s"   
  ÿÿÿz6replace_return_docstrings.<locals>.docstring_decoratorr   )rN   rE   r   r   r†   r   Úreplace_return_docstrings¦  s   r‡   c                 C   s6   t j| j| j| j| j| jd�}t || ¡}| j	|_	|S )zReturns a copy of a function f.)ÚnameZargdefsÚclosure)
ÚtypesÚFunctionTypeÚ__code__Ú__globals__rH   Ú__defaults__Ú__closure__Ú	functoolsÚupdate_wrapperÚ__kwdefaults__)ÚfÚgr   r   r   Ú	copy_func¼  s   r•   )N)NN)7r   r�   r   r4   r$   rŠ   r   r   r2   r3   rL   rK   r8   rA   rR   r€   ZPT_TOKEN_CLASSIFICATION_SAMPLEZPT_QUESTION_ANSWERING_SAMPLEZ!PT_SEQUENCE_CLASSIFICATION_SAMPLEZPT_MASKED_LM_SAMPLEZPT_BASE_MODEL_SAMPLEZPT_MULTIPLE_CHOICE_SAMPLEZPT_CAUSAL_LM_SAMPLEZPT_SPEECH_BASE_MODEL_SAMPLEZPT_SPEECH_CTC_SAMPLEZPT_SPEECH_SEQ_CLASS_SAMPLEZPT_SPEECH_FRAME_CLASS_SAMPLEZPT_SPEECH_XVECTOR_SAMPLEZPT_VISION_BASE_MODEL_SAMPLEZPT_VISION_SEQ_CLASS_SAMPLEr   ZTF_TOKEN_CLASSIFICATION_SAMPLEZTF_QUESTION_ANSWERING_SAMPLEZ!TF_SEQUENCE_CLASSIFICATION_SAMPLEZTF_MASKED_LM_SAMPLEZTF_BASE_MODEL_SAMPLEZTF_MULTIPLE_CHOICE_SAMPLEZTF_CAUSAL_LM_SAMPLEZTF_SPEECH_BASE_MODEL_SAMPLEZTF_SPEECH_CTC_SAMPLEZTF_VISION_BASE_MODEL_SAMPLEZTF_VISION_SEQ_CLASS_SAMPLEr}   Z FLAX_TOKEN_CLASSIFICATION_SAMPLEZFLAX_QUESTION_ANSWERING_SAMPLEZ#FLAX_SEQUENCE_CLASSIFICATION_SAMPLEZFLAX_MASKED_LM_SAMPLEZFLAX_BASE_MODEL_SAMPLEZFLAX_MULTIPLE_CHOICE_SAMPLEZFLAX_CAUSAL_LM_SAMPLEr~   rg   r…   r‡   r•   r   r   r   r   Ú<module>   sÈ   $		
+!": #$#ò!#!$õùò
c