transformers 5.0.0rc3__py3-none-any.whl → 5.1.0__py3-none-any.whl

{transformers-5.0.0rc3.dist-info → transformers-5.1.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

transformers/pipelines/deprecated/text2text_generation.py

@@ -1,408 +0,0 @@
-import enum
-import warnings
-from typing import Any
-
-from ...generation import GenerationConfig
-from ...tokenization_python import TruncationStrategy
-from ...utils import add_end_docstrings, is_torch_available, logging
-from ..base import Pipeline, build_pipeline_init_args
-
-
-if is_torch_available():
-    from ...models.auto.modeling_auto import MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING_NAMES
-
-logger = logging.get_logger(__name__)
-
-
-class ReturnType(enum.Enum):
-    TENSORS = 0
-    TEXT = 1
-
-
-@add_end_docstrings(build_pipeline_init_args(has_tokenizer=True))
-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
-    >>> from transformers import pipeline
-
-    >>> generator = pipeline(model="mrm8488/t5-base-finetuned-question-generation-ap")
-    >>> generator(
-    ...     "answer: Manuel context: Manuel has created RuPERTa-base with the support of HF-Transformers and Google"
-    ... )
-    [{'generated_text': 'question: Who created the RuPERTa-base?'}]
-    ```
-
-    Learn more about the basics of using a pipeline in the [pipeline tutorial](../pipeline_tutorial). You can pass text
-    generation parameters to this pipeline to control stopping criteria, decoding strategy, and more. Learn more about
-    text generation parameters in [Text generation strategies](../generation_strategies) and [Text
-    generation](text_generation).
-
-    This Text2TextGenerationPipeline pipeline can currently be loaded from [`pipeline`] using the following task
-    identifier: `"text2text-generation"`.
-
-    The models that this pipeline can use are models that have been fine-tuned on a translation task. See the
-    up-to-date list of available models on
-    [huggingface.co/models](https://huggingface.co/models?filter=text2text-generation). For a list of available
-    parameters, see the [following
-    documentation](https://huggingface.co/docs/transformers/en/main_classes/text_generation#transformers.generation.GenerationMixin.generate)
-
-    Usage:
-
-    ```python
-    text2text_generator = pipeline("text2text-generation")
-    text2text_generator("question: What is 42 ? context: 42 is the answer to life, the universe and everything")
-    ```"""
-
-    _pipeline_calls_generate = True
-    _load_processor = False
-    _load_image_processor = False
-    _load_feature_extractor = False
-    _load_tokenizer = 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"
-
-    def __init__(self, *args, **kwargs):
-        if self.return_name == "generated":  # Check this isn't summarization/translation instead
-            logger.warning_once(
-                "The `Text2TextGenerationPipeline` is deprecated and no longer maintained. For most "
-                "purposes, we recommend using newer models with causal pipelines like "
-                "`TextGenerationPipeline` or `ImageTextToTextPipeline`."
-            )
-        super().__init__(*args, **kwargs)
-
-        self.check_model_type(MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING_NAMES)
-
-    def _sanitize_parameters(
-        self,
-        return_tensors=None,
-        return_text=None,
-        return_type=None,
-        clean_up_tokenization_spaces=None,
-        truncation=None,
-        stop_sequence=None,
-        **generate_kwargs,
-    ):
-        preprocess_params = {}
-        if truncation is not None:
-            preprocess_params["truncation"] = truncation
-
-        forward_params = generate_kwargs
-
-        postprocess_params = {}
-        if return_tensors is not None and return_type is None:
-            return_type = ReturnType.TENSORS if return_tensors else ReturnType.TEXT
-        if return_type is not None:
-            postprocess_params["return_type"] = return_type
-
-        if clean_up_tokenization_spaces is not None:
-            postprocess_params["clean_up_tokenization_spaces"] = clean_up_tokenization_spaces
-
-        if stop_sequence is not None:
-            stop_sequence_ids = self.tokenizer.encode(stop_sequence, add_special_tokens=False)
-            if len(stop_sequence_ids) > 1:
-                warnings.warn(
-                    "Stopping on a multiple token sequence is not yet supported on transformers. The first token of"
-                    " the stop sequence will be used as the stop sequence string in the interim."
-                )
-            generate_kwargs["eos_token_id"] = stop_sequence_ids[0]
-
-        if self.assistant_model is not None:
-            forward_params["assistant_model"] = self.assistant_model
-        if self.assistant_tokenizer is not None:
-            forward_params["tokenizer"] = self.tokenizer
-            forward_params["assistant_tokenizer"] = self.assistant_tokenizer
-
-        return preprocess_params, forward_params, postprocess_params
-
-    def check_inputs(self, input_length: int, min_length: int, max_new_tokens: int):
-        """
-        Checks whether there might be something wrong with given input with regard to the model.
-        """
-        return True
-
-    def _parse_and_tokenize(self, *args, truncation):
-        prefix = self.prefix if self.prefix is not None else ""
-        if isinstance(args[0], list):
-            if self.tokenizer.pad_token_id is None:
-                raise ValueError("Please make sure that the tokenizer has a pad_token_id when using a batch input")
-            args = ([prefix + arg for arg in args[0]],)
-            padding = True
-
-        elif isinstance(args[0], str):
-            args = (prefix + args[0],)
-            padding = False
-        else:
-            raise TypeError(
-                f" `args[0]`: {args[0]} have the wrong format. The should be either of type `str` or type `list`"
-            )
-        inputs = self.tokenizer(*args, padding=padding, truncation=truncation, return_tensors="pt")
-        # This is produced by tokenizers but is an invalid generate kwargs
-        if "token_type_ids" in inputs:
-            del inputs["token_type_ids"]
-        return inputs
-
-    def __call__(self, *args: str | list[str], **kwargs: Any) -> list[dict[str, str]]:
-        r"""
-        Generate the output text(s) using text(s) given as inputs.
-
-        Args:
-            args (`str` or `list[str]`):
-                Input text for the encoder.
-            return_tensors (`bool`, *optional*, defaults to `False`):
-                Whether or not to include the tensors of predictions (as token indices) in the outputs.
-            return_text (`bool`, *optional*, defaults to `True`):
-                Whether or not to include the decoded texts in the outputs.
-            clean_up_tokenization_spaces (`bool`, *optional*, defaults to `False`):
-                Whether or not to clean up the potential extra spaces in the text output.
-            truncation (`TruncationStrategy`, *optional*, defaults to `TruncationStrategy.DO_NOT_TRUNCATE`):
-                The truncation strategy for the tokenization within the pipeline. `TruncationStrategy.DO_NOT_TRUNCATE`
-                (default) will never truncate, but it is sometimes desirable to truncate the input to fit the model's
-                max_length instead of throwing an error down the line.
-            generate_kwargs:
-                Additional keyword arguments to pass along to the generate method of the model (see the generate method
-                [here](./text_generation)).
-
-        Return:
-            A list or a list of list of `dict`: Each result comes as a dictionary with the following keys:
-
-            - **generated_text** (`str`, present when `return_text=True`) -- The generated text.
-            - **generated_token_ids** (`torch.Tensor`, present when `return_tensors=True`) -- The token
-              ids of the generated text.
-        """
-
-        result = super().__call__(*args, **kwargs)
-        if (
-            isinstance(args[0], list)
-            and all(isinstance(el, str) for el in args[0])
-            and all(len(res) == 1 for res in result)
-        ):
-            return [res[0] for res in result]
-        return result
-
-    def preprocess(self, inputs, truncation=TruncationStrategy.DO_NOT_TRUNCATE, **kwargs):
-        inputs = self._parse_and_tokenize(inputs, truncation=truncation, **kwargs)
-        return inputs
-
-    def _forward(self, model_inputs, **generate_kwargs):
-        in_b, input_length = model_inputs["input_ids"].shape
-        # User-defined `generation_config` passed to the pipeline call take precedence
-        if "generation_config" not in generate_kwargs:
-            generate_kwargs["generation_config"] = self.generation_config
-
-        min_length = generate_kwargs.get("min_length", generate_kwargs["generation_config"].min_length)
-        max_new_tokens = generate_kwargs.get("max_new_tokens", generate_kwargs["generation_config"].max_new_tokens)
-        self.check_inputs(input_length, min_length, max_new_tokens)
-        output_ids = self.model.generate(**model_inputs, **generate_kwargs)
-        out_b = output_ids.shape[0]
-        output_ids = output_ids.reshape(in_b, out_b // in_b, *output_ids.shape[1:])
-        return {"output_ids": output_ids}
-
-    def postprocess(self, model_outputs, return_type=ReturnType.TEXT, clean_up_tokenization_spaces=False):
-        records = []
-        for output_ids in model_outputs["output_ids"][0]:
-            if return_type == ReturnType.TENSORS:
-                record = {f"{self.return_name}_token_ids": output_ids}
-            elif return_type == ReturnType.TEXT:
-                record = {
-                    f"{self.return_name}_text": self.tokenizer.decode(
-                        output_ids,
-                        skip_special_tokens=True,
-                        clean_up_tokenization_spaces=clean_up_tokenization_spaces,
-                    )
-                }
-            records.append(record)
-        return records
-
-
-@add_end_docstrings(build_pipeline_init_args(has_tokenizer=True))
-class SummarizationPipeline(Text2TextGenerationPipeline):
-    """
-    Summarize news articles and other documents.
-
-    This summarizing pipeline can currently be loaded from [`pipeline`] using the following task identifier:
-    `"summarization"`.
-
-    The models that this pipeline can use are models that have been fine-tuned on a summarization task, which is
-    currently, '*bart-large-cnn*', '*google-t5/t5-small*', '*google-t5/t5-base*', '*google-t5/t5-large*', '*google-t5/t5-3b*', '*google-t5/t5-11b*'. See the up-to-date
-    list of available models on [huggingface.co/models](https://huggingface.co/models?filter=summarization). 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
-    # use bart
-    summarizer = pipeline("summarization")
-    summarizer("An apple a day, keeps the doctor away", min_length=5, max_length=20)
-
-    ```"""
-
-    # Used in the return key of the pipeline.
-    return_name = "summary"
-
-    def __init__(self, *args, **kwargs):
-        logger.warning_once(
-            "The `SummarizationPipeline` is deprecated and no longer maintained. For most "
-            "summarization tasks, we recommend appropriately prompting modern general-purpose LLMs "
-            "via pipelines like `TextGenerationPipeline` or `ImageTextToTextPipeline`."
-        )
-        super().__init__(*args, **kwargs)
-
-    def __call__(self, *args, **kwargs):
-        r"""
-        Summarize the text(s) given as inputs.
-
-        Args:
-            documents (*str* or `list[str]`):
-                One or several articles (or one list of articles) to summarize.
-            return_text (`bool`, *optional*, defaults to `True`):
-                Whether or not to include the decoded texts in the outputs
-            return_tensors (`bool`, *optional*, defaults to `False`):
-                Whether or not to include the tensors of predictions (as token indices) in the outputs.
-            clean_up_tokenization_spaces (`bool`, *optional*, defaults to `False`):
-                Whether or not to clean up the potential extra spaces in the text output.
-            generate_kwargs:
-                Additional keyword arguments to pass along to the generate method of the model (see the generate method
-                [here](./text_generation)).
-
-        Return:
-            A list or a list of list of `dict`: Each result comes as a dictionary with the following keys:
-
-            - **summary_text** (`str`, present when `return_text=True`) -- The summary of the corresponding input.
-            - **summary_token_ids** (`torch.Tensor`, present when `return_tensors=True`) -- The token
-              ids of the summary.
-        """
-        return super().__call__(*args, **kwargs)
-
-    def check_inputs(self, input_length: int, min_length: int, max_new_tokens: int) -> bool:
-        """
-        Checks whether there might be something wrong with given input with regard to the model.
-        """
-        if max_new_tokens < min_length:
-            logger.warning(f"Your min_length={min_length} must be inferior than your max_new_tokens={max_new_tokens}.")
-
-        if input_length < max_new_tokens:
-            logger.warning(
-                f"Your max_new_tokens is set to {max_new_tokens}, but your input_length is only {input_length}. Since this is "
-                "a summarization task, where outputs shorter than the input are typically wanted, you might "
-                f"consider decreasing max_new_tokens manually, e.g. summarizer('...', max_new_tokens={input_length // 2})"
-            )
-
-
-@add_end_docstrings(build_pipeline_init_args(has_tokenizer=True))
-class TranslationPipeline(Text2TextGenerationPipeline):
-    """
-    Translates from one language to another.
-
-    This translation pipeline can currently be loaded from [`pipeline`] using the following task identifier:
-    `"translation_xx_to_yy"`.
-
-    The models that this pipeline can use are models that have been fine-tuned on a translation task. See the
-    up-to-date list of available models on [huggingface.co/models](https://huggingface.co/models?filter=translation).
-    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
-    en_fr_translator = pipeline("translation_en_to_fr")
-    en_fr_translator("How old are you?")
-    ```"""
-
-    # Used in the return key of the pipeline.
-    return_name = "translation"
-
-    def __init__(self, *args, **kwargs):
-        logger.warning_once(
-            "The `TranslationPipeline` is deprecated and no longer maintained. For most "
-            "translation tasks, we recommend appropriately prompting modern general-purpose LLMs "
-            "via pipelines like `TextGenerationPipeline` or `ImageTextToTextPipeline`."
-        )
-        super().__init__(*args, **kwargs)
-
-    def check_inputs(self, input_length: int, min_length: int, max_new_tokens: int):
-        """
-        Removed input length check - unnecessary with max_new_tokens (previously relevant for max_length)
-        """
-        return True
-
-    def preprocess(self, *args, truncation=TruncationStrategy.DO_NOT_TRUNCATE, src_lang=None, tgt_lang=None):
-        if getattr(self.tokenizer, "_build_translation_inputs", None):
-            return self.tokenizer._build_translation_inputs(
-                *args, return_tensors="pt", truncation=truncation, src_lang=src_lang, tgt_lang=tgt_lang
-            )
-        else:
-            return super()._parse_and_tokenize(*args, truncation=truncation)
-
-    def _sanitize_parameters(self, src_lang=None, tgt_lang=None, **kwargs):
-        preprocess_params, forward_params, postprocess_params = super()._sanitize_parameters(**kwargs)
-        if src_lang is not None:
-            preprocess_params["src_lang"] = src_lang
-        if tgt_lang is not None:
-            preprocess_params["tgt_lang"] = tgt_lang
-        if src_lang is None and tgt_lang is None:
-            # Backward compatibility, direct arguments use is preferred.
-            task = kwargs.get("task", self.task)
-            items = task.split("_")
-            if task and len(items) == 4:
-                # translation, XX, to YY
-                preprocess_params["src_lang"] = items[1]
-                preprocess_params["tgt_lang"] = items[3]
-        return preprocess_params, forward_params, postprocess_params
-
-    def __call__(self, *args, **kwargs):
-        r"""
-        Translate the text(s) given as inputs.
-
-        Args:
-            args (`str` or `list[str]`):
-                Texts to be translated.
-            return_tensors (`bool`, *optional*, defaults to `False`):
-                Whether or not to include the tensors of predictions (as token indices) in the outputs.
-            return_text (`bool`, *optional*, defaults to `True`):
-                Whether or not to include the decoded texts in the outputs.
-            clean_up_tokenization_spaces (`bool`, *optional*, defaults to `False`):
-                Whether or not to clean up the potential extra spaces in the text output.
-            src_lang (`str`, *optional*):
-                The language of the input. Might be required for multilingual models. Will not have any effect for
-                single pair translation models
-            tgt_lang (`str`, *optional*):
-                The language of the desired output. Might be required for multilingual models. Will not have any effect
-                for single pair translation models
-            generate_kwargs:
-                Additional keyword arguments to pass along to the generate method of the model (see the generate method
-                [here](./text_generation)).
-
-        Return:
-            A list or a list of list of `dict`: Each result comes as a dictionary with the following keys:
-
-            - **translation_text** (`str`, present when `return_text=True`) -- The translation.
-            - **translation_token_ids** (`torch.Tensor`, present when `return_tensors=True`) -- The
-              token ids of the translation.
-        """
-        return super().__call__(*args, **kwargs)

transformers/pipelines/image_to_text.py

@@ -1,189 +0,0 @@
-# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# 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.
-
-from typing import Any, Union, overload
-
-from ..generation import GenerationConfig
-from ..utils import (
-    add_end_docstrings,
-    is_torch_available,
-    is_vision_available,
-    logging,
-    requires_backends,
-)
-from .base import Pipeline, build_pipeline_init_args
-
-
-if is_vision_available():
-    from PIL import Image
-
-    from ..image_utils import load_image
-
-if is_torch_available():
-    from ..models.auto.modeling_auto import MODEL_FOR_IMAGE_TEXT_TO_TEXT_MAPPING_NAMES
-
-logger = logging.get_logger(__name__)
-
-
-@add_end_docstrings(build_pipeline_init_args(has_tokenizer=True, has_image_processor=True))
-class ImageToTextPipeline(Pipeline):
-    """
-    Image To Text pipeline using a `AutoModelForImageTextToText`. 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
-    >>> from transformers import pipeline
-
-    >>> captioner = pipeline(model="ydshieh/vit-gpt2-coco-en")
-    >>> captioner("https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png")
-    [{'generated_text': 'two birds are standing next to each other '}]
-    ```
-
-    Learn more about the basics of using a pipeline in the [pipeline tutorial](../pipeline_tutorial)
-
-    This image to text pipeline can currently be loaded from pipeline() using the following task identifier:
-    "image-to-text".
-
-    See the list of available models on
-    [huggingface.co/models](https://huggingface.co/models?pipeline_tag=image-to-text).
-    """
-
-    _pipeline_calls_generate = True
-    _load_processor = False
-    _load_image_processor = True
-    _load_feature_extractor = False
-    _load_tokenizer = 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")
-        self.check_model_type(MODEL_FOR_IMAGE_TEXT_TO_TEXT_MAPPING_NAMES)
-
-    def _sanitize_parameters(self, max_new_tokens=None, generate_kwargs=None, prompt=None, timeout=None):
-        forward_params = {}
-        preprocess_params = {}
-
-        if prompt is not None:
-            preprocess_params["prompt"] = prompt
-        if timeout is not None:
-            preprocess_params["timeout"] = timeout
-
-        if max_new_tokens is not None:
-            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)
-
-        if self.assistant_model is not None:
-            forward_params["assistant_model"] = self.assistant_model
-        if self.assistant_tokenizer is not None:
-            forward_params["tokenizer"] = self.tokenizer
-            forward_params["assistant_tokenizer"] = self.assistant_tokenizer
-
-        return preprocess_params, forward_params, {}
-
-    @overload
-    def __call__(self, inputs: Union[str, "Image.Image"], **kwargs: Any) -> list[dict[str, Any]]: ...
-
-    @overload
-    def __call__(self, inputs: list[str] | list["Image.Image"], **kwargs: Any) -> list[list[dict[str, Any]]]: ...
-
-    def __call__(self, inputs: Union[str, list[str], "Image.Image", list["Image.Image"]], **kwargs):
-        """
-        Assign labels to the image(s) passed as inputs.
-
-        Args:
-            inputs (`str`, `list[str]`, `PIL.Image` or `list[PIL.Image]`):
-                The pipeline handles three types of images:
-
-                - A string containing a HTTP(s) link pointing to an image
-                - A string containing a local path to an image
-                - An image loaded in PIL directly
-
-                The pipeline accepts either a single image or a batch of images.
-
-            max_new_tokens (`int`, *optional*):
-                The amount of maximum tokens to generate. By default it will use `generate` default.
-
-            generate_kwargs (`Dict`, *optional*):
-                Pass it to send all of these arguments directly to `generate` allowing full control of this function.
-
-            timeout (`float`, *optional*, defaults to None):
-                The maximum time in seconds to wait for fetching images from the web. If None, no timeout is set and
-                the call may block forever.
-
-        Return:
-            A list or a list of list of `dict`: Each result comes as a dictionary with the following key:
-
-            - **generated_text** (`str`) -- The generated text.
-        """
-        # After deprecation of this is completed, remove the default `None` value for `images`
-        if "images" in kwargs:
-            inputs = kwargs.pop("images")
-        if inputs is None:
-            raise ValueError("Cannot call the image-to-text pipeline without an inputs argument!")
-        return super().__call__(inputs, **kwargs)
-
-    def preprocess(self, image, timeout=None):
-        image = load_image(image, timeout=timeout)
-        model_inputs = self.image_processor(images=image, return_tensors="pt")
-        model_inputs = model_inputs.to(self.dtype)
-
-        if self.model.config.model_type == "git":
-            model_inputs["input_ids"] = None
-
-        return model_inputs
-
-    def _forward(self, model_inputs, **generate_kwargs):
-        # Git model sets `model_inputs["input_ids"] = None` in `preprocess` (when `prompt=None`). In batch model, the
-        # pipeline will group them into a list of `None`, which fail `_forward`. Avoid this by checking it first.
-        if (
-            "input_ids" in model_inputs
-            and isinstance(model_inputs["input_ids"], list)
-            and all(x is None for x in model_inputs["input_ids"])
-        ):
-            model_inputs["input_ids"] = None
-
-        # User-defined `generation_config` passed to the pipeline call take precedence
-        if "generation_config" not in generate_kwargs:
-            generate_kwargs["generation_config"] = self.generation_config
-
-        inputs = model_inputs.pop(self.model.main_input_name)
-        model_outputs = self.model.generate(inputs, **model_inputs, **generate_kwargs)
-        return model_outputs
-
-    def postprocess(self, model_outputs):
-        records = []
-        for output_ids in model_outputs:
-            record = {
-                "generated_text": self.tokenizer.decode(
-                    output_ids,
-                    skip_special_tokens=True,
-                )
-            }
-            records.append(record)
-        return records