Upload configuration_rotary_indictrans.py with huggingface_hub

configuration_rotary_indictrans.py

@@ -1,28 +1,4 @@
-# coding=utf-8
-# Copyright 2023 The IndicTrans2 Authors and AI4Bharat 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.
-""" PyTorch IndicTrans config."""
-
-import json
-from collections import OrderedDict
-from typing import Any, Mapping, Optional
-
-from transformers import PreTrainedTokenizer
 from transformers.configuration_utils import PretrainedConfig
-from transformers.onnx import OnnxConfig, OnnxSeq2SeqConfigWithPast
-from transformers.onnx.utils import compute_effective_axis_dimension
-from transformers.utils import TensorType, is_torch_available
 
 
 # Copied from transformers.models.m2m_100.configuration_m2m_100.M2M100Config->IndicTrans
@@ -79,6 +55,7 @@ class RotaryIndicTransConfig(PretrainedConfig):
         use_cache (`bool`, *optional*, defaults to `True`):
             Whether or not the model should return the last key/values attentions (not used by all models).
     ```"""
+
     model_type = "RotaryIndicTrans"
     keys_to_ignore_at_inference = ["past_key_values"]
     attribute_map = {
@@ -146,7 +123,7 @@ class RotaryIndicTransConfig(PretrainedConfig):
         self.scale_embedding = scale_embedding
         self.share_decoder_input_output_embed = share_decoder_input_output_embed
         self.attn_implementation = attn_implementation
-        
+
         super().__init__(
             pad_token_id=pad_token_id,
             bos_token_id=bos_token_id,
@@ -155,153 +132,3 @@ class RotaryIndicTransConfig(PretrainedConfig):
             decoder_start_token_id=decoder_start_token_id,
             **kwargs,
         )
-
-
-class RotaryIndicTransOnnxConfig(OnnxSeq2SeqConfigWithPast):
-    @property
-    def inputs(self) -> Mapping[str, Mapping[int, str]]:
-        common_inputs = OrderedDict(
-            [
-                ("input_ids", {0: "batch", 1: "encoder_sequence"}),
-                ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
-            ]
-        )
-
-        if self.use_past:
-            common_inputs["decoder_input_ids"] = {0: "batch"}
-            common_inputs["decoder_attention_mask"] = {
-                0: "batch",
-                1: "past_decoder_sequence + sequence",
-            }
-        else:
-            common_inputs["decoder_input_ids"] = {0: "batch", 1: "decoder_sequence"}
-            common_inputs["decoder_attention_mask"] = {
-                0: "batch",
-                1: "decoder_sequence",
-            }
-
-        if self.use_past:
-            self.fill_with_past_key_values_(common_inputs, direction="inputs")
-        return common_inputs
-
-    # Copied from BartOnnxConfig._generate_dummy_inputs_for_sequence_classification_and_question_answering
-    # A better name would be _generate_dummy_inputs_for_encoder_and_decoder because sequence classification and question
-    # answering are not supported for IT2, but this name is preserved to be able to check that the copy matches what
-    # was done for BART so that it can be updated if need be.
-    def _generate_dummy_inputs_for_sequence_classification_and_question_answering(
-        self,
-        tokenizer: PreTrainedTokenizer,
-        batch_size: int = -1,
-        seq_length: int = -1,
-        is_pair: bool = False,
-        framework: Optional[TensorType] = None,
-    ) -> Mapping[str, Any]:
-        # Copied from OnnxConfig.generate_dummy_inputs
-        # Did not use super(OnnxConfigWithPast, self).generate_dummy_inputs for code clarity.
-        # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
-        batch_size = compute_effective_axis_dimension(
-            batch_size,
-            fixed_dimension=OnnxConfig.default_fixed_batch,
-            num_token_to_add=0,
-        )
-
-        # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
-        token_to_add = tokenizer.num_special_tokens_to_add(is_pair)
-        seq_length = compute_effective_axis_dimension(
-            seq_length,
-            fixed_dimension=OnnxConfig.default_fixed_sequence,
-            num_token_to_add=token_to_add,
-        )
-
-        # Generate dummy inputs according to compute batch and sequence
-        dummy_input = [" ".join([tokenizer.unk_token]) * seq_length] * batch_size
-        common_inputs = dict(tokenizer(dummy_input, return_tensors=framework))
-        return common_inputs
-
-    # Copied from transformers.models.bart.configuration_bart.BartOnnxConfig._generate_dummy_inputs_for_default_and_seq2seq_lm
-    def _generate_dummy_inputs_for_default_and_seq2seq_lm(
-        self,
-        tokenizer: PreTrainedTokenizer,
-        batch_size: int = -1,
-        seq_length: int = -1,
-        is_pair: bool = False,
-        framework: Optional[TensorType] = None,
-    ) -> Mapping[str, Any]:
-        encoder_inputs = self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
-            tokenizer, batch_size, seq_length, is_pair, framework
-        )
-
-        # Generate decoder inputs
-        decoder_seq_length = seq_length if not self.use_past else 1
-        decoder_inputs = self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
-            tokenizer, batch_size, decoder_seq_length, is_pair, framework
-        )
-        decoder_inputs = {
-            f"decoder_{name}": tensor for name, tensor in decoder_inputs.items()
-        }
-        common_inputs = dict(**encoder_inputs, **decoder_inputs)
-
-        if self.use_past:
-            if not is_torch_available():
-                raise ValueError(
-                    "Cannot generate dummy past_keys inputs without PyTorch installed."
-                )
-            else:
-                import torch
-            batch, encoder_seq_length = common_inputs["input_ids"].shape
-            decoder_seq_length = common_inputs["decoder_input_ids"].shape[1]
-            (
-                num_encoder_attention_heads,
-                num_decoder_attention_heads,
-            ) = self.num_attention_heads
-            encoder_shape = (
-                batch,
-                num_encoder_attention_heads,
-                encoder_seq_length,
-                self._config.hidden_size // num_encoder_attention_heads,
-            )
-            decoder_past_length = decoder_seq_length + 3
-            decoder_shape = (
-                batch,
-                num_decoder_attention_heads,
-                decoder_past_length,
-                self._config.hidden_size // num_decoder_attention_heads,
-            )
-
-            common_inputs["decoder_attention_mask"] = torch.cat(
-                [
-                    common_inputs["decoder_attention_mask"],
-                    torch.ones(batch, decoder_past_length),
-                ],
-                dim=1,
-            )
-
-            common_inputs["past_key_values"] = []
-            # If the number of encoder and decoder layers are present in the model configuration, both are considered
-            num_encoder_layers, num_decoder_layers = self.num_layers
-            min_num_layers = min(num_encoder_layers, num_decoder_layers)
-            max_num_layers = (
-                max(num_encoder_layers, num_decoder_layers) - min_num_layers
-            )
-            remaining_side_name = (
-                "encoder" if num_encoder_layers > num_decoder_layers else "decoder"
-            )
-
-            for _ in range(min_num_layers):
-                common_inputs["past_key_values"].append(
-                    (
-                        torch.zeros(decoder_shape),
-                        torch.zeros(decoder_shape),
-                        torch.zeros(encoder_shape),
-                        torch.zeros(encoder_shape),
-                    )
-                )
-            # TODO: test this.
-            shape = encoder_shape if remaining_side_name == "encoder" else decoder_shape
-            for _ in range(min_num_layers, max_num_layers):
-                common_inputs["past_key_values"].append(
-                    (torch.zeros(shape), torch.zeros(shape))
-                )
-        return common_inputs
-
-    generate_dummy_inputs = _generate_dummy_inputs_for_default_and_seq2seq_lm