riaz.somc/transformers
1
0
Fork 0
mirror of https://github.com/huggingface/transformers.git synced 2025-07-03 12:50:06 +06:00
Code Issues Actions 28 Packages Projects Releases Wiki Activity

🚨🚨🚨 [pipelines] update defaults in pipelines that can generate (#38129)

Browse Source 
* pipeline generation defaults

* add max_new_tokens=20 in test pipelines

* pop all kwargs that are used to parameterize generation config

* add class attr that tell us whether a pipeline calls generate

* tmp commit

* pt text gen pipeline tests passing

* remove failing tf tests

* fix text gen pipeline mixin test corner case

* update text_to_audio pipeline tests

* trigger tests

* a few more tests

* skips

* some more audio tests

* not slow

* broken

* lower severity of generation mode errors

* fix all asr pipeline tests

* nit

* skip

* image to text pipeline tests

* text2test pipeline

* last pipelines

* fix flaky

* PR comments

* handle generate attrs more carefully in models that cant generate

* same as above
This commit is contained in:
Joao Gante 2025-05-19 18:02:06 +01:00 committed by GitHub
parent 6f9da7649f
commit 9c500015c5
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
23 changed files with 361 additions and 438 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/transformers/generation/configuration_utils.py
View File

@ -577,9 +577,10 @@ class GenerationConfig(PushToHubMixin):
if generation_mode in ("greedy_search", "sample"):
generation_mode = GenerationMode.ASSISTED_GENERATION
else:
raise ValueError(
logger.warning(
"You've set `assistant_model`, which triggers assisted generate. Currently, assisted generate "
"is only supported with Greedy Search and Sample."
"is only supported with Greedy Search and Sample. However, the base decoding mode (based on "
f"current flags) is {generation_mode} -- some of the set flags will be ignored."
)
# DoLa generation may extend some generation modes
@ -587,9 +588,10 @@ class GenerationConfig(PushToHubMixin):
if generation_mode in ("greedy_search", "sample"):
generation_mode = GenerationMode.DOLA_GENERATION
else:
raise ValueError(
logger.warning(
"You've set `dola_layers`, which triggers DoLa generate. Currently, DoLa generate "
"is only supported with Greedy Search and Sample."
"is only supported with Greedy Search and Sample. However, the base decoding mode (based on "
f"current flags) is {generation_mode} -- some of the set flags will be ignored."
)
return generation_mode

17
src/transformers/generation/utils.py
View File

@ -1752,16 +1752,21 @@ class GenerationMixin:
use_model_defaults is None and model_base_version >= version.parse("4.50.0")
):
modified_values = {}
default_generation_config = GenerationConfig()
for key, default_value in default_generation_config.__dict__.items():
global_default_generation_config = GenerationConfig()
model_generation_config = self.generation_config
# we iterate over the model's generation config: it may hold custom keys, which we'll want to copy
for key, model_gen_config_value in model_generation_config.__dict__.items():
if key.startswith("_") or key == "transformers_version": # metadata
continue
custom_gen_config_value = getattr(generation_config, key)
model_gen_config_value = getattr(self.generation_config, key)
if custom_gen_config_value == default_value and model_gen_config_value != default_value:
global_default_value = getattr(global_default_generation_config, key, None)
custom_gen_config_value = getattr(generation_config, key, None)
if (
custom_gen_config_value == global_default_value
and model_gen_config_value != global_default_value
):
modified_values[key] = model_gen_config_value
setattr(generation_config, key, model_gen_config_value)
if len(modified_values) > 0:
if use_model_defaults is None and len(modified_values) > 0:
logger.warning_once(
f"`generation_config` default values have been modified to match model-specific defaults: "
f"{modified_values}. If this is not desired, please set these values explicitly."

36
src/transformers/pipelines/automatic_speech_recognition.py
View File

@ -11,13 +11,13 @@
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import warnings
from collections import defaultdict
from typing import TYPE_CHECKING, Dict, Optional, Union
import numpy as np
import requests
from ..generation import GenerationConfig
from ..tokenization_utils import PreTrainedTokenizer
from ..utils import is_torch_available, is_torchaudio_available, logging
from .audio_utils import ffmpeg_read
@ -131,6 +131,11 @@ class AutomaticSpeechRecognitionPipeline(ChunkPipeline):
The input can be either a raw waveform or a audio file. In case of the audio file, ffmpeg should be installed for
to support multiple audio formats
Unless the model you're using explicitly sets these generation parameters in its configuration files
(`generation_config.json`), the following default values will be used:
- max_new_tokens: 256
- num_beams: 5
Example:
```python
@ -192,6 +197,13 @@ class AutomaticSpeechRecognitionPipeline(ChunkPipeline):
"""
_pipeline_calls_generate = True
# Make sure the docstring is updated when the default generation config is changed
_default_generation_config = GenerationConfig(
max_new_tokens=256,
num_beams=5, # follows openai's whisper implementation
)
def __init__(
self,
model: "PreTrainedModel",
@ -291,7 +303,6 @@ class AutomaticSpeechRecognitionPipeline(ChunkPipeline):
return_timestamps=None,
return_language=None,
generate_kwargs=None,
max_new_tokens=None,
):
# No parameters on this pipeline right now
preprocess_params = {}
@ -308,23 +319,17 @@ class AutomaticSpeechRecognitionPipeline(ChunkPipeline):
preprocess_params["stride_length_s"] = stride_length_s
forward_params = defaultdict(dict)
if max_new_tokens is not None:
warnings.warn(
"`max_new_tokens` is deprecated and will be removed in version 4.49 of Transformers. To remove this warning, pass `max_new_tokens` as a key inside `generate_kwargs` instead.",
FutureWarning,
)
forward_params["max_new_tokens"] = max_new_tokens
if generate_kwargs is not None:
if max_new_tokens is not None and "max_new_tokens" in generate_kwargs:
raise ValueError(
"`max_new_tokens` is defined both as an argument and inside `generate_kwargs` argument, please use"
" only 1 version"
)
forward_params.update(generate_kwargs)
postprocess_params = {}
if decoder_kwargs is not None:
postprocess_params["decoder_kwargs"] = decoder_kwargs
# in some models like whisper, the generation config has a `return_timestamps` key
if hasattr(self, "generation_config") and hasattr(self.generation_config, "return_timestamps"):
return_timestamps = return_timestamps or self.generation_config.return_timestamps
if return_timestamps is not None:
# Check whether we have a valid setting for return_timestamps and throw an error before we perform a forward pass
if self.type == "seq2seq" and return_timestamps:
@ -348,9 +353,9 @@ class AutomaticSpeechRecognitionPipeline(ChunkPipeline):
raise ValueError("Only Whisper can return language for now.")
postprocess_params["return_language"] = return_language
if self.assistant_model is not None:
if getattr(self, "assistant_model", None) is not None:
forward_params["assistant_model"] = self.assistant_model
if self.assistant_tokenizer is not None:
if getattr(self, "assistant_tokenizer", None) is not None:
forward_params["tokenizer"] = self.tokenizer
forward_params["assistant_tokenizer"] = self.assistant_tokenizer
@ -500,6 +505,7 @@ class AutomaticSpeechRecognitionPipeline(ChunkPipeline):
)
# custom processing for Whisper timestamps and word-level timestamps
return_timestamps = return_timestamps or getattr(self.generation_config, "return_timestamps", False)
if return_timestamps and self.type == "seq2seq_whisper":
generate_kwargs["return_timestamps"] = return_timestamps
if return_timestamps == "word":

49
src/transformers/pipelines/base.py
View File

@ -31,6 +31,7 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union
from ..dynamic_module_utils import custom_object_save
from ..feature_extraction_utils import PreTrainedFeatureExtractor
from ..generation import GenerationConfig
from ..image_processing_utils import BaseImageProcessor
from ..modelcard import ModelCard
from ..models.auto import AutoConfig, AutoTokenizer
@ -913,6 +914,9 @@ class Pipeline(_ScikitCompat, PushToHubMixin):
_load_feature_extractor = True
_load_tokenizer = True
# Pipelines that call `generate` have shared logic, e.g. preparing the generation config.
_pipeline_calls_generate = False
default_input_names = None
def __init__(
@ -1011,18 +1015,47 @@ class Pipeline(_ScikitCompat, PushToHubMixin):
):
self.model.to(self.device)
# If the model can generate:
# If it's a generation pipeline and the model can generate:
# 1 - create a local generation config. This is done to avoid side-effects on the model as we apply local
# tweaks to the generation config.
# 2 - load the assistant model if it is passed.
self.assistant_model, self.assistant_tokenizer = load_assistant_model(
self.model, kwargs.pop("assistant_model", None), kwargs.pop("assistant_tokenizer", None)
)
if self.model.can_generate():
if self._pipeline_calls_generate and self.model.can_generate():
self.assistant_model, self.assistant_tokenizer = load_assistant_model(
self.model, kwargs.pop("assistant_model", None), kwargs.pop("assistant_tokenizer", None)
)
self.prefix = self.model.config.prefix if hasattr(self.model.config, "prefix") else None
self.generation_config = copy.deepcopy(self.model.generation_config)
# Update the generation config with task specific params if they exist
# NOTE: `prefix` is pipeline-specific and doesn't exist in the generation config.
# each pipeline with text generation capabilities should define its own default generation in a
# `_default_generation_config` class attribute
default_pipeline_generation_config = getattr(self, "_default_generation_config", GenerationConfig())
if hasattr(self.model, "_prepare_generation_config"): # TF doesn't have `_prepare_generation_config`
# Uses `generate`'s logic to enforce the following priority of arguments:
# 1. user-defined config options in `**kwargs`
# 2. model's generation config values
# 3. pipeline's default generation config values
# NOTE: _prepare_generation_config creates a deep copy of the generation config before updating it,
# and returns all kwargs that were not used to update the generation config
prepared_generation_config, kwargs = self.model._prepare_generation_config(
generation_config=default_pipeline_generation_config, use_model_defaults=True, **kwargs
)
self.generation_config = prepared_generation_config
# if the `max_new_tokens` is set to the pipeline default, but `max_length` is set to a non-default
# value: let's honor `max_length`. E.g. we want Whisper's default `max_length=448` take precedence
# over over the pipeline's length default.
if (
default_pipeline_generation_config.max_new_tokens is not None # there's a pipeline default
and self.generation_config.max_new_tokens == default_pipeline_generation_config.max_new_tokens
and self.generation_config.max_length is not None
and self.generation_config.max_length != 20 # global default
):
self.generation_config.max_new_tokens = None
else:
# TODO (joao): no PT model should reach this line. However, some audio models with complex
# inheritance patterns do. Streamline those models such that this line is no longer needed.
# In those models, the default generation config is not (yet) used.
self.generation_config = copy.deepcopy(self.model.generation_config)
# Update the generation config with task specific params if they exist.
# NOTE: 1. `prefix` is pipeline-specific and doesn't exist in the generation config.
# 2. `task_specific_params` is a legacy feature and should be removed in a future version.
task_specific_params = self.model.config.task_specific_params
if task_specific_params is not None and task in task_specific_params:
this_task_params = task_specific_params.get(task)

15
src/transformers/pipelines/document_question_answering.py
View File

@ -17,6 +17,7 @@ from typing import List, Optional, Tuple, Union
import numpy as np
from ..generation import GenerationConfig
from ..utils import (
ExplicitEnum,
add_end_docstrings,
@ -106,6 +107,10 @@ class DocumentQuestionAnsweringPipeline(ChunkPipeline):
similar to the (extractive) question answering pipeline; however, the pipeline takes an image (and optional OCR'd
words/boxes) as input instead of text context.
Unless the model you're using explicitly sets these generation parameters in its configuration files
(`generation_config.json`), the following default values will be used:
- max_new_tokens: 256
Example:
```python
@ -129,6 +134,12 @@ class DocumentQuestionAnsweringPipeline(ChunkPipeline):
[huggingface.co/models](https://huggingface.co/models?filter=document-question-answering).
"""
_pipeline_calls_generate = True
# Make sure the docstring is updated when the default generation config is changed
_default_generation_config = GenerationConfig(
max_new_tokens=256,
)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
if self.tokenizer is not None and not self.tokenizer.__class__.__name__.endswith("Fast"):
@ -190,9 +201,9 @@ class DocumentQuestionAnsweringPipeline(ChunkPipeline):
postprocess_params["handle_impossible_answer"] = handle_impossible_answer
forward_params = {}
if self.assistant_model is not None:
if getattr(self, "assistant_model", None) is not None:
forward_params["assistant_model"] = self.assistant_model
if self.assistant_tokenizer is not None:
if getattr(self, "assistant_tokenizer", None) is not None:
forward_params["tokenizer"] = self.tokenizer
forward_params["assistant_tokenizer"] = self.assistant_tokenizer

11
src/transformers/pipelines/image_text_to_text.py
View File

@ -17,6 +17,7 @@ import enum
from collections.abc import Iterable # pylint: disable=g-importing-member
from typing import Dict, List, Optional, Union
from ..generation import GenerationConfig
from ..processing_utils import ProcessingKwargs, Unpack
from ..utils import (
add_end_docstrings,
@ -120,6 +121,10 @@ class ImageTextToTextPipeline(Pipeline):
in which case the pipeline will operate in chat mode and will continue the chat(s) by adding its response(s).
Each chat takes the form of a list of dicts, where each dict contains "role" and "content" keys.
Unless the model you're using explicitly sets these generation parameters in its configuration files
(`generation_config.json`), the following default values will be used:
- max_new_tokens: 256
Example:
```python
@ -176,6 +181,12 @@ class ImageTextToTextPipeline(Pipeline):
_load_feature_extractor = False
_load_tokenizer = False
_pipeline_calls_generate = True
# Make sure the docstring is updated when the default generation config is changed
_default_generation_config = GenerationConfig(
max_new_tokens=256,
)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
requires_backends(self, "vision")

11
src/transformers/pipelines/image_to_text.py
View File

@ -15,6 +15,7 @@
from typing import List, Union
from ..generation import GenerationConfig
from ..utils import (
add_end_docstrings,
is_tf_available,
@ -47,6 +48,10 @@ class ImageToTextPipeline(Pipeline):
"""
Image To Text pipeline using a `AutoModelForVision2Seq`. This pipeline predicts a caption for a given image.
Unless the model you're using explicitly sets these generation parameters in its configuration files
(`generation_config.json`), the following default values will be used:
- max_new_tokens: 256
Example:
```python
@ -66,6 +71,12 @@ class ImageToTextPipeline(Pipeline):
[huggingface.co/models](https://huggingface.co/models?pipeline_tag=image-to-text).
"""
_pipeline_calls_generate = True
# Make sure the docstring is updated when the default generation config is changed
_default_generation_config = GenerationConfig(
max_new_tokens=256,
)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
requires_backends(self, "vision")

15
src/transformers/pipelines/table_question_answering.py
View File

@ -3,6 +3,7 @@ import types
import numpy as np
from ..generation import GenerationConfig
from ..utils import (
add_end_docstrings,
is_tf_available,
@ -88,6 +89,10 @@ class TableQuestionAnsweringPipeline(Pipeline):
Table Question Answering pipeline using a `ModelForTableQuestionAnswering`. This pipeline is only available in
PyTorch.
Unless the model you're using explicitly sets these generation parameters in its configuration files
(`generation_config.json`), the following default values will be used:
- max_new_tokens: 256
Example:
```python
@ -116,6 +121,12 @@ class TableQuestionAnsweringPipeline(Pipeline):
default_input_names = "table,query"
_pipeline_calls_generate = True
# Make sure the docstring is updated when the default generation config is changed
_default_generation_config = GenerationConfig(
max_new_tokens=256,
)
def __init__(self, args_parser=TableQuestionAnsweringArgumentHandler(), *args, **kwargs):
super().__init__(*args, **kwargs)
self._args_parser = args_parser
@ -359,9 +370,9 @@ class TableQuestionAnsweringPipeline(Pipeline):
if sequential is not None:
forward_params["sequential"] = sequential
if self.assistant_model is not None:
if getattr(self, "assistant_model", None) is not None:
forward_params["assistant_model"] = self.assistant_model
if self.assistant_tokenizer is not None:
if getattr(self, "assistant_tokenizer", None) is not None:
forward_params["tokenizer"] = self.tokenizer
forward_params["assistant_tokenizer"] = self.assistant_tokenizer

23
src/transformers/pipelines/text2text_generation.py
View File

@ -1,6 +1,7 @@
import enum
import warnings
from ..generation import GenerationConfig
from ..tokenization_utils import TruncationStrategy
from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging
from .base import Pipeline, build_pipeline_init_args
@ -27,6 +28,11 @@ class Text2TextGenerationPipeline(Pipeline):
"""
Pipeline for text to text generation using seq2seq models.
Unless the model you're using explicitly sets these generation parameters in its configuration files
(`generation_config.json`), the following default values will be used:
- max_new_tokens: 256
- num_beams: 4
Example:
```python
@ -60,6 +66,13 @@ class Text2TextGenerationPipeline(Pipeline):
text2text_generator("question: What is 42 ? context: 42 is the answer to life, the universe and everything")
```"""
_pipeline_calls_generate = True
# Make sure the docstring is updated when the default generation config is changed (in all pipelines in this file)
_default_generation_config = GenerationConfig(
max_new_tokens=256,
num_beams=4,
)
# Used in the return key of the pipeline.
return_name = "generated"
@ -238,6 +251,11 @@ class SummarizationPipeline(Text2TextGenerationPipeline):
of available parameters, see the [following
documentation](https://huggingface.co/docs/transformers/en/main_classes/text_generation#transformers.generation.GenerationMixin.generate)
Unless the model you're using explicitly sets these generation parameters in its configuration files
(`generation_config.json`), the following default values will be used:
- max_new_tokens: 256
- num_beams: 4
Usage:
```python
@ -307,6 +325,11 @@ class TranslationPipeline(Text2TextGenerationPipeline):
For a list of available parameters, see the [following
documentation](https://huggingface.co/docs/transformers/en/main_classes/text_generation#transformers.generation.GenerationMixin.generate)
Unless the model you're using explicitly sets these generation parameters in its configuration files
(`generation_config.json`), the following default values will be used:
- max_new_tokens: 256
- num_beams: 4
Usage:
```python

30
src/transformers/pipelines/text_generation.py
View File

@ -3,6 +3,7 @@ import itertools
import types
from typing import Dict
from ..generation import GenerationConfig
from ..utils import ModelOutput, add_end_docstrings, is_tf_available, is_torch_available
from .base import Pipeline, build_pipeline_init_args
@ -40,10 +41,16 @@ class Chat:
@add_end_docstrings(build_pipeline_init_args(has_tokenizer=True))
class TextGenerationPipeline(Pipeline):
"""
Language generation pipeline using any `ModelWithLMHead`. This pipeline predicts the words that will follow a
specified text prompt. When the underlying model is a conversational model, it can also accept one or more chats,
in which case the pipeline will operate in chat mode and will continue the chat(s) by adding its response(s).
Each chat takes the form of a list of dicts, where each dict contains "role" and "content" keys.
Language generation pipeline using any `ModelWithLMHead` or `ModelForCausalLM`. This pipeline predicts the words
that will follow a specified text prompt. When the underlying model is a conversational model, it can also accept
one or more chats, in which case the pipeline will operate in chat mode and will continue the chat(s) by adding
its response(s). Each chat takes the form of a list of dicts, where each dict contains "role" and "content" keys.
Unless the model you're using explicitly sets these generation parameters in its configuration files
(`generation_config.json`), the following default values will be used:
- max_new_tokens: 256
- do_sample: True
- temperature: 0.7
Examples:
@ -95,6 +102,14 @@ class TextGenerationPipeline(Pipeline):
begging for his blessing. <eod> </s> <eos>
"""
_pipeline_calls_generate = True
# Make sure the docstring is updated when the default generation config is changed
_default_generation_config = GenerationConfig(
max_new_tokens=256,
do_sample=True, # free-form text generation often uses sampling
temperature=0.7,
)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.check_model_type(
@ -303,7 +318,7 @@ class TextGenerationPipeline(Pipeline):
"add_special_tokens": add_special_tokens,
"truncation": truncation,
"padding": padding,
"max_length": max_length,
"max_length": max_length, # TODO: name clash -- this is broken, `max_length` is also a `generate` arg
}
tokenizer_kwargs = {key: value for key, value in tokenizer_kwargs.items() if value is not None}
@ -386,7 +401,7 @@ class TextGenerationPipeline(Pipeline):
if isinstance(output, ModelOutput):
generated_sequence = output.sequences
other_outputs = {k: v for k, v in output.items() if k != "sequences"}
other_outputs = {k: v for k, v in output.items() if k not in {"sequences", "past_key_values"}}
out_b = generated_sequence.shape[0]
if self.framework == "pt":
@ -418,7 +433,8 @@ class TextGenerationPipeline(Pipeline):
"input_ids": input_ids,
"prompt_text": prompt_text,
}
model_outputs.update(other_outputs)
if other_outputs:
model_outputs.update({"additional_outputs": other_outputs})
return model_outputs
def postprocess(

15
src/transformers/pipelines/text_to_audio.py
View File

@ -13,6 +13,7 @@
# limitations under the License.from typing import List, Union
from typing import List, Union
from ..generation import GenerationConfig
from ..utils import is_torch_available
from .base import Pipeline
@ -31,6 +32,10 @@ class TextToAudioPipeline(Pipeline):
Text-to-audio generation pipeline using any `AutoModelForTextToWaveform` or `AutoModelForTextToSpectrogram`. This
pipeline generates an audio file from an input text and optional other conditional inputs.
Unless the model you're using explicitly sets these generation parameters in its configuration files
(`generation_config.json`), the following default values will be used:
- max_new_tokens: 256
Example:
```python
@ -75,6 +80,12 @@ class TextToAudioPipeline(Pipeline):
See the list of available models on [huggingface.co/models](https://huggingface.co/models?filter=text-to-speech).
"""
_pipeline_calls_generate = True
# Make sure the docstring is updated when the default generation config is changed
_default_generation_config = GenerationConfig(
max_new_tokens=256,
)
def __init__(self, *args, vocoder=None, sampling_rate=None, **kwargs):
super().__init__(*args, **kwargs)
@ -192,9 +203,9 @@ class TextToAudioPipeline(Pipeline):
forward_params=None,
generate_kwargs=None,
):
if self.assistant_model is not None:
if getattr(self, "assistant_model", None) is not None:
generate_kwargs["assistant_model"] = self.assistant_model
if self.assistant_tokenizer is not None:
if getattr(self, "assistant_tokenizer", None) is not None:
generate_kwargs["tokenizer"] = self.tokenizer
generate_kwargs["assistant_tokenizer"] = self.assistant_tokenizer

15
src/transformers/pipelines/visual_question_answering.py
View File

@ -1,5 +1,6 @@
from typing import List, Optional, Union
from ..generation import GenerationConfig
from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging
from .base import Pipeline, build_pipeline_init_args
@ -22,6 +23,10 @@ class VisualQuestionAnsweringPipeline(Pipeline):
Visual Question Answering pipeline using a `AutoModelForVisualQuestionAnswering`. This pipeline is currently only
available in PyTorch.
Unless the model you're using explicitly sets these generation parameters in its configuration files
(`generation_config.json`), the following default values will be used:
- max_new_tokens: 256
Example:
```python
@ -52,6 +57,12 @@ class VisualQuestionAnsweringPipeline(Pipeline):
[huggingface.co/models](https://huggingface.co/models?filter=visual-question-answering).
"""
_pipeline_calls_generate = True
# Make sure the docstring is updated when the default generation config is changed
_default_generation_config = GenerationConfig(
max_new_tokens=256,
)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.check_model_type(MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING_NAMES)
@ -68,9 +79,9 @@ class VisualQuestionAnsweringPipeline(Pipeline):
postprocess_params["top_k"] = top_k
forward_params = {}
if self.assistant_model is not None:
if getattr(self, "assistant_model", None) is not None:
forward_params["assistant_model"] = self.assistant_model
if self.assistant_tokenizer is not None:
if getattr(self, "assistant_tokenizer", None) is not None:
forward_params["tokenizer"] = self.tokenizer
forward_params["assistant_tokenizer"] = self.assistant_tokenizer

12
tests/generation/test_configuration_utils.py
View File

@ -204,8 +204,9 @@ class GenerationConfigTest(unittest.TestCase):
# By default we throw a short warning. However, we log with INFO level the details.
# Default: we don't log the incorrect input values, only a short summary. We explain how to get more details.
with CaptureLogger(logger) as captured_logs:
GenerationConfig(do_sample=False, temperature=0.5)
with LoggingLevel(logging.WARNING):
with CaptureLogger(logger) as captured_logs:
GenerationConfig(do_sample=False, temperature=0.5)
self.assertNotIn("0.5", captured_logs.out)
self.assertTrue(len(captured_logs.out) < 150) # short log
self.assertIn("Set `TRANSFORMERS_VERBOSITY=info` for more details", captured_logs.out)
@ -259,9 +260,10 @@ class GenerationConfigTest(unittest.TestCase):
# Catch warnings
with warnings.catch_warnings(record=True) as captured_warnings:
# Catch logs (up to WARNING level, the default level)
logger = transformers_logging.get_logger("transformers.generation.configuration_utils")
with CaptureLogger(logger) as captured_logs:
config.save_pretrained(tmp_dir)
with LoggingLevel(logging.WARNING):
logger = transformers_logging.get_logger("transformers.generation.configuration_utils")
with CaptureLogger(logger) as captured_logs:
config.save_pretrained(tmp_dir)
self.assertEqual(len(captured_warnings), 0)
self.assertEqual(len(captured_logs.out), 0)
self.assertEqual(len(os.listdir(tmp_dir)), 1)

68
tests/pipelines/test_pipelines_automatic_speech_recognition.py
View File

@ -12,7 +12,6 @@
# See the License for the specific language governing permissions and
# limitations under the License.
import time
import unittest
import numpy as np
@ -56,10 +55,6 @@ if is_torch_available():
import torch
# We can't use this mixin because it assumes TF support.
# from .test_pipelines_common import CustomInputPipelineCommonMixin
@is_pipeline_test
class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
model_mapping = dict(
@ -81,6 +76,11 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
# But the slow tokenizer test should still run as they're quite small
self.skipTest(reason="No tokenizer available")
if model.can_generate():
extra_kwargs = {"max_new_tokens": 20}
else:
extra_kwargs = {}
speech_recognizer = AutomaticSpeechRecognitionPipeline(
model=model,
tokenizer=tokenizer,
@ -88,6 +88,7 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
image_processor=image_processor,
processor=processor,
torch_dtype=torch_dtype,
**extra_kwargs,
)
# test with a raw waveform
@ -159,7 +160,6 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
outputs = speech_recognizer(audio, return_timestamps="char")
@require_torch
@slow
def test_pt_defaults(self):
pipeline("automatic-speech-recognition", framework="pt")
@ -225,13 +225,13 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
):
_ = speech_recognizer(waveform, return_timestamps="char")
@slow
@require_torch_accelerator
def test_whisper_fp16(self):
speech_recognizer = pipeline(
model="openai/whisper-base",
model="openai/whisper-tiny",
device=torch_device,
torch_dtype=torch.float16,
max_new_tokens=5,
)
waveform = np.tile(np.arange(1000, dtype=np.float32), 34)
speech_recognizer(waveform)
@ -241,6 +241,8 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
speech_recognizer = pipeline(
model="hf-internal-testing/tiny-random-speech-encoder-decoder",
framework="pt",
max_new_tokens=19,
num_beams=1,
)
waveform = np.tile(np.arange(1000, dtype=np.float32), 34)
@ -252,10 +254,11 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
speech_recognizer = pipeline(
model="hf-internal-testing/tiny-random-speech-encoder-decoder",
framework="pt",
max_new_tokens=10,
)
waveform = np.tile(np.arange(1000, dtype=np.float32), 34)
output = speech_recognizer(waveform, max_new_tokens=10, generate_kwargs={"num_beams": 2})
output = speech_recognizer(waveform, generate_kwargs={"num_beams": 2})
self.assertEqual(output, {"text": "あл † γ ت ב オ 束 泣 足"})
@slow
@ -330,6 +333,7 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
self.skipTest(reason="Tensorflow not supported yet.")
@require_torch
@unittest.skip("TODO (joao, eustache): this test is failing, find the breaking PR and fix the cause or the test")
def test_torch_small_no_tokenizer_files(self):
# test that model without tokenizer file cannot be loaded
with pytest.raises(OSError):
@ -376,6 +380,7 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
@slow
@require_torch
@unittest.skip("TODO (joao, eustache): this test is failing, find the breaking PR and fix the cause or the test")
def test_return_timestamps_in_preprocess(self):
pipe = pipeline(
task="automatic-speech-recognition",
@ -420,6 +425,7 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
@slow
@require_torch
@unittest.skip("TODO (joao, eustache): this test is failing, find the breaking PR and fix the cause or the test")
def test_return_timestamps_and_language_in_preprocess(self):
pipe = pipeline(
task="automatic-speech-recognition",
@ -477,6 +483,7 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
@slow
@require_torch
@unittest.skip("TODO (joao, eustache): this test is failing, find the breaking PR and fix the cause or the test")
def test_return_timestamps_in_preprocess_longform(self):
pipe = pipeline(
task="automatic-speech-recognition",
@ -556,6 +563,7 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
chunk_length_s=8,
stride_length_s=1,
return_timestamps=True,
max_new_tokens=1,
)
_ = pipe(dummy_speech)
@ -569,6 +577,7 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
chunk_length_s=8,
stride_length_s=1,
return_timestamps="word",
max_new_tokens=1,
)
_ = pipe(dummy_speech)
@ -587,6 +596,7 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
chunk_length_s=8,
stride_length_s=1,
return_timestamps="char",
max_new_tokens=1,
)
_ = pipe(dummy_speech)
@ -598,6 +608,7 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
task="automatic-speech-recognition",
model="openai/whisper-tiny",
framework="pt",
num_beams=1,
)
ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation").sort("id")
audio = ds[40]["audio"]
@ -614,6 +625,7 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
task="automatic-speech-recognition",
model="openai/whisper-tiny",
framework="pt",
num_beams=1,
)
ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation[:2]")
EXPECTED_OUTPUT = [
@ -624,7 +636,6 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
output = speech_recognizer(ds["audio"], batch_size=2)
self.assertEqual(output, EXPECTED_OUTPUT)
@slow
def test_find_longest_common_subsequence(self):
max_source_positions = 1500
processor = AutoProcessor.from_pretrained("openai/whisper-tiny")
@ -790,6 +801,7 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
@slow
@require_torch
@unittest.skip("TODO (joao, eustache): this test is failing, find the breaking PR and fix the cause or the test")
def test_whisper_timestamp_prediction(self):
ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation").sort("id")
array = np.concatenate(
@ -893,7 +905,7 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
array = np.concatenate(
[ds[40]["audio"]["array"], ds[41]["audio"]["array"], ds[42]["audio"]["array"], ds[43]["audio"]["array"]]
)
pipe = pipeline(model="openai/whisper-large-v3", return_timestamps=True)
pipe = pipeline(model="openai/whisper-large-v3", return_timestamps=True, num_beams=1)
output = pipe(ds[40]["audio"])
self.assertDictEqual(
@ -976,6 +988,7 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
@slow
@require_torch
@unittest.skip("TODO (joao, eustache): this test is failing, find the breaking PR and fix the cause or the test")
def test_whisper_word_timestamps_batched(self):
pipe = pipeline(
task="automatic-speech-recognition",
@ -1020,6 +1033,7 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
@slow
@require_torch
@unittest.skip("TODO (joao, eustache): this test is failing, find the breaking PR and fix the cause or the test")
def test_whisper_large_word_timestamps_batched(self):
pipe = pipeline(
task="automatic-speech-recognition",
@ -1063,6 +1077,7 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
@require_torch
@slow
@unittest.skip("TODO (joao, eustache): this test is failing, find the breaking PR and fix the cause or the test")
def test_torch_speech_encoder_decoder(self):
speech_recognizer = pipeline(
task="automatic-speech-recognition",
@ -1106,7 +1121,9 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
tokenizer = AutoTokenizer.from_pretrained("facebook/s2t-small-mustc-en-it-st")
feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/s2t-small-mustc-en-it-st")
asr = AutomaticSpeechRecognitionPipeline(model=model, tokenizer=tokenizer, feature_extractor=feature_extractor)
asr = AutomaticSpeechRecognitionPipeline(
model=model, tokenizer=tokenizer, feature_extractor=feature_extractor, max_new_tokens=20
)
waveform = np.tile(np.arange(1000, dtype=np.float32), 34)
@ -1125,11 +1142,13 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
@slow
@require_torch
@require_torchaudio
@unittest.skip("TODO (joao, eustache): this test is failing, find the breaking PR and fix the cause or the test")
def test_simple_whisper_asr(self):
speech_recognizer = pipeline(
task="automatic-speech-recognition",
model="openai/whisper-tiny.en",
framework="pt",
num_beams=1,
)
ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
audio = ds[0]["audio"]
@ -1210,7 +1229,7 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
feature_extractor = AutoFeatureExtractor.from_pretrained("openai/whisper-large")
speech_recognizer_2 = AutomaticSpeechRecognitionPipeline(
model=model, tokenizer=tokenizer, feature_extractor=feature_extractor
model=model, tokenizer=tokenizer, feature_extractor=feature_extractor, max_new_tokens=20
)
output_2 = speech_recognizer_2(ds[40]["audio"])
self.assertEqual(output, output_2)
@ -1223,6 +1242,7 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
tokenizer=tokenizer,
feature_extractor=feature_extractor,
generate_kwargs={"task": "transcribe", "language": "<|it|>"},
max_new_tokens=20,
)
output_3 = speech_translator(ds[40]["audio"])
self.assertEqual(output_3, {"text": " Un uomo ha detto all'universo, Sir, esiste."})
@ -1279,6 +1299,7 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
model = AutoModelForSpeechSeq2Seq.from_pretrained(
model_id,
use_safetensors=True,
device_map="auto",
)
# Load assistant:
@ -1286,6 +1307,7 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
assistant_model = AutoModelForSpeechSeq2Seq.from_pretrained(
assistant_model_id,
use_safetensors=True,
device_map="auto",
)
# Load pipeline:
@ -1294,22 +1316,18 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
tokenizer=processor.tokenizer,
feature_extractor=processor.feature_extractor,
generate_kwargs={"language": "en"},
max_new_tokens=21,
num_beams=1,
)
start_time = time.time()
transcription_non_ass = pipe(sample.copy(), generate_kwargs={"assistant_model": assistant_model})["text"]
total_time_assist = time.time() - start_time
start_time = time.time()
transcription_ass = pipe(sample)["text"]
total_time_non_assist = time.time() - start_time
self.assertEqual(transcription_ass, transcription_non_ass)
self.assertEqual(
transcription_ass,
" Mr. Quilter is the apostle of the middle classes and we are glad to welcome his gospel.",
)
self.assertTrue(total_time_non_assist > total_time_assist, "Make sure that assistant decoding is faster")
@slow
def test_speculative_decoding_whisper_distil(self):
@ -1325,6 +1343,7 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
model = AutoModelForSpeechSeq2Seq.from_pretrained(
model_id,
use_safetensors=True,
device_map="auto",
)
# Load assistant:
@ -1332,6 +1351,7 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
assistant_model = AutoModelForCausalLM.from_pretrained(
assistant_model_id,
use_safetensors=True,
device_map="auto",
)
# Load pipeline:
@ -1340,22 +1360,18 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
tokenizer=processor.tokenizer,
feature_extractor=processor.feature_extractor,
generate_kwargs={"language": "en"},
max_new_tokens=21,
num_beams=1,
)
start_time = time.time()
transcription_non_ass = pipe(sample.copy(), generate_kwargs={"assistant_model": assistant_model})["text"]
total_time_assist = time.time() - start_time
start_time = time.time()
transcription_ass = pipe(sample)["text"]
total_time_non_assist = time.time() - start_time
self.assertEqual(transcription_ass, transcription_non_ass)
self.assertEqual(
transcription_ass,
" Mr. Quilter is the apostle of the middle classes and we are glad to welcome his gospel.",
)
self.assertEqual(total_time_non_assist > total_time_assist, "Make sure that assistant decoding is faster")
@slow
@require_torch
@ -1595,6 +1611,7 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
max_new_tokens=128,
chunk_length_s=30,
batch_size=16,
num_beams=1,
)
dataset = load_dataset("distil-whisper/librispeech_long", "clean", split="validation")
@ -1634,6 +1651,7 @@ class AutomaticSpeechRecognitionPipelineTests(unittest.TestCase):
max_new_tokens=128,
device=torch_device,
return_timestamps=True, # to allow longform generation
num_beams=1,
)
ds = load_dataset("distil-whisper/meanwhile", "default")["test"]

1
tests/pipelines/test_pipelines_document_question_answering.py
View File

@ -86,6 +86,7 @@ class DocumentQuestionAnsweringPipelineTests(unittest.TestCase):
image_processor=image_processor,
processor=processor,
torch_dtype=torch_dtype,
max_new_tokens=20,
)
image = INVOICE_URL

6
tests/pipelines/test_pipelines_image_text_to_text.py
View File

@ -43,7 +43,7 @@ class ImageTextToTextPipelineTests(unittest.TestCase):
model_mapping = MODEL_FOR_IMAGE_TEXT_TO_TEXT_MAPPING
def get_test_pipeline(self, model, tokenizer, processor, image_processor, torch_dtype="float32"):
pipe = ImageTextToTextPipeline(model=model, processor=processor, torch_dtype=torch_dtype)
pipe = ImageTextToTextPipeline(model=model, processor=processor, torch_dtype=torch_dtype, max_new_tokens=10)
image_token = getattr(processor.tokenizer, "image_token", "")
examples = [
{
@ -176,8 +176,8 @@ class ImageTextToTextPipelineTests(unittest.TestCase):
image = "./tests/fixtures/tests_samples/COCO/000000039769.png"
prompt = "a photo of"
outputs = pipe([image, image], text=[prompt, prompt])
outputs_batched = pipe([image, image], text=[prompt, prompt], batch_size=2)
outputs = pipe([image, image], text=[prompt, prompt], max_new_tokens=10)
outputs_batched = pipe([image, image], text=[prompt, prompt], batch_size=2, max_new_tokens=10)
self.assertEqual(outputs, outputs_batched)
@slow

72
tests/pipelines/test_pipelines_image_to_text.py
View File

@ -15,14 +15,11 @@
import unittest
import requests
from huggingface_hub import ImageToTextOutput
from transformers import MODEL_FOR_VISION_2_SEQ_MAPPING, TF_MODEL_FOR_VISION_2_SEQ_MAPPING, is_vision_available
from transformers.pipelines import ImageToTextPipeline, pipeline
from transformers.testing_utils import (
compare_pipeline_output_to_hub_spec,
is_pipeline_test,
require_tf,
require_torch,
require_vision,
slow,
@ -63,6 +60,7 @@ class ImageToTextPipelineTests(unittest.TestCase):
image_processor=image_processor,
processor=processor,
torch_dtype=torch_dtype,
max_new_tokens=20,
)
examples = [
Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"),
@ -80,50 +78,9 @@ class ImageToTextPipelineTests(unittest.TestCase):
],
)
@require_tf
def test_small_model_tf(self):
pipe = pipeline("image-to-text", model="hf-internal-testing/tiny-random-vit-gpt2", framework="tf")
image = "./tests/fixtures/tests_samples/COCO/000000039769.png"
outputs = pipe(image)
self.assertEqual(
outputs,
[
{
"generated_text": "growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO"
},
],
)
outputs = pipe([image, image])
self.assertEqual(
outputs,
[
[
{
"generated_text": "growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO"
}
],
[
{
"generated_text": "growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO"
}
],
],
)
outputs = pipe(image, max_new_tokens=1)
self.assertEqual(
outputs,
[{"generated_text": "growth"}],
)
for single_output in outputs:
compare_pipeline_output_to_hub_spec(single_output, ImageToTextOutput)
@require_torch
def test_small_model_pt(self):
pipe = pipeline("image-to-text", model="hf-internal-testing/tiny-random-vit-gpt2")
pipe = pipeline("image-to-text", model="hf-internal-testing/tiny-random-vit-gpt2", max_new_tokens=19)
image = "./tests/fixtures/tests_samples/COCO/000000039769.png"
outputs = pipe(image)
@ -164,7 +121,9 @@ class ImageToTextPipelineTests(unittest.TestCase):
@require_torch
def test_consistent_batching_behaviour(self):
pipe = pipeline("image-to-text", model="hf-internal-testing/tiny-random-BlipForConditionalGeneration")
pipe = pipeline(
"image-to-text", model="hf-internal-testing/tiny-random-BlipForConditionalGeneration", max_new_tokens=10
)
image = "./tests/fixtures/tests_samples/COCO/000000039769.png"
prompt = "a photo of"
@ -274,26 +233,9 @@ class ImageToTextPipelineTests(unittest.TestCase):
with self.assertRaises(ValueError):
outputs = pipe([image, image], prompt=[prompt, prompt])
@slow
@require_tf
def test_large_model_tf(self):
pipe = pipeline("image-to-text", model="ydshieh/vit-gpt2-coco-en", framework="tf")
image = "./tests/fixtures/tests_samples/COCO/000000039769.png"
outputs = pipe(image)
self.assertEqual(outputs, [{"generated_text": "a cat laying on a blanket next to a cat laying on a bed "}])
outputs = pipe([image, image])
self.assertEqual(
outputs,
[
[{"generated_text": "a cat laying on a blanket next to a cat laying on a bed "}],
[{"generated_text": "a cat laying on a blanket next to a cat laying on a bed "}],
],
)
@slow
@require_torch
@unittest.skip("TODO (joao, raushan): there is something wrong with image processing in the model/pipeline")
def test_conditional_generation_llava(self):
pipe = pipeline("image-to-text", model="llava-hf/bakLlava-v1-hf")
@ -318,7 +260,7 @@ class ImageToTextPipelineTests(unittest.TestCase):
@slow
@require_torch
def test_nougat(self):
pipe = pipeline("image-to-text", "facebook/nougat-base")
pipe = pipeline("image-to-text", "facebook/nougat-base", max_new_tokens=19)
outputs = pipe("https://huggingface.co/datasets/Xenova/transformers.js-docs/resolve/main/nougat_paper.png")

18
tests/pipelines/test_pipelines_summarization.py
View File

@ -21,7 +21,7 @@ from transformers import (
TFPreTrainedModel,
pipeline,
)
from transformers.testing_utils import is_pipeline_test, require_tf, require_torch, slow, torch_device
from transformers.testing_utils import is_pipeline_test, require_torch, slow, torch_device
from transformers.tokenization_utils import TruncationStrategy
from .test_pipelines_common import ANY
@ -48,6 +48,7 @@ class SummarizationPipelineTests(unittest.TestCase):
image_processor=image_processor,
processor=processor,
torch_dtype=torch_dtype,
max_new_tokens=20,
)
return summarizer, ["(CNN)The Palestinian Authority officially became", "Some other text"]
@ -92,20 +93,7 @@ class SummarizationPipelineTests(unittest.TestCase):
@require_torch
def test_small_model_pt(self):
summarizer = pipeline(task="summarization", model="sshleifer/tiny-mbart", framework="pt")
outputs = summarizer("This is a small test")
self.assertEqual(
outputs,
[
{
"summary_text": "เข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไป"
}
],
)
@require_tf
def test_small_model_tf(self):
summarizer = pipeline(task="summarization", model="sshleifer/tiny-mbart", framework="tf")
summarizer = pipeline(task="summarization", model="sshleifer/tiny-mbart", framework="pt", max_new_tokens=19)
outputs = summarizer("This is a small test")
self.assertEqual(
outputs,

12
tests/pipelines/test_pipelines_table_question_answering.py
View File

@ -49,7 +49,7 @@ class TQAPipelineTests(unittest.TestCase):
self.assertIsInstance(model.config.aggregation_labels, dict)
self.assertIsInstance(model.config.no_aggregation_label_index, int)
table_querier = TableQuestionAnsweringPipeline(model=model, tokenizer=tokenizer)
table_querier = TableQuestionAnsweringPipeline(model=model, tokenizer=tokenizer, max_new_tokens=20)
outputs = table_querier(
table={
"actors": ["brad pitt", "leonardo di caprio", "george clooney"],
@ -151,7 +151,7 @@ class TQAPipelineTests(unittest.TestCase):
self.assertIsInstance(model.config.aggregation_labels, dict)
self.assertIsInstance(model.config.no_aggregation_label_index, int)
table_querier = TableQuestionAnsweringPipeline(model=model, tokenizer=tokenizer)
table_querier = TableQuestionAnsweringPipeline(model=model, tokenizer=tokenizer, max_new_tokens=20)
outputs = table_querier(
table={
"actors": ["brad pitt", "leonardo di caprio", "george clooney"],
@ -254,7 +254,7 @@ class TQAPipelineTests(unittest.TestCase):
model_id = "lysandre/tiny-tapas-random-sqa"
model = AutoModelForTableQuestionAnswering.from_pretrained(model_id, torch_dtype=torch_dtype)
tokenizer = AutoTokenizer.from_pretrained(model_id)
table_querier = TableQuestionAnsweringPipeline(model=model, tokenizer=tokenizer)
table_querier = TableQuestionAnsweringPipeline(model=model, tokenizer=tokenizer, max_new_tokens=20)
inputs = {
"table": {
@ -274,7 +274,7 @@ class TQAPipelineTests(unittest.TestCase):
self.assertNotEqual(sequential_outputs[1], batch_outputs[1])
# self.assertNotEqual(sequential_outputs[2], batch_outputs[2])
table_querier = TableQuestionAnsweringPipeline(model=model, tokenizer=tokenizer)
table_querier = TableQuestionAnsweringPipeline(model=model, tokenizer=tokenizer, max_new_tokens=20)
outputs = table_querier(
table={
"actors": ["brad pitt", "leonardo di caprio", "george clooney"],
@ -380,7 +380,7 @@ class TQAPipelineTests(unittest.TestCase):
model_id = "lysandre/tiny-tapas-random-sqa"
model = TFAutoModelForTableQuestionAnswering.from_pretrained(model_id, from_pt=True)
tokenizer = AutoTokenizer.from_pretrained(model_id)
table_querier = TableQuestionAnsweringPipeline(model=model, tokenizer=tokenizer)
table_querier = TableQuestionAnsweringPipeline(model=model, tokenizer=tokenizer, max_new_tokens=20)
inputs = {
"table": {
@ -400,7 +400,7 @@ class TQAPipelineTests(unittest.TestCase):
self.assertNotEqual(sequential_outputs[1], batch_outputs[1])
# self.assertNotEqual(sequential_outputs[2], batch_outputs[2])
table_querier = TableQuestionAnsweringPipeline(model=model, tokenizer=tokenizer)
table_querier = TableQuestionAnsweringPipeline(model=model, tokenizer=tokenizer, max_new_tokens=20)
outputs = table_querier(
table={
"actors": ["brad pitt", "leonardo di caprio", "george clooney"],

18
tests/pipelines/test_pipelines_text2text_generation.py
View File

@ -20,7 +20,7 @@ from transformers import (
Text2TextGenerationPipeline,
pipeline,
)
from transformers.testing_utils import is_pipeline_test, require_tf, require_torch
from transformers.testing_utils import is_pipeline_test, require_torch
from transformers.utils import is_torch_available
from .test_pipelines_common import ANY
@ -51,6 +51,7 @@ class Text2TextGenerationPipelineTests(unittest.TestCase):
image_processor=image_processor,
processor=processor,
torch_dtype=torch_dtype,
max_new_tokens=20,
)
return generator, ["Something to write", "Something else"]
@ -85,7 +86,13 @@ class Text2TextGenerationPipelineTests(unittest.TestCase):
@require_torch
def test_small_model_pt(self):
generator = pipeline("text2text-generation", model="patrickvonplaten/t5-tiny-random", framework="pt")
generator = pipeline(
"text2text-generation",
model="patrickvonplaten/t5-tiny-random",
framework="pt",
num_beams=1,
max_new_tokens=9,
)
# do_sample=False necessary for reproducibility
outputs = generator("Something there", do_sample=False)
self.assertEqual(outputs, [{"generated_text": ""}])
@ -133,10 +140,3 @@ class Text2TextGenerationPipelineTests(unittest.TestCase):
],
],
)
@require_tf
def test_small_model_tf(self):
generator = pipeline("text2text-generation", model="patrickvonplaten/t5-tiny-random", framework="tf")
# do_sample=False necessary for reproducibility
outputs = generator("Something there", do_sample=False)
self.assertEqual(outputs, [{"generated_text": ""}])

269
tests/pipelines/test_pipelines_text_generation.py
View File

@ -25,7 +25,6 @@ from transformers.testing_utils import (
CaptureLogger,
is_pipeline_test,
require_accelerate,
require_tf,
require_torch,
require_torch_accelerator,
require_torch_or_tf,
@ -43,41 +42,22 @@ class TextGenerationPipelineTests(unittest.TestCase):
@require_torch
def test_small_model_pt(self):
text_generator = pipeline(task="text-generation", model="sshleifer/tiny-ctrl", framework="pt")
text_generator = pipeline(
task="text-generation",
model="hf-internal-testing/tiny-random-LlamaForCausalLM",
framework="pt",
max_new_tokens=10,
)
# Using `do_sample=False` to force deterministic output
outputs = text_generator("This is a test", do_sample=False)
self.assertEqual(
outputs,
[
{
"generated_text": (
"This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope."
" oscope. FiliFili@@"
)
}
],
)
self.assertEqual(outputs, [{"generated_text": "This is a testкт MéxicoWSAnimImportдели pip letscosatur"}])
outputs = text_generator(["This is a test", "This is a second test"])
outputs = text_generator(["This is a test", "This is a second test"], do_sample=False)
self.assertEqual(
outputs,
[
[
{
"generated_text": (
"This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope."
" oscope. FiliFili@@"
)
}
],
[
{
"generated_text": (
"This is a second test ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy"
" oscope. oscope. FiliFili@@"
)
}
],
[{"generated_text": "This is a testкт MéxicoWSAnimImportдели pip letscosatur"}],
[{"generated_text": "This is a second testкт MéxicoWSAnimImportдели Düsseld bootstrap learn user"}],
],
)
@ -90,64 +70,12 @@ class TextGenerationPipelineTests(unittest.TestCase):
],
)
## -- test tokenizer_kwargs
test_str = "testing tokenizer kwargs. using truncation must result in a different generation."
input_len = len(text_generator.tokenizer(test_str)["input_ids"])
output_str, output_str_with_truncation = (
text_generator(test_str, do_sample=False, return_full_text=False, min_new_tokens=1)[0]["generated_text"],
text_generator(
test_str,
do_sample=False,
return_full_text=False,
min_new_tokens=1,
truncation=True,
max_length=input_len + 1,
)[0]["generated_text"],
)
assert output_str != output_str_with_truncation # results must be different because one had truncation
## -- test kwargs for preprocess_params
outputs = text_generator("This is a test", do_sample=False, add_special_tokens=False, padding=False)
self.assertEqual(
outputs,
[
{
"generated_text": (
"This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope."
" oscope. FiliFili@@"
)
}
],
)
# -- what is the point of this test? padding is hardcoded False in the pipeline anyway
text_generator.tokenizer.pad_token_id = text_generator.model.config.eos_token_id
text_generator.tokenizer.pad_token = "<pad>"
outputs = text_generator(
["This is a test", "This is a second test"],
do_sample=True,
num_return_sequences=2,
batch_size=2,
return_tensors=True,
)
self.assertEqual(
outputs,
[
[
{"generated_token_ids": ANY(list)},
{"generated_token_ids": ANY(list)},
],
[
{"generated_token_ids": ANY(list)},
{"generated_token_ids": ANY(list)},
],
],
)
@require_torch
def test_small_chat_model_pt(self):
text_generator = pipeline(
task="text-generation", model="hf-internal-testing/tiny-gpt2-with-chatml-template", framework="pt"
task="text-generation",
model="hf-internal-testing/tiny-gpt2-with-chatml-template",
framework="pt",
)
# Using `do_sample=False` to force deterministic output
chat1 = [
@ -193,7 +121,9 @@ class TextGenerationPipelineTests(unittest.TestCase):
# Here we check that passing a chat that ends in an assistant message is handled correctly
# by continuing the final message rather than starting a new one
text_generator = pipeline(
task="text-generation", model="hf-internal-testing/tiny-gpt2-with-chatml-template", framework="pt"
task="text-generation",
model="hf-internal-testing/tiny-gpt2-with-chatml-template",
framework="pt",
)
# Using `do_sample=False` to force deterministic output
chat1 = [
@ -225,7 +155,9 @@ class TextGenerationPipelineTests(unittest.TestCase):
# Here we check that passing a chat that ends in an assistant message is handled correctly
# by continuing the final message rather than starting a new one
text_generator = pipeline(
task="text-generation", model="hf-internal-testing/tiny-gpt2-with-chatml-template", framework="pt"
task="text-generation",
model="hf-internal-testing/tiny-gpt2-with-chatml-template",
framework="pt",
)
# Using `do_sample=False` to force deterministic output
chat1 = [
@ -271,7 +203,9 @@ class TextGenerationPipelineTests(unittest.TestCase):
return {"text": self.data[i]}
text_generator = pipeline(
task="text-generation", model="hf-internal-testing/tiny-gpt2-with-chatml-template", framework="pt"
task="text-generation",
model="hf-internal-testing/tiny-gpt2-with-chatml-template",
framework="pt",
)
dataset = MyDataset()
@ -296,7 +230,9 @@ class TextGenerationPipelineTests(unittest.TestCase):
from transformers.pipelines.pt_utils import PipelineIterator
text_generator = pipeline(
task="text-generation", model="hf-internal-testing/tiny-gpt2-with-chatml-template", framework="pt"
task="text-generation",
model="hf-internal-testing/tiny-gpt2-with-chatml-template",
framework="pt",
)
# Using `do_sample=False` to force deterministic output
@ -335,91 +271,6 @@ class TextGenerationPipelineTests(unittest.TestCase):
],
)
@require_tf
def test_small_model_tf(self):
text_generator = pipeline(task="text-generation", model="sshleifer/tiny-ctrl", framework="tf")
# Using `do_sample=False` to force deterministic output
outputs = text_generator("This is a test", do_sample=False)
self.assertEqual(
outputs,
[
{
"generated_text": (
"This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵"
" please,"
)
}
],
)
outputs = text_generator(["This is a test", "This is a second test"], do_sample=False)
self.assertEqual(
outputs,
[
[
{
"generated_text": (
"This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵"
" please,"
)
}
],
[
{
"generated_text": (
"This is a second test Chieftain Chieftain prefecture prefecture prefecture Cannes Cannes"
" Cannes 閲閲Cannes Cannes Cannes 攵 please,"
)
}
],
],
)
@require_tf
def test_small_chat_model_tf(self):
text_generator = pipeline(
task="text-generation", model="hf-internal-testing/tiny-gpt2-with-chatml-template", framework="tf"
)
# Using `do_sample=False` to force deterministic output
chat1 = [
{"role": "system", "content": "This is a system message."},
{"role": "user", "content": "This is a test"},
]
chat2 = [
{"role": "system", "content": "This is a system message."},
{"role": "user", "content": "This is a second test"},
]
outputs = text_generator(chat1, do_sample=False, max_new_tokens=10)
expected_chat1 = chat1 + [
{
"role": "assistant",
"content": " factors factors factors factors factors factors factors factors factors factors",
}
]
self.assertEqual(
outputs,
[
{"generated_text": expected_chat1},
],
)
outputs = text_generator([chat1, chat2], do_sample=False, max_new_tokens=10)
expected_chat2 = chat2 + [
{
"role": "assistant",
"content": " stairs stairs stairs stairs stairs stairs stairs stairs stairs stairs",
}
]
self.assertEqual(
outputs,
[
[{"generated_text": expected_chat1}],
[{"generated_text": expected_chat2}],
],
)
def get_test_pipeline(
self,
model,
@ -436,16 +287,19 @@ class TextGenerationPipelineTests(unittest.TestCase):
image_processor=image_processor,
processor=processor,
torch_dtype=torch_dtype,
max_new_tokens=5,
)
return text_generator, ["This is a test", "Another test"]
def test_stop_sequence_stopping_criteria(self):
prompt = """Hello I believe in"""
text_generator = pipeline("text-generation", model="hf-internal-testing/tiny-random-gpt2")
text_generator = pipeline(
"text-generation", model="hf-internal-testing/tiny-random-gpt2", max_new_tokens=5, do_sample=False
)
output = text_generator(prompt)
self.assertEqual(
output,
[{"generated_text": "Hello I believe in fe fe fe fe fe fe fe fe fe fe fe fe"}],
[{"generated_text": "Hello I believe in fe fe fe fe fe"}],
)
output = text_generator(prompt, stop_sequence=" fe")
@ -463,7 +317,9 @@ class TextGenerationPipelineTests(unittest.TestCase):
self.assertEqual(outputs, [{"generated_text": ANY(str)}])
self.assertNotIn("This is a test", outputs[0]["generated_text"])
text_generator = pipeline(task="text-generation", model=model, tokenizer=tokenizer, return_full_text=False)
text_generator = pipeline(
task="text-generation", model=model, tokenizer=tokenizer, return_full_text=False, max_new_tokens=5
)
outputs = text_generator("This is a test")
self.assertEqual(outputs, [{"generated_text": ANY(str)}])
self.assertNotIn("This is a test", outputs[0]["generated_text"])
@ -538,9 +394,9 @@ class TextGenerationPipelineTests(unittest.TestCase):
# Handling of large generations
if str(text_generator.device) == "cpu":
with self.assertRaises((RuntimeError, IndexError, ValueError, AssertionError)):
text_generator("This is a test" * 500, max_new_tokens=20)
text_generator("This is a test" * 500, max_new_tokens=5)
outputs = text_generator("This is a test" * 500, handle_long_generation="hole", max_new_tokens=20)
outputs = text_generator("This is a test" * 500, handle_long_generation="hole", max_new_tokens=5)
# Hole strategy cannot work
if str(text_generator.device) == "cpu":
with self.assertRaises(ValueError):
@ -560,51 +416,40 @@ class TextGenerationPipelineTests(unittest.TestCase):
pipe = pipeline(
model="hf-internal-testing/tiny-random-bloom",
model_kwargs={"device_map": "auto", "torch_dtype": torch.bfloat16},
max_new_tokens=5,
do_sample=False,
)
self.assertEqual(pipe.model.lm_head.weight.dtype, torch.bfloat16)
out = pipe("This is a test")
self.assertEqual(
out,
[
{
"generated_text": (
"This is a test test test test test test test test test test test test test test test test"
" test"
)
}
],
[{"generated_text": ("This is a test test test test test test")}],
)
# Upgraded those two to real pipeline arguments (they just get sent for the model as they're unlikely to mean anything else.)
pipe = pipeline(model="hf-internal-testing/tiny-random-bloom", device_map="auto", torch_dtype=torch.bfloat16)
pipe = pipeline(
model="hf-internal-testing/tiny-random-bloom",
device_map="auto",
torch_dtype=torch.bfloat16,
max_new_tokens=5,
do_sample=False,
)
self.assertEqual(pipe.model.lm_head.weight.dtype, torch.bfloat16)
out = pipe("This is a test")
self.assertEqual(
out,
[
{
"generated_text": (
"This is a test test test test test test test test test test test test test test test test"
" test"
)
}
],
[{"generated_text": ("This is a test test test test test test")}],
)
# torch_dtype will be automatically set to float32 if not provided - check: https://github.com/huggingface/transformers/pull/20602
pipe = pipeline(model="hf-internal-testing/tiny-random-bloom", device_map="auto")
pipe = pipeline(
model="hf-internal-testing/tiny-random-bloom", device_map="auto", max_new_tokens=5, do_sample=False
)
self.assertEqual(pipe.model.lm_head.weight.dtype, torch.float32)
out = pipe("This is a test")
self.assertEqual(
out,
[
{
"generated_text": (
"This is a test test test test test test test test test test test test test test test test"
" test"
)
}
],
[{"generated_text": ("This is a test test test test test test")}],
)
@require_torch
@ -616,6 +461,7 @@ class TextGenerationPipelineTests(unittest.TestCase):
model="hf-internal-testing/tiny-random-bloom",
device=torch_device,
torch_dtype=torch.float16,
max_new_tokens=3,
)
pipe("This is a test")
@ -626,13 +472,16 @@ class TextGenerationPipelineTests(unittest.TestCase):
import torch
pipe = pipeline(
model="hf-internal-testing/tiny-random-bloom", device_map=torch_device, torch_dtype=torch.float16
model="hf-internal-testing/tiny-random-bloom",
device_map=torch_device,
torch_dtype=torch.float16,
max_new_tokens=3,
)
pipe("This is a test", do_sample=True, top_p=0.5)
def test_pipeline_length_setting_warning(self):
prompt = """Hello world"""
text_generator = pipeline("text-generation", model="hf-internal-testing/tiny-random-gpt2")
text_generator = pipeline("text-generation", model="hf-internal-testing/tiny-random-gpt2", max_new_tokens=5)
if text_generator.model.framework == "tf":
logger = logging.get_logger("transformers.generation.tf_utils")
else:
@ -650,11 +499,11 @@ class TextGenerationPipelineTests(unittest.TestCase):
self.assertNotIn(logger_msg, cl.out)
with CaptureLogger(logger) as cl:
_ = text_generator(prompt, max_length=10)
_ = text_generator(prompt, max_length=10, max_new_tokens=None)
self.assertNotIn(logger_msg, cl.out)
def test_return_dict_in_generate(self):
text_generator = pipeline("text-generation", model="hf-internal-testing/tiny-random-gpt2", max_new_tokens=16)
text_generator = pipeline("text-generation", model="hf-internal-testing/tiny-random-gpt2", max_new_tokens=2)
out = text_generator(
["This is great !", "Something else"], return_dict_in_generate=True, output_logits=True, output_scores=True
)
@ -682,7 +531,7 @@ class TextGenerationPipelineTests(unittest.TestCase):
def test_pipeline_assisted_generation(self):
"""Tests that we can run assisted generation in the pipeline"""
model = "hf-internal-testing/tiny-random-MistralForCausalLM"
pipe = pipeline("text-generation", model=model, assistant_model=model)
pipe = pipeline("text-generation", model=model, assistant_model=model, max_new_tokens=2)
# We can run the pipeline
prompt = "Hello world"

40
tests/pipelines/test_pipelines_text_to_audio.py
View File

@ -41,25 +41,23 @@ class TextToAudioPipelineTests(unittest.TestCase):
model_mapping = MODEL_FOR_TEXT_TO_WAVEFORM_MAPPING
# for now only test text_to_waveform and not text_to_spectrogram
@slow
@require_torch
def test_small_musicgen_pt(self):
music_generator = pipeline(task="text-to-audio", model="facebook/musicgen-small", framework="pt")
music_generator = pipeline(
task="text-to-audio", model="facebook/musicgen-small", framework="pt", do_sample=False, max_new_tokens=5
)
forward_params = {
"do_sample": False,
"max_new_tokens": 250,
}
outputs = music_generator("This is a test", forward_params=forward_params)
outputs = music_generator("This is a test")
self.assertEqual({"audio": ANY(np.ndarray), "sampling_rate": 32000}, outputs)
# test two examples side-by-side
outputs = music_generator(["This is a test", "This is a second test"], forward_params=forward_params)
outputs = music_generator(["This is a test", "This is a second test"])
audio = [output["audio"] for output in outputs]
self.assertEqual([ANY(np.ndarray), ANY(np.ndarray)], audio)
# test batching
# test batching, this time with parameterization in the forward pass
music_generator = pipeline(task="text-to-audio", model="facebook/musicgen-small", framework="pt")
forward_params = {"do_sample": False, "max_new_tokens": 5}
outputs = music_generator(
["This is a test", "This is a second test"], forward_params=forward_params, batch_size=2
)
@ -69,7 +67,9 @@ class TextToAudioPipelineTests(unittest.TestCase):
@slow
@require_torch
def test_medium_seamless_m4t_pt(self):
speech_generator = pipeline(task="text-to-audio", model="facebook/hf-seamless-m4t-medium", framework="pt")
speech_generator = pipeline(
task="text-to-audio", model="facebook/hf-seamless-m4t-medium", framework="pt", max_new_tokens=5
)
for forward_params in [{"tgt_lang": "eng"}, {"return_intermediate_token_ids": True, "tgt_lang": "eng"}]:
outputs = speech_generator("This is a test", forward_params=forward_params)
@ -95,7 +95,7 @@ class TextToAudioPipelineTests(unittest.TestCase):
forward_params = {
# Using `do_sample=False` to force deterministic output
"do_sample": False,
"semantic_max_new_tokens": 100,
"semantic_max_new_tokens": 5,
}
outputs = speech_generator("This is a test", forward_params=forward_params)
@ -115,7 +115,7 @@ class TextToAudioPipelineTests(unittest.TestCase):
# test other generation strategy
forward_params = {
"do_sample": True,
"semantic_max_new_tokens": 100,
"semantic_max_new_tokens": 5,
"semantic_num_return_sequences": 2,
}
@ -145,7 +145,7 @@ class TextToAudioPipelineTests(unittest.TestCase):
forward_params = {
"do_sample": True,
"semantic_max_new_tokens": 100,
"semantic_max_new_tokens": 5,
}
# atm, must do to stay coherent with BarkProcessor
@ -176,7 +176,6 @@ class TextToAudioPipelineTests(unittest.TestCase):
outputs,
)
@slow
@require_torch
def test_vits_model_pt(self):
speech_generator = pipeline(task="text-to-audio", model="facebook/mms-tts-eng", framework="pt")
@ -196,7 +195,6 @@ class TextToAudioPipelineTests(unittest.TestCase):
outputs = speech_generator(["This is a test", "This is a second test"], batch_size=2)
self.assertEqual(ANY(np.ndarray), outputs[0]["audio"])
@slow
@require_torch
def test_forward_model_kwargs(self):
# use vits - a forward model
@ -221,7 +219,6 @@ class TextToAudioPipelineTests(unittest.TestCase):
)
self.assertTrue(np.abs(outputs["audio"] - audio).max() < 1e-5)
@slow
@require_torch
def test_generative_model_kwargs(self):
# use musicgen - a generative model
@ -229,7 +226,7 @@ class TextToAudioPipelineTests(unittest.TestCase):
forward_params = {
"do_sample": True,
"max_new_tokens": 250,
"max_new_tokens": 20,
}
# for reproducibility
@ -241,7 +238,7 @@ class TextToAudioPipelineTests(unittest.TestCase):
# make sure generate kwargs get priority over forward params
forward_params = {
"do_sample": False,
"max_new_tokens": 250,
"max_new_tokens": 20,
}
generate_kwargs = {"do_sample": True}
@ -259,6 +256,9 @@ class TextToAudioPipelineTests(unittest.TestCase):
processor=None,
torch_dtype="float32",
):
model_test_kwargs = {}
if model.can_generate(): # not all models in this pipeline can generate and, therefore, take `generate` kwargs
model_test_kwargs["max_new_tokens"] = 5
speech_generator = TextToAudioPipeline(
model=model,
tokenizer=tokenizer,
@ -266,7 +266,9 @@ class TextToAudioPipelineTests(unittest.TestCase):
image_processor=image_processor,
processor=processor,
torch_dtype=torch_dtype,
**model_test_kwargs,
)
return speech_generator, ["This is a test", "Another test"]
def run_pipeline_test(self, speech_generator, _):

36
tests/pipelines/test_pipelines_translation.py
View File

@ -25,7 +25,7 @@ from transformers import (
TranslationPipeline,
pipeline,
)
from transformers.testing_utils import is_pipeline_test, require_tf, require_torch, slow
from transformers.testing_utils import is_pipeline_test, require_torch, slow
from .test_pipelines_common import ANY
@ -55,6 +55,7 @@ class TranslationPipelineTests(unittest.TestCase):
torch_dtype=torch_dtype,
src_lang=src_lang,
tgt_lang=tgt_lang,
max_new_tokens=20,
)
else:
translator = TranslationPipeline(
@ -64,6 +65,7 @@ class TranslationPipelineTests(unittest.TestCase):
image_processor=image_processor,
processor=processor,
torch_dtype=torch_dtype,
max_new_tokens=20,
)
return translator, ["Some string", "Some other text"]
@ -93,22 +95,6 @@ class TranslationPipelineTests(unittest.TestCase):
],
)
@require_tf
def test_small_model_tf(self):
translator = pipeline("translation_en_to_ro", model="patrickvonplaten/t5-tiny-random", framework="tf")
outputs = translator("This is a test string", max_length=20)
self.assertEqual(
outputs,
[
{
"translation_text": (
"Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide"
" Beide Beide"
)
}
],
)
@require_torch
def test_en_to_de_pt(self):
translator = pipeline("translation_en_to_de", model="patrickvonplaten/t5-tiny-random", framework="pt")
@ -125,22 +111,6 @@ class TranslationPipelineTests(unittest.TestCase):
],
)
@require_tf
def test_en_to_de_tf(self):
translator = pipeline("translation_en_to_de", model="patrickvonplaten/t5-tiny-random", framework="tf")
outputs = translator("This is a test string", max_length=20)
self.assertEqual(
outputs,
[
{
"translation_text": (
"monoton monoton monoton monoton monoton monoton monoton monoton monoton monoton urine urine"
" urine urine urine urine urine urine urine"
)
}
],
)
class TranslationNewFormatPipelineTests(unittest.TestCase):
@require_torch