codingutf8 2021 the eleutherai and huggingface teams 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 orglicenseslicense2 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 gptj model configuration from collections import ordereddict from typing import any list mapping optional from import pretrainedtokenizer tensortype istorchavailable from configurationutils import pretrainedconfig from onnx import onnxconfigwithpast patchingspec from utils import logging logger logging getloggername gptjpretrainedconfigarchivemap eleutheraigptj6b https huggingface coeleutheraigptj6bresolvemainconfig json see all gptj models at https huggingface comodels filtergptj class gptjconfigpretrainedconfig r this is the configuration class to store the configuration of a gptjmodel it is used to instantiate a gptj model according to the specified arguments defining the model architecture instantiating a configuration with the defaults will yield a similar configuration to that of the gptj eleutheraigptj6bhttps huggingface coeleutheraigptj6b architecture configuration objects inherit from pretrainedconfig and can be used to control the model outputs read the documentation from pretrainedconfig for more information args vocabsize int optional defaults to 50400 vocabulary size of the gptj model defines the number of different tokens that can be represented by the inputsids passed when calling gptjmodel npositions int optional defaults to 2048 the maximum sequence length that this model might ever be used with typically set this to something large just in case e g 512 or 1024 or 2048 nembd int optional defaults to 4096 dimensionality of the embeddings and hidden states nlayer int optional defaults to 28 number of hidden layers in the transformer encoder nhead int optional defaults to 16 number of attention heads for each attention layer in the transformer encoder rotarydim int optional defaults to 64 number of dimensions in the embedding that rotary position embedding is applied to ninner int optional defaults to none dimensionality of the inner feedforward layers none will set it to 4 times nembd activationfunction str optional defaults to gelunew activation function to be selected in the list relu silu gelu tanh gelunew residpdrop float optional defaults to 0 1 the dropout probability for all fully connected layers in the embeddings encoder and pooler embdpdrop int optional defaults to 0 1 the dropout ratio for the embeddings attnpdrop float optional defaults to 0 1 the dropout ratio for the attention layernormepsilon float optional defaults to 1e5 the epsilon to use in the layer normalization layers initializerrange float optional defaults to 0 02 the standard deviation of the truncatednormalinitializer for initializing all weight matrices usecache bool optional defaults to true whether or not the model should return the last keyvalues attentions not used by all models example python from transformers import gptjmodel gptjconfig initializing a gptj 6b configuration configuration gptjconfig initializing a model from the configuration model gptjmodelconfiguration accessing the model configuration configuration model config modeltype gptj attributemap maxpositionembeddings npositions hiddensize nembd numattentionheads nhead numhiddenlayers nlayer def init self vocabsize50400 npositions2048 nembd4096 nlayer28 nhead16 rotarydim64 ninnernone activationfunctiongelunew residpdrop0 0 embdpdrop0 0 attnpdrop0 0 layernormepsilon1e5 initializerrange0 02 usecachetrue bostokenid50256 eostokenid50256 tiewordembeddingsfalse kwargs self vocabsize vocabsize self npositions npositions self nembd nembd self nlayer nlayer self nhead nhead self ninner ninner self rotarydim rotarydim self activationfunction activationfunction self residpdrop residpdrop self embdpdrop embdpdrop self attnpdrop attnpdrop self layernormepsilon layernormepsilon self initializerrange initializerrange self usecache usecache self bostokenid bostokenid self eostokenid eostokenid super init bostokenidbostokenid eostokenideostokenid tiewordembeddingstiewordembeddings kwargs copied from transformers models gpt2 configurationgpt2 gpt2onnxconfig class gptjonnxconfigonnxconfigwithpast def init self config pretrainedconfig task str default patchingspecs listpatchingspec none usepast bool false super initconfig tasktask patchingspecspatchingspecs usepastusepast if not getattrself config padtokenid none todo how to do that better self config padtokenid 0 property def inputsself mappingstr mappingint str commoninputs ordereddictinputids 0 batch 1 sequence if self usepast self fillwithpastkeyvaluescommoninputs directioninputs commoninputsattentionmask 0 batch 1 pastsequence sequence else commoninputsattentionmask 0 batch 1 sequence return commoninputs property def numlayersself int return self config nlayer property def numattentionheadsself int return self config nhead def generatedummyinputs self tokenizer pretrainedtokenizer batchsize int 1 seqlength int 1 ispair bool false framework optionaltensortype none mappingstr any commoninputs superonnxconfigwithpast self generatedummyinputs tokenizer batchsizebatchsize seqlengthseqlength ispairispair frameworkframework we need to order the input in the way they appears in the forward orderedinputs ordereddictinputids commoninputsinputids need to add the pastkeys if self usepast if not istorchavailable raise valueerrorcannot generate dummy pastkeys inputs without pytorch installed else import torch batch seqlen commoninputsinputids shape not using the same length for pastkeyvalues pastkeyvalueslength seqlen 2 pastshape batch self numattentionheads pastkeyvalueslength self config hiddensize self numattentionheads orderedinputspastkeyvalues torch zerospastshape torch zerospastshape for in rangeself numlayers orderedinputsattentionmask commoninputsattentionmask if self usepast maskdtype orderedinputsattentionmask dtype orderedinputsattentionmask torch cat orderedinputsattentionmask torch onesbatch pastkeyvalueslength dtypemaskdtype dim1 return orderedinputs property def defaultonnxopsetself int return 13 coding utf 8 2021 the eleutherai and huggingface teams 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 gpt j model configuration see all gpt j models at https huggingface co models filter gpt_j this is the configuration class to store the configuration of a gptjmodel it is used to instantiate a gpt j model according to the specified arguments defining the model architecture instantiating a configuration with the defaults will yield a similar configuration to that of the gpt j eleutherai gpt j 6b https huggingface co eleutherai gpt j 6b architecture configuration objects inherit from pretrainedconfig and can be used to control the model outputs read the documentation from pretrainedconfig for more information args vocab_size int optional defaults to 50400 vocabulary size of the gpt j model defines the number of different tokens that can be represented by the inputs_ids passed when calling gptjmodel n_positions int optional defaults to 2048 the maximum sequence length that this model might ever be used with typically set this to something large just in case e g 512 or 1024 or 2048 n_embd int optional defaults to 4096 dimensionality of the embeddings and hidden states n_layer int optional defaults to 28 number of hidden layers in the transformer encoder n_head int optional defaults to 16 number of attention heads for each attention layer in the transformer encoder rotary_dim int optional defaults to 64 number of dimensions in the embedding that rotary position embedding is applied to n_inner int optional defaults to none dimensionality of the inner feed forward layers none will set it to 4 times n_embd activation_function str optional defaults to gelu_new activation function to be selected in the list relu silu gelu tanh gelu_new resid_pdrop float optional defaults to 0 1 the dropout probability for all fully connected layers in the embeddings encoder and pooler embd_pdrop int optional defaults to 0 1 the dropout ratio for the embeddings attn_pdrop float optional defaults to 0 1 the dropout ratio for the attention layer_norm_epsilon float optional defaults to 1e 5 the epsilon to use in the layer normalization layers initializer_range float optional defaults to 0 02 the standard deviation of the truncated_normal_initializer for initializing all weight matrices use_cache bool optional defaults to true whether or not the model should return the last key values attentions not used by all models example python from transformers import gptjmodel gptjconfig initializing a gpt j 6b configuration configuration gptjconfig initializing a model from the configuration model gptjmodel configuration accessing the model configuration configuration model config copied from transformers models gpt2 configuration_gpt2 gpt2onnxconfig todo how to do that better we need to order the input in the way they appears in the forward need to add the past_keys not using the same length for past_key_values
from collections import OrderedDict
from typing import Any, List, Mapping, Optional

from ... import PreTrainedTokenizer, TensorType, is_torch_available
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfigWithPast, PatchingSpec
from ...utils import logging


logger = logging.get_logger(__name__)

GPTJ_PRETRAINED_CONFIG_ARCHIVE_MAP = {
    "EleutherAI/gpt-j-6B": "https://huggingface.co/EleutherAI/gpt-j-6B/resolve/main/config.json",
    
}


class GPTJConfig(PretrainedConfig):
    r

    model_type = "gptj"
    attribute_map = {
        "max_position_embeddings": "n_positions",
        "hidden_size": "n_embd",
        "num_attention_heads": "n_head",
        "num_hidden_layers": "n_layer",
    }

    def __init__(
        self,
        vocab_size=50400,
        n_positions=2048,
        n_embd=4096,
        n_layer=28,
        n_head=16,
        rotary_dim=64,
        n_inner=None,
        activation_function="gelu_new",
        resid_pdrop=0.0,
        embd_pdrop=0.0,
        attn_pdrop=0.0,
        layer_norm_epsilon=1e-5,
        initializer_range=0.02,
        use_cache=True,
        bos_token_id=50256,
        eos_token_id=50256,
        tie_word_embeddings=False,
        **kwargs,
    ):
        self.vocab_size = vocab_size
        self.n_positions = n_positions
        self.n_embd = n_embd
        self.n_layer = n_layer
        self.n_head = n_head
        self.n_inner = n_inner
        self.rotary_dim = rotary_dim
        self.activation_function = activation_function
        self.resid_pdrop = resid_pdrop
        self.embd_pdrop = embd_pdrop
        self.attn_pdrop = attn_pdrop
        self.layer_norm_epsilon = layer_norm_epsilon
        self.initializer_range = initializer_range
        self.use_cache = use_cache

        self.bos_token_id = bos_token_id
        self.eos_token_id = eos_token_id

        super().__init__(
            bos_token_id=bos_token_id, eos_token_id=eos_token_id, tie_word_embeddings=tie_word_embeddings, **kwargs
        )



class GPTJOnnxConfig(OnnxConfigWithPast):
    def __init__(
        self,
        config: PretrainedConfig,
        task: str = "default",
        patching_specs: List[PatchingSpec] = None,
        use_past: bool = False,
    ):
        super().__init__(config, task=task, patching_specs=patching_specs, use_past=use_past)
        if not getattr(self._config, "pad_token_id", None):
            
            self._config.pad_token_id = 0

    @property
    def inputs(self) -> Mapping[str, Mapping[int, str]]:
        common_inputs = OrderedDict({"input_ids": {0: "batch", 1: "sequence"}})
        if self.use_past:
            self.fill_with_past_key_values_(common_inputs, direction="inputs")
            common_inputs["attention_mask"] = {0: "batch", 1: "past_sequence + sequence"}
        else:
            common_inputs["attention_mask"] = {0: "batch", 1: "sequence"}

        return common_inputs

    @property
    def num_layers(self) -> int:
        return self._config.n_layer

    @property
    def num_attention_heads(self) -> int:
        return self._config.n_head

    def generate_dummy_inputs(
        self,
        tokenizer: PreTrainedTokenizer,
        batch_size: int = -1,
        seq_length: int = -1,
        is_pair: bool = False,
        framework: Optional[TensorType] = None,
    ) -> Mapping[str, Any]:
        common_inputs = super(OnnxConfigWithPast, self).generate_dummy_inputs(
            tokenizer, batch_size=batch_size, seq_length=seq_length, is_pair=is_pair, framework=framework
        )

        
        ordered_inputs = OrderedDict({"input_ids": common_inputs["input_ids"]})

        
        if self.use_past:
            if not is_torch_available():
                raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed.")
            else:
                import torch

                batch, seqlen = common_inputs["input_ids"].shape
                
                past_key_values_length = seqlen + 2
                past_shape = (
                    batch,
                    self.num_attention_heads,
                    past_key_values_length,
                    self._config.hidden_size // self.num_attention_heads,
                )
                ordered_inputs["past_key_values"] = [
                    (torch.zeros(past_shape), torch.zeros(past_shape)) for _ in range(self.num_layers)
                ]

        ordered_inputs["attention_mask"] = common_inputs["attention_mask"]
        if self.use_past:
            mask_dtype = ordered_inputs["attention_mask"].dtype
            ordered_inputs["attention_mask"] = torch.cat(
                [ordered_inputs["attention_mask"], torch.ones(batch, past_key_values_length, dtype=mask_dtype)], dim=1
            )

        return ordered_inputs

    @property
    def default_onnx_opset(self) -> int:
        return 13