Doc styler examples (#14953)

* Fix bad examples

* Add black formatting to style_doc

* Use first nonempty line

* Put it at the right place

* Don't add spaces to empty lines

* Better templates

* Deal with triple quotes in docstrings

* Result of style_doc

* Enable mdx treatment and fix code examples in MDXs

* Result of doc styler on doc source files

* Last fixes

* Break copy from

src/transformers/generation_tf_utils.py

@@ -488,40 +488,60 @@ class TFGenerationMixin:
         Examples:
 
         ```python
-        tokenizer = AutoTokenizer.from_pretrained('distilgpt2')   # Initialize tokenizer
-        model = TFAutoModelWithLMHead.from_pretrained('distilgpt2')    # Download model and configuration from huggingface.co and cache.
+        tokenizer = AutoTokenizer.from_pretrained("distilgpt2")  # Initialize tokenizer
+        model = TFAutoModelWithLMHead.from_pretrained(
+            "distilgpt2"
+        )  # Download model and configuration from huggingface.co and cache.
         outputs = model.generate(max_length=40)  # do greedy decoding
-        print(f'Generated: {tokenizer.decode(outputs[0], skip_special_tokens=True)}')
-
-        tokenizer = AutoTokenizer.from_pretrained('openai-gpt')   # Initialize tokenizer
-        model = TFAutoModelWithLMHead.from_pretrained('openai-gpt')    # Download model and configuration from huggingface.co and cache.
-        input_context = 'The dog'
-        input_ids = tokenizer.encode(input_context, return_tensors='tf')  # encode input context
-        outputs = model.generate(input_ids=input_ids, num_beams=5, num_return_sequences=3, temperature=1.5)  # generate 3 independent sequences using beam search decoding (5 beams) with sampling from initial context 'The dog'
+        print(f"Generated: {tokenizer.decode(outputs[0], skip_special_tokens=True)}")
+
+        tokenizer = AutoTokenizer.from_pretrained("openai-gpt")  # Initialize tokenizer
+        model = TFAutoModelWithLMHead.from_pretrained(
+            "openai-gpt"
+        )  # Download model and configuration from huggingface.co and cache.
+        input_context = "The dog"
+        input_ids = tokenizer.encode(input_context, return_tensors="tf")  # encode input context
+        outputs = model.generate(
+            input_ids=input_ids, num_beams=5, num_return_sequences=3, temperature=1.5
+        )  # generate 3 independent sequences using beam search decoding (5 beams) with sampling from initial context 'The dog'
         for i in range(3):  #  3 output sequences were generated
-            print(f'Generated {i}: {tokenizer.decode(outputs[i], skip_special_tokens=True)}')
-
-        tokenizer = AutoTokenizer.from_pretrained('distilgpt2')   # Initialize tokenizer
-        model = TFAutoModelWithLMHead.from_pretrained('distilgpt2')    # Download model and configuration from huggingface.co and cache.
-        input_context = 'The dog'
-        input_ids = tokenizer.encode(input_context, return_tensors='tf')  # encode input context
-        outputs = model.generate(input_ids=input_ids, max_length=40, temperature=0.7, num_return_sequences=3, do_sample=True)  # generate 3 candidates using sampling
+            print(f"Generated {i}: {tokenizer.decode(outputs[i], skip_special_tokens=True)}")
+
+        tokenizer = AutoTokenizer.from_pretrained("distilgpt2")  # Initialize tokenizer
+        model = TFAutoModelWithLMHead.from_pretrained(
+            "distilgpt2"
+        )  # Download model and configuration from huggingface.co and cache.
+        input_context = "The dog"
+        input_ids = tokenizer.encode(input_context, return_tensors="tf")  # encode input context
+        outputs = model.generate(
+            input_ids=input_ids, max_length=40, temperature=0.7, num_return_sequences=3, do_sample=True
+        )  # generate 3 candidates using sampling
         for i in range(3):  #  3 output sequences were generated
-            print(f'Generated {i}: {tokenizer.decode(outputs[i], skip_special_tokens=True)}')
-
-        tokenizer = AutoTokenizer.from_pretrained('ctrl')   # Initialize tokenizer
-        model = TFAutoModelWithLMHead.from_pretrained('ctrl')    # Download model and configuration from huggingface.co and cache.
-        input_context = 'Legal My neighbor is'  # "Legal" is one of the control codes for ctrl
-        input_ids = tokenizer.encode(input_context, return_tensors='tf')  # encode input context
-        outputs = model.generate(input_ids=input_ids, max_length=50, temperature=0.7, repetition_penalty=1.2)  # generate sequences
-        print(f'Generated: {tokenizer.decode(outputs[0], skip_special_tokens=True)}')
-
-        tokenizer = AutoTokenizer.from_pretrained('gpt2')   # Initialize tokenizer
-        model = TFAutoModelWithLMHead.from_pretrained('gpt2')    # Download model and configuration from huggingface.co and cache.
-        input_context = 'My cute dog'
-        bad_words_ids = [tokenizer.encode(bad_word, add_prefix_space=True) for bad_word in ['idiot', 'stupid', 'shut up']]
-        input_ids = tokenizer.encode(input_context, return_tensors='tf')  # encode input context
-        outputs = model.generate(input_ids=input_ids, max_length=100, do_sample=True, bad_words_ids=bad_words_ids)  # generate sequences without allowing bad_words to be generated
+            print(f"Generated {i}: {tokenizer.decode(outputs[i], skip_special_tokens=True)}")
+
+        tokenizer = AutoTokenizer.from_pretrained("ctrl")  # Initialize tokenizer
+        model = TFAutoModelWithLMHead.from_pretrained(
+            "ctrl"
+        )  # Download model and configuration from huggingface.co and cache.
+        input_context = "Legal My neighbor is"  # "Legal" is one of the control codes for ctrl
+        input_ids = tokenizer.encode(input_context, return_tensors="tf")  # encode input context
+        outputs = model.generate(
+            input_ids=input_ids, max_length=50, temperature=0.7, repetition_penalty=1.2
+        )  # generate sequences
+        print(f"Generated: {tokenizer.decode(outputs[0], skip_special_tokens=True)}")
+
+        tokenizer = AutoTokenizer.from_pretrained("gpt2")  # Initialize tokenizer
+        model = TFAutoModelWithLMHead.from_pretrained(
+            "gpt2"
+        )  # Download model and configuration from huggingface.co and cache.
+        input_context = "My cute dog"
+        bad_words_ids = [
+            tokenizer.encode(bad_word, add_prefix_space=True) for bad_word in ["idiot", "stupid", "shut up"]
+        ]
+        input_ids = tokenizer.encode(input_context, return_tensors="tf")  # encode input context
+        outputs = model.generate(
+            input_ids=input_ids, max_length=100, do_sample=True, bad_words_ids=bad_words_ids
+        )  # generate sequences without allowing bad_words to be generated
         ```"""
 
         # We cannot generate if the model does not have a LM head

src/transformers/generation_utils.py

@@ -1345,9 +1345,11 @@ class GenerationMixin:
         >>> input_ids = tokenizer(input_prompt, return_tensors="pt").input_ids
 
         >>> # instantiate logits processors
-        >>> logits_processor = LogitsProcessorList([
+        >>> logits_processor = LogitsProcessorList(
+        ...     [
         ...         MinLengthLogitsProcessor(15, eos_token_id=model.config.eos_token_id),
-        ... ])
+        ...     ]
+        ... )
 
         >>> outputs = model.greedy_search(input_ids, logits_processor=logits_processor)
 
@@ -1574,14 +1576,18 @@ class GenerationMixin:
         >>> input_ids = tokenizer(input_prompt, return_tensors="pt").input_ids
 
         >>> # instantiate logits processors
-        >>> logits_processor = LogitsProcessorList([
+        >>> logits_processor = LogitsProcessorList(
+        ...     [
         ...         MinLengthLogitsProcessor(15, eos_token_id=model.config.eos_token_id),
-        ... ])
+        ...     ]
+        ... )
         >>> # instantiate logits processors
-        >>> logits_warper = LogitsProcessorList([
+        >>> logits_warper = LogitsProcessorList(
+        ...     [
         ...         TopKLogitsWarper(50),
         ...         TemperatureLogitsWarper(0.7),
-        ... ])
+        ...     ]
+        ... )
 
         >>> outputs = model.sample(input_ids, logits_processor=logits_processor, logits_warper=logits_warper)
 
@@ -1818,7 +1824,9 @@ class GenerationMixin:
 
         >>> # add encoder_outputs to model keyword arguments
         >>> model_kwargs = {
-        ...     "encoder_outputs": model.get_encoder()(encoder_input_ids.repeat_interleave(num_beams, dim=0), return_dict=True)
+        ...     "encoder_outputs": model.get_encoder()(
+        ...         encoder_input_ids.repeat_interleave(num_beams, dim=0), return_dict=True
+        ...     )
         ... }
 
         >>> # instantiate beam scorer
@@ -1829,9 +1837,11 @@ class GenerationMixin:
         ... )
 
         >>> # instantiate logits processors
-        >>> logits_processor = LogitsProcessorList([
+        >>> logits_processor = LogitsProcessorList(
+        ...     [
         ...         MinLengthLogitsProcessor(5, eos_token_id=model.config.eos_token_id),
-        ... ])
+        ...     ]
+        ... )
 
         >>> outputs = model.beam_search(input_ids, beam_scorer, logits_processor=logits_processor, **model_kwargs)
 
@@ -2112,7 +2122,9 @@ class GenerationMixin:
 
         >>> # add encoder_outputs to model keyword arguments
         >>> model_kwargs = {
-        ...     "encoder_outputs": model.get_encoder()(encoder_input_ids.repeat_interleave(num_beams, dim=0), return_dict=True)
+        ...     "encoder_outputs": model.get_encoder()(
+        ...         encoder_input_ids.repeat_interleave(num_beams, dim=0), return_dict=True
+        ...     )
         ... }
 
         >>> # instantiate beam scorer
@@ -2124,14 +2136,16 @@ class GenerationMixin:
         ... )
 
         >>> # instantiate logits processors
-        >>> logits_processor = LogitsProcessorList([
-        ...     MinLengthLogitsProcessor(5, eos_token_id=model.config.eos_token_id)
-        ... ])
+        >>> logits_processor = LogitsProcessorList(
+        ...     [MinLengthLogitsProcessor(5, eos_token_id=model.config.eos_token_id)]
+        ... )
         >>> # instantiate logits processors
-        >>> logits_warper = LogitsProcessorList([
+        >>> logits_warper = LogitsProcessorList(
+        ...     [
         ...         TopKLogitsWarper(50),
         ...         TemperatureLogitsWarper(0.7),
-        ... ])
+        ...     ]
+        ... )
 
         >>> outputs = model.beam_sample(
         ...     input_ids, beam_scorer, logits_processor=logits_processor, logits_warper=logits_warper, **model_kwargs
@@ -2408,7 +2422,9 @@ class GenerationMixin:
 
         >>> # add encoder_outputs to model keyword arguments
         >>> model_kwargs = {
-        ...     "encoder_outputs": model.get_encoder()(encoder_input_ids.repeat_interleave(num_beams, dim=0), return_dict=True)
+        ...     "encoder_outputs": model.get_encoder()(
+        ...         encoder_input_ids.repeat_interleave(num_beams, dim=0), return_dict=True
+        ...     )
         ... }
 
         >>> # instantiate beam scorer
@@ -2417,16 +2433,20 @@ class GenerationMixin:
         ...     max_length=model.config.max_length,
         ...     num_beams=num_beams,
         ...     device=model.device,
-        ...     num_beam_groups=3
+        ...     num_beam_groups=3,
         ... )
 
         >>> # instantiate logits processors
-        >>> logits_processor = LogitsProcessorList([
+        >>> logits_processor = LogitsProcessorList(
+        ...     [
         ...         HammingDiversityLogitsProcessor(5.5, num_beams=6, num_beam_groups=3),
         ...         MinLengthLogitsProcessor(5, eos_token_id=model.config.eos_token_id),
-        ... ])
+        ...     ]
+        ... )
 
-        >>> outputs = model.group_beam_search(input_ids, beam_scorer, logits_processor=logits_processor, **model_kwargs)
+        >>> outputs = model.group_beam_search(
+        ...     input_ids, beam_scorer, logits_processor=logits_processor, **model_kwargs
+        ... )
 
         >>> print("Generated:", tokenizer.batch_decode(outputs, skip_special_tokens=True))
         ```"""

src/transformers/keras_callbacks.py

@@ -32,10 +32,12 @@ class KerasMetricCallback(Callback):
 
     ```py
     from datasets import load_metric
+
     rouge_metric = load_metric("rouge")
 
+
     def rouge_fn(predictions, labels):
-        decoded_predictions = tokenizer.batch_decode(predictions, skip_special_tokens=True))
+        decoded_predictions = tokenizer.batch_decode(predictions, skip_special_tokens=True)
         decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True)
         result = rouge_metric.compute(predictions=decoded_predictions, references=decoded_labels)
         return {key: value.mid.fmeasure * 100 for key, value in result.items()}

src/transformers/modelcard.py

@@ -168,10 +168,14 @@ class ModelCard:
         Examples:
 
         ```python
-        modelcard = ModelCard.from_pretrained('bert-base-uncased')    # Download model card from huggingface.co and cache.
-        modelcard = ModelCard.from_pretrained('./test/saved_model/')  # E.g. model card was saved using *save_pretrained('./test/saved_model/')*
-        modelcard = ModelCard.from_pretrained('./test/saved_model/modelcard.json')
-        modelcard = ModelCard.from_pretrained('bert-base-uncased', output_attentions=True, foo=False)
+        modelcard = ModelCard.from_pretrained(
+            "bert-base-uncased"
+        )  # Download model card from huggingface.co and cache.
+        modelcard = ModelCard.from_pretrained(
+            "./test/saved_model/"
+        )  # E.g. model card was saved using *save_pretrained('./test/saved_model/')*
+        modelcard = ModelCard.from_pretrained("./test/saved_model/modelcard.json")
+        modelcard = ModelCard.from_pretrained("bert-base-uncased", output_attentions=True, foo=False)
         ```"""
         # This imports every model so let's do it dynamically here.
         from transformers.models.auto.configuration_auto import ALL_PRETRAINED_CONFIG_ARCHIVE_MAP

src/transformers/modeling_flax_utils.py

@@ -200,16 +200,21 @@ class FlaxPreTrainedModel(PushToHubMixin, FlaxGenerationMixin):
 
         ```python
         >>> from transformers import FlaxBertModel
+
         >>> # load model
-        >>> model = FlaxBertModel.from_pretrained('bert-base-cased')
+        >>> model = FlaxBertModel.from_pretrained("bert-base-cased")
         >>> # By default, the model parameters will be in fp32 precision, to cast these to bfloat16 precision
         >>> model.params = model.to_bf16(model.params)
         >>> # If you want don't want to cast certain parameters (for example layer norm bias and scale)
         >>> # then pass the mask as follows
         >>> from flax import traverse_util
-        >>> model = FlaxBertModel.from_pretrained('bert-base-cased')
+
+        >>> model = FlaxBertModel.from_pretrained("bert-base-cased")
         >>> flat_params = traverse_util.flatten_dict(model.params)
-        >>> mask = {path: (path[-2] != ("LayerNorm", "bias") and path[-2:] != ("LayerNorm", "scale")) for path in flat_params}
+        >>> mask = {
+        ...     path: (path[-2] != ("LayerNorm", "bias") and path[-2:] != ("LayerNorm", "scale"))
+        ...     for path in flat_params
+        ... }
         >>> mask = traverse_util.unflatten_dict(mask)
         >>> model.params = model.to_bf16(model.params, mask)
         ```"""
@@ -231,8 +236,9 @@ class FlaxPreTrainedModel(PushToHubMixin, FlaxGenerationMixin):
 
         ```python
         >>> from transformers import FlaxBertModel
+
         >>> # Download model and configuration from huggingface.co
-        >>> model = FlaxBertModel.from_pretrained('bert-base-cased')
+        >>> model = FlaxBertModel.from_pretrained("bert-base-cased")
         >>> # By default, the model params will be in fp32, to illustrate the use of this method,
         >>> # we'll first cast to fp16 and back to fp32
         >>> model.params = model.to_f16(model.params)
@@ -260,16 +266,21 @@ class FlaxPreTrainedModel(PushToHubMixin, FlaxGenerationMixin):
 
         ```python
         >>> from transformers import FlaxBertModel
+
         >>> # load model
-        >>> model = FlaxBertModel.from_pretrained('bert-base-cased')
+        >>> model = FlaxBertModel.from_pretrained("bert-base-cased")
         >>> # By default, the model params will be in fp32, to cast these to float16
         >>> model.params = model.to_fp16(model.params)
         >>> # If you want don't want to cast certain parameters (for example layer norm bias and scale)
         >>> # then pass the mask as follows
         >>> from flax import traverse_util
-        >>> model = FlaxBertModel.from_pretrained('bert-base-cased')
+
+        >>> model = FlaxBertModel.from_pretrained("bert-base-cased")
         >>> flat_params = traverse_util.flatten_dict(model.params)
-        >>> mask = {path: (path[-2] != ("LayerNorm", "bias") and path[-2:] != ("LayerNorm", "scale")) for path in flat_params}
+        >>> mask = {
+        ...     path: (path[-2] != ("LayerNorm", "bias") and path[-2:] != ("LayerNorm", "scale"))
+        ...     for path in flat_params
+        ... }
         >>> mask = traverse_util.unflatten_dict(mask)
         >>> model.params = model.to_fp16(model.params, mask)
         ```"""
@@ -377,13 +388,14 @@ class FlaxPreTrainedModel(PushToHubMixin, FlaxGenerationMixin):
 
         ```python
         >>> from transformers import BertConfig, FlaxBertModel
+
         >>> # Download model and configuration from huggingface.co and cache.
-        >>> model = FlaxBertModel.from_pretrained('bert-base-cased')
+        >>> model = FlaxBertModel.from_pretrained("bert-base-cased")
         >>> # Model was saved using *save_pretrained('./test/saved_model/')* (for example purposes, not runnable).
-        >>> model = FlaxBertModel.from_pretrained('./test/saved_model/')
+        >>> model = FlaxBertModel.from_pretrained("./test/saved_model/")
         >>> # Loading from a PyTorch checkpoint file instead of a PyTorch model (slower, for example purposes, not runnable).
-        >>> config = BertConfig.from_json_file('./pt_model/config.json')
-        >>> model = FlaxBertModel.from_pretrained('./pt_model/pytorch_model.bin', from_pt=True, config=config)
+        >>> config = BertConfig.from_json_file("./pt_model/config.json")
+        >>> model = FlaxBertModel.from_pretrained("./pt_model/pytorch_model.bin", from_pt=True, config=config)
         ```"""
         config = kwargs.pop("config", None)
         cache_dir = kwargs.pop("cache_dir", None)

src/transformers/modeling_tf_utils.py

@@ -1460,16 +1460,17 @@ class TFPreTrainedModel(tf.keras.Model, TFModelUtilsMixin, TFGenerationMixin, Pu
 
         ```python
         >>> from transformers import BertConfig, TFBertModel
+
         >>> # Download model and configuration from huggingface.co and cache.
-        >>> model = TFBertModel.from_pretrained('bert-base-uncased')
+        >>> model = TFBertModel.from_pretrained("bert-base-uncased")
         >>> # Model was saved using *save_pretrained('./test/saved_model/')* (for example purposes, not runnable).
-        >>> model = TFBertModel.from_pretrained('./test/saved_model/')
+        >>> model = TFBertModel.from_pretrained("./test/saved_model/")
         >>> # Update configuration during loading.
-        >>> model = TFBertModel.from_pretrained('bert-base-uncased', output_attentions=True)
+        >>> model = TFBertModel.from_pretrained("bert-base-uncased", output_attentions=True)
         >>> assert model.config.output_attentions == True
         >>> # Loading from a Pytorch model file instead of a TensorFlow checkpoint (slower, for example purposes, not runnable).
-        >>> config = BertConfig.from_json_file('./pt_model/my_pt_model_config.json')
-        >>> model = TFBertModel.from_pretrained('./pt_model/my_pytorch_model.bin', from_pt=True, config=config)
+        >>> config = BertConfig.from_json_file("./pt_model/my_pt_model_config.json")
+        >>> model = TFBertModel.from_pretrained("./pt_model/my_pytorch_model.bin", from_pt=True, config=config)
         ```"""
         config = kwargs.pop("config", None)
         cache_dir = kwargs.pop("cache_dir", None)

src/transformers/modeling_utils.py

@@ -1211,18 +1211,19 @@ class PreTrainedModel(nn.Module, ModuleUtilsMixin, GenerationMixin, PushToHubMix
 
         ```python
         >>> from transformers import BertConfig, BertModel
+
         >>> # Download model and configuration from huggingface.co and cache.
-        >>> model = BertModel.from_pretrained('bert-base-uncased')
+        >>> model = BertModel.from_pretrained("bert-base-uncased")
         >>> # Model was saved using *save_pretrained('./test/saved_model/')* (for example purposes, not runnable).
-        >>> model = BertModel.from_pretrained('./test/saved_model/')
+        >>> model = BertModel.from_pretrained("./test/saved_model/")
         >>> # Update configuration during loading.
-        >>> model = BertModel.from_pretrained('bert-base-uncased', output_attentions=True)
+        >>> model = BertModel.from_pretrained("bert-base-uncased", output_attentions=True)
         >>> assert model.config.output_attentions == True
         >>> # Loading from a TF checkpoint file instead of a PyTorch model (slower, for example purposes, not runnable).
-        >>> config = BertConfig.from_json_file('./tf_model/my_tf_model_config.json')
-        >>> model = BertModel.from_pretrained('./tf_model/my_tf_checkpoint.ckpt.index', from_tf=True, config=config)
+        >>> config = BertConfig.from_json_file("./tf_model/my_tf_model_config.json")
+        >>> model = BertModel.from_pretrained("./tf_model/my_tf_checkpoint.ckpt.index", from_tf=True, config=config)
         >>> # Loading from a Flax checkpoint file instead of a PyTorch model (slower)
-        >>> model = BertModel.from_pretrained('bert-base-uncased', from_flax=True)
+        >>> model = BertModel.from_pretrained("bert-base-uncased", from_flax=True)
         ```"""
         config = kwargs.pop("config", None)
         state_dict = kwargs.pop("state_dict", None)
@@ -2320,6 +2321,7 @@ def apply_chunking_to_forward(
         hidden_states = self.decoder(hidden_states)
         return hidden_states
 
+
     # implement a chunked forward function
     def forward(self, hidden_states):
         return apply_chunking_to_forward(self.forward_chunk, self.chunk_size_lm_head, self.seq_len_dim, hidden_states)

src/transformers/models/albert/configuration_albert.py

@@ -90,6 +90,7 @@ class AlbertConfig(PretrainedConfig):
 
     ```python
     >>> from transformers import AlbertConfig, AlbertModel
+
     >>> # Initializing an ALBERT-xxlarge style configuration
     >>> albert_xxlarge_configuration = AlbertConfig()
 

src/transformers/models/albert/modeling_albert.py

@@ -802,10 +802,12 @@ class AlbertForPreTraining(AlbertPreTrainedModel):
         >>> from transformers import AlbertTokenizer, AlbertForPreTraining
         >>> import torch
 
-        >>> tokenizer = AlbertTokenizer.from_pretrained('albert-base-v2')
-        >>> model = AlbertForPreTraining.from_pretrained('albert-base-v2')
+        >>> tokenizer = AlbertTokenizer.from_pretrained("albert-base-v2")
+        >>> model = AlbertForPreTraining.from_pretrained("albert-base-v2")
 
-        >>> input_ids = torch.tensor(tokenizer.encode("Hello, my dog is cute", add_special_tokens=True)).unsqueeze(0)  # Batch size 1
+        >>> input_ids = torch.tensor(tokenizer.encode("Hello, my dog is cute", add_special_tokens=True)).unsqueeze(
+        ...     0
+        >>> )  # Batch size 1
         >>> outputs = model(input_ids)
 
         >>> prediction_logits = outputs.prediction_logits

src/transformers/models/albert/modeling_flax_albert.py

@@ -748,8 +748,8 @@ FLAX_ALBERT_FOR_PRETRAINING_DOCSTRING = """
     ```python
     >>> from transformers import AlbertTokenizer, FlaxAlbertForPreTraining
 
-    >>> tokenizer = AlbertTokenizer.from_pretrained('albert-base-v2')
-    >>> model = FlaxAlbertForPreTraining.from_pretrained('albert-base-v2')
+    >>> tokenizer = AlbertTokenizer.from_pretrained("albert-base-v2")
+    >>> model = FlaxAlbertForPreTraining.from_pretrained("albert-base-v2")
 
     >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="np")
     >>> outputs = model(**inputs)

src/transformers/models/albert/modeling_tf_albert.py

@@ -892,10 +892,12 @@ class TFAlbertForPreTraining(TFAlbertPreTrainedModel, TFAlbertPreTrainingLoss):
         >>> import tensorflow as tf
         >>> from transformers import AlbertTokenizer, TFAlbertForPreTraining
 
-        >>> tokenizer = AlbertTokenizer.from_pretrained('albert-base-v2')
-        >>> model = TFAlbertForPreTraining.from_pretrained('albert-base-v2')
+        >>> tokenizer = AlbertTokenizer.from_pretrained("albert-base-v2")
+        >>> model = TFAlbertForPreTraining.from_pretrained("albert-base-v2")
 
-        >>> input_ids = tf.constant(tokenizer.encode("Hello, my dog is cute", add_special_tokens=True))[None, :]  # Batch size 1
+        >>> input_ids = tf.constant(tokenizer.encode("Hello, my dog is cute", add_special_tokens=True))[
+        ...     None, :
+        >>> ]  # Batch size 1
         >>> outputs = model(input_ids)
 
         >>> prediction_logits = outputs.prediction_logits

src/transformers/models/auto/auto_factory.py

@@ -51,8 +51,9 @@ FROM_CONFIG_DOCSTRING = """
 
         ```python
         >>> from transformers import AutoConfig, BaseAutoModelClass
+
         >>> # Download configuration from huggingface.co and cache.
-        >>> config = AutoConfig.from_pretrained('checkpoint_placeholder')
+        >>> config = AutoConfig.from_pretrained("checkpoint_placeholder")
         >>> model = BaseAutoModelClass.from_config(config)
         ```
 """
@@ -147,16 +148,18 @@ FROM_PRETRAINED_TORCH_DOCSTRING = """
         >>> from transformers import AutoConfig, BaseAutoModelClass
 
         >>> # Download model and configuration from huggingface.co and cache.
-        >>> model = BaseAutoModelClass.from_pretrained('checkpoint_placeholder')
+        >>> model = BaseAutoModelClass.from_pretrained("checkpoint_placeholder")
 
         >>> # Update configuration during loading
-        >>> model = BaseAutoModelClass.from_pretrained('checkpoint_placeholder', output_attentions=True)
+        >>> model = BaseAutoModelClass.from_pretrained("checkpoint_placeholder", output_attentions=True)
         >>> model.config.output_attentions
         True
 
         >>> # Loading from a TF checkpoint file instead of a PyTorch model (slower)
-        >>> config = AutoConfig.from_pretrained('./tf_model/shortcut_placeholder_tf_model_config.json')
-        >>> model = BaseAutoModelClass.from_pretrained('./tf_model/shortcut_placeholder_tf_checkpoint.ckpt.index', from_tf=True, config=config)
+        >>> config = AutoConfig.from_pretrained("./tf_model/shortcut_placeholder_tf_model_config.json")
+        >>> model = BaseAutoModelClass.from_pretrained(
+        ...     "./tf_model/shortcut_placeholder_tf_checkpoint.ckpt.index", from_tf=True, config=config
+        ... )
         ```
 """
 
@@ -241,16 +244,18 @@ FROM_PRETRAINED_TF_DOCSTRING = """
         >>> from transformers import AutoConfig, BaseAutoModelClass
 
         >>> # Download model and configuration from huggingface.co and cache.
-        >>> model = BaseAutoModelClass.from_pretrained('checkpoint_placeholder')
+        >>> model = BaseAutoModelClass.from_pretrained("checkpoint_placeholder")
 
         >>> # Update configuration during loading
-        >>> model = BaseAutoModelClass.from_pretrained('checkpoint_placeholder', output_attentions=True)
+        >>> model = BaseAutoModelClass.from_pretrained("checkpoint_placeholder", output_attentions=True)
         >>> model.config.output_attentions
         True
 
         >>> # Loading from a PyTorch checkpoint file instead of a TensorFlow model (slower)
-        >>> config = AutoConfig.from_pretrained('./pt_model/shortcut_placeholder_pt_model_config.json')
-        >>> model = BaseAutoModelClass.from_pretrained('./pt_model/shortcut_placeholder_pytorch_model.bin', from_pt=True, config=config)
+        >>> config = AutoConfig.from_pretrained("./pt_model/shortcut_placeholder_pt_model_config.json")
+        >>> model = BaseAutoModelClass.from_pretrained(
+        ...     "./pt_model/shortcut_placeholder_pytorch_model.bin", from_pt=True, config=config
+        ... )
         ```
 """
 
@@ -335,16 +340,18 @@ FROM_PRETRAINED_FLAX_DOCSTRING = """
         >>> from transformers import AutoConfig, BaseAutoModelClass
 
         >>> # Download model and configuration from huggingface.co and cache.
-        >>> model = BaseAutoModelClass.from_pretrained('checkpoint_placeholder')
+        >>> model = BaseAutoModelClass.from_pretrained("checkpoint_placeholder")
 
         >>> # Update configuration during loading
-        >>> model = BaseAutoModelClass.from_pretrained('checkpoint_placeholder', output_attentions=True)
+        >>> model = BaseAutoModelClass.from_pretrained("checkpoint_placeholder", output_attentions=True)
         >>> model.config.output_attentions
         True
 
         >>> # Loading from a PyTorch checkpoint file instead of a TensorFlow model (slower)
-        >>> config = AutoConfig.from_pretrained('./pt_model/shortcut_placeholder_pt_model_config.json')
-        >>> model = BaseAutoModelClass.from_pretrained('./pt_model/shortcut_placeholder_pytorch_model.bin', from_pt=True, config=config)
+        >>> config = AutoConfig.from_pretrained("./pt_model/shortcut_placeholder_pt_model_config.json")
+        >>> model = BaseAutoModelClass.from_pretrained(
+        ...     "./pt_model/shortcut_placeholder_pytorch_model.bin", from_pt=True, config=config
+        ... )
         ```
 """
 

src/transformers/models/auto/configuration_auto.py

@@ -555,24 +555,28 @@ class AutoConfig:
         >>> from transformers import AutoConfig
 
         >>> # Download configuration from huggingface.co and cache.
-        >>> config = AutoConfig.from_pretrained('bert-base-uncased')
+        >>> config = AutoConfig.from_pretrained("bert-base-uncased")
 
         >>> # Download configuration from huggingface.co (user-uploaded) and cache.
-        >>> config = AutoConfig.from_pretrained('dbmdz/bert-base-german-cased')
+        >>> config = AutoConfig.from_pretrained("dbmdz/bert-base-german-cased")
 
         >>> # If configuration file is in a directory (e.g., was saved using *save_pretrained('./test/saved_model/')*).
-        >>> config = AutoConfig.from_pretrained('./test/bert_saved_model/')
+        >>> config = AutoConfig.from_pretrained("./test/bert_saved_model/")
 
         >>> # Load a specific configuration file.
-        >>> config = AutoConfig.from_pretrained('./test/bert_saved_model/my_configuration.json')
+        >>> config = AutoConfig.from_pretrained("./test/bert_saved_model/my_configuration.json")
 
         >>> # Change some config attributes when loading a pretrained config.
-        >>> config = AutoConfig.from_pretrained('bert-base-uncased', output_attentions=True, foo=False)
+        >>> config = AutoConfig.from_pretrained("bert-base-uncased", output_attentions=True, foo=False)
         >>> config.output_attentions
         True
-        >>> config, unused_kwargs = AutoConfig.from_pretrained('bert-base-uncased', output_attentions=True, foo=False, return_unused_kwargs=True)
+
+        >>> config, unused_kwargs = AutoConfig.from_pretrained(
+        ...     "bert-base-uncased", output_attentions=True, foo=False, return_unused_kwargs=True
+        ... )
         >>> config.output_attentions
         True
+
         >>> config.unused_kwargs
         {'foo': False}
         ```"""

src/transformers/models/auto/feature_extraction_auto.py

@@ -141,10 +141,10 @@ class AutoFeatureExtractor:
         >>> from transformers import AutoFeatureExtractor
 
         >>> # Download feature extractor from huggingface.co and cache.
-        >>> feature_extractor = AutoFeatureExtractor.from_pretrained('facebook/wav2vec2-base-960h')
+        >>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base-960h")
 
         >>> # If feature extractor files are in a directory (e.g. feature extractor was saved using *save_pretrained('./test/saved_model/')*)
-        >>> feature_extractor = AutoFeatureExtractor.from_pretrained('./test/saved_model/')
+        >>> feature_extractor = AutoFeatureExtractor.from_pretrained("./test/saved_model/")
         ```"""
         config = kwargs.pop("config", None)
         kwargs["_from_auto"] = True

src/transformers/models/auto/processing_auto.py

@@ -134,10 +134,10 @@ class AutoProcessor:
         >>> from transformers import AutoProcessor
 
         >>> # Download processor from huggingface.co and cache.
-        >>> processor = AutoProcessor.from_pretrained('facebook/wav2vec2-base-960h')
+        >>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h")
 
         >>> # If processor files are in a directory (e.g. processor was saved using *save_pretrained('./test/saved_model/')*)
-        >>> processor = AutoProcessor.from_pretrained('./test/saved_model/')
+        >>> processor = AutoProcessor.from_pretrained("./test/saved_model/")
         ```"""
         config = kwargs.pop("config", None)
         kwargs["_from_auto"] = True

src/transformers/models/auto/tokenization_auto.py

@@ -451,13 +451,13 @@ class AutoTokenizer:
         >>> from transformers import AutoTokenizer
 
         >>> # Download vocabulary from huggingface.co and cache.
-        >>> tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')
+        >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
 
         >>> # Download vocabulary from huggingface.co (user-uploaded) and cache.
-        >>> tokenizer = AutoTokenizer.from_pretrained('dbmdz/bert-base-german-cased')
+        >>> tokenizer = AutoTokenizer.from_pretrained("dbmdz/bert-base-german-cased")
 
         >>> # If vocabulary files are in a directory (e.g. tokenizer was saved using *save_pretrained('./test/saved_model/')*)
-        >>> tokenizer = AutoTokenizer.from_pretrained('./test/bert_saved_model/')
+        >>> tokenizer = AutoTokenizer.from_pretrained("./test/bert_saved_model/")
         ```"""
         config = kwargs.pop("config", None)
         kwargs["_from_auto"] = True

src/transformers/models/bart/modeling_bart.py

@@ -1779,8 +1779,8 @@ class BartForCausalLM(BartPretrainedModel):
         ```python
         >>> from transformers import BartTokenizer, BartForCausalLM
 
-        >>> tokenizer = BartTokenizer.from_pretrained('facebook/bart-large')
-        >>> model = BartForCausalLM.from_pretrained('facebook/bart-large', add_cross_attention=False)
+        >>> tokenizer = BartTokenizer.from_pretrained("facebook/bart-large")
+        >>> model = BartForCausalLM.from_pretrained("facebook/bart-large", add_cross_attention=False)
         >>> assert model.config.is_decoder, f"{model.__class__} has to be configured as a decoder."
         >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
         >>> outputs = model(**inputs)

src/transformers/models/bart/modeling_flax_bart.py

@@ -1021,11 +1021,11 @@ class FlaxBartPreTrainedModel(FlaxPreTrainedModel):
         ```python
         >>> from transformers import BartTokenizer, FlaxBartForConditionalGeneration
 
-        >>> model = FlaxBartForConditionalGeneration.from_pretrained('facebook/bart-large-cnn')
-        >>> tokenizer = BartTokenizer.from_pretrained('facebook/bart-large-cnn')
+        >>> model = FlaxBartForConditionalGeneration.from_pretrained("facebook/bart-large-cnn")
+        >>> tokenizer = BartTokenizer.from_pretrained("facebook/bart-large-cnn")
 
         >>> text = "My friends are cool but they eat too many carbs."
-        >>> inputs = tokenizer(text, max_length=1024, return_tensors='jax')
+        >>> inputs = tokenizer(text, max_length=1024, return_tensors="jax")
         >>> encoder_outputs = model.encode(**inputs)
         ```"""
         output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
@@ -1087,11 +1087,11 @@ class FlaxBartPreTrainedModel(FlaxPreTrainedModel):
         ```python
         >>> from transformers import BartTokenizer, FlaxBartForConditionalGeneration
 
-        >>> model = FlaxBartForConditionalGeneration.from_pretrained('facebook/bart-large-cnn')
-        >>> tokenizer = BartTokenizer.from_pretrained('facebook/bart-large-cnn')
+        >>> model = FlaxBartForConditionalGeneration.from_pretrained("facebook/bart-large-cnn")
+        >>> tokenizer = BartTokenizer.from_pretrained("facebook/bart-large-cnn")
 
         >>> text = "My friends are cool but they eat too many carbs."
-        >>> inputs = tokenizer(text, max_length=1024, return_tensors='jax')
+        >>> inputs = tokenizer(text, max_length=1024, return_tensors="jax")
         >>> encoder_outputs = model.encode(**inputs)
 
         >>> decoder_start_token_id = model.config.decoder_start_token_id
@@ -1355,11 +1355,11 @@ class FlaxBartForConditionalGeneration(FlaxBartPreTrainedModel):
         ```python
         >>> from transformers import BartTokenizer, FlaxBartForConditionalGeneration
 
-        >>> model = FlaxBartForConditionalGeneration.from_pretrained('facebook/bart-large-cnn')
-        >>> tokenizer = BartTokenizer.from_pretrained('facebook/bart-large-cnn')
+        >>> model = FlaxBartForConditionalGeneration.from_pretrained("facebook/bart-large-cnn")
+        >>> tokenizer = BartTokenizer.from_pretrained("facebook/bart-large-cnn")
 
         >>> text = "My friends are cool but they eat too many carbs."
-        >>> inputs = tokenizer(text, max_length=1024, return_tensors='jax')
+        >>> inputs = tokenizer(text, max_length=1024, return_tensors="jax")
         >>> encoder_outputs = model.encode(**inputs)
 
         >>> decoder_start_token_id = model.config.decoder_start_token_id

src/transformers/models/beit/modeling_beit.py

@@ -633,11 +633,11 @@ class BeitModel(BeitPreTrainedModel):
         >>> from PIL import Image
         >>> import requests
 
-        >>> url = 'http://images.cocodataset.org/val2017/000000039769.jpg'
+        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
         >>> image = Image.open(requests.get(url, stream=True).raw)
 
-        >>> feature_extractor = BeitFeatureExtractor.from_pretrained('microsoft/beit-base-patch16-224-pt22k-ft22k')
-        >>> model = BeitModel.from_pretrained('microsoft/beit-base-patch16-224-pt22k-ft22k')
+        >>> feature_extractor = BeitFeatureExtractor.from_pretrained("microsoft/beit-base-patch16-224-pt22k-ft22k")
+        >>> model = BeitModel.from_pretrained("microsoft/beit-base-patch16-224-pt22k-ft22k")
 
         >>> inputs = feature_extractor(images=image, return_tensors="pt")
         >>> outputs = model(**inputs)
@@ -750,11 +750,11 @@ class BeitForMaskedImageModeling(BeitPreTrainedModel):
         >>> from PIL import Image
         >>> import requests
 
-        >>> url = 'http://images.cocodataset.org/val2017/000000039769.jpg'
+        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
         >>> image = Image.open(requests.get(url, stream=True).raw)
 
-        >>> feature_extractor = BeitFeatureExtractor.from_pretrained('microsoft/beit-base-patch16-224-pt22k')
-        >>> model = BeitForMaskedImageModeling.from_pretrained('microsoft/beit-base-patch16-224-pt22k')
+        >>> feature_extractor = BeitFeatureExtractor.from_pretrained("microsoft/beit-base-patch16-224-pt22k")
+        >>> model = BeitForMaskedImageModeling.from_pretrained("microsoft/beit-base-patch16-224-pt22k")
 
         >>> inputs = feature_extractor(images=image, return_tensors="pt")
         >>> outputs = model(**inputs)
@@ -838,11 +838,11 @@ class BeitForImageClassification(BeitPreTrainedModel):
         >>> from PIL import Image
         >>> import requests
 
-        >>> url = 'http://images.cocodataset.org/val2017/000000039769.jpg'
+        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
         >>> image = Image.open(requests.get(url, stream=True).raw)
 
-        >>> feature_extractor = BeitFeatureExtractor.from_pretrained('microsoft/beit-base-patch16-224')
-        >>> model = BeitForImageClassification.from_pretrained('microsoft/beit-base-patch16-224')
+        >>> feature_extractor = BeitFeatureExtractor.from_pretrained("microsoft/beit-base-patch16-224")
+        >>> model = BeitForImageClassification.from_pretrained("microsoft/beit-base-patch16-224")
 
         >>> inputs = feature_extractor(images=image, return_tensors="pt")
         >>> outputs = model(**inputs)
@@ -1172,11 +1172,11 @@ class BeitForSemanticSegmentation(BeitPreTrainedModel):
         >>> from PIL import Image
         >>> import requests
 
-        >>> url = 'http://images.cocodataset.org/val2017/000000039769.jpg'
+        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
         >>> image = Image.open(requests.get(url, stream=True).raw)
 
-        >>> feature_extractor = BeitFeatureExtractor.from_pretrained('microsoft/beit-base-finetuned-ade-640-640')
-        >>> model = BeitForSemanticSegmentation.from_pretrained('microsoft/beit-base-finetuned-ade-640-640')
+        >>> feature_extractor = BeitFeatureExtractor.from_pretrained("microsoft/beit-base-finetuned-ade-640-640")
+        >>> model = BeitForSemanticSegmentation.from_pretrained("microsoft/beit-base-finetuned-ade-640-640")
 
         >>> inputs = feature_extractor(images=image, return_tensors="pt")
         >>> outputs = model(**inputs)

src/transformers/models/beit/modeling_flax_beit.py

@@ -735,11 +735,11 @@ FLAX_BEIT_MODEL_DOCSTRING = """
     >>> from PIL import Image
     >>> import requests
 
-    >>> url = 'http://images.cocodataset.org/val2017/000000039769.jpg'
+    >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
     >>> image = Image.open(requests.get(url, stream=True).raw)
 
-    >>> feature_extractor = BeitFeatureExtractor.from_pretrained('microsoft/beit-base-patch16-224-pt22k-ft22k')
-    >>> model = FlaxBeitModel.from_pretrained('microsoft/beit-base-patch16-224-pt22k-ft22k')
+    >>> feature_extractor = BeitFeatureExtractor.from_pretrained("microsoft/beit-base-patch16-224-pt22k-ft22k")
+    >>> model = FlaxBeitModel.from_pretrained("microsoft/beit-base-patch16-224-pt22k-ft22k")
 
     >>> inputs = feature_extractor(images=image, return_tensors="np")
     >>> outputs = model(**inputs)
@@ -822,11 +822,11 @@ FLAX_BEIT_MLM_DOCSTRING = """
     >>> from PIL import Image
     >>> import requests
 
-    >>> url = 'http://images.cocodataset.org/val2017/000000039769.jpg'
+    >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
     >>> image = Image.open(requests.get(url, stream=True).raw)
 
-    >>> feature_extractor = BeitFeatureExtractor.from_pretrained('microsoft/beit-base-patch16-224-pt22k')
-    >>> model = BeitForMaskedImageModeling.from_pretrained('microsoft/beit-base-patch16-224-pt22k')
+    >>> feature_extractor = BeitFeatureExtractor.from_pretrained("microsoft/beit-base-patch16-224-pt22k")
+    >>> model = BeitForMaskedImageModeling.from_pretrained("microsoft/beit-base-patch16-224-pt22k")
 
     >>> inputs = feature_extractor(images=image, return_tensors="np")
     >>> outputs = model(**inputs)
@@ -906,11 +906,11 @@ FLAX_BEIT_CLASSIF_DOCSTRING = """
     >>> from PIL import Image
     >>> import requests
 
-    >>> url = 'http://images.cocodataset.org/val2017/000000039769.jpg'
+    >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
     >>> image = Image.open(requests.get(url, stream=True).raw)
 
-    >>> feature_extractor = BeitFeatureExtractor.from_pretrained('microsoft/beit-base-patch16-224')
-    >>> model = FlaxBeitForImageClassification.from_pretrained('microsoft/beit-base-patch16-224')
+    >>> feature_extractor = BeitFeatureExtractor.from_pretrained("microsoft/beit-base-patch16-224")
+    >>> model = FlaxBeitForImageClassification.from_pretrained("microsoft/beit-base-patch16-224")
 
     >>> inputs = feature_extractor(images=image, return_tensors="np")
     >>> outputs = model(**inputs)