






import argparse

import torch

from transformers import GPTaLMHeadModel, RobertaForMaskedLM


if __name__ == "__main__":
    _SCREAMING_SNAKE_CASE   =  argparse.ArgumentParser(
        description=(
            "Extraction some layers of the full RobertaForMaskedLM or GPT2LMHeadModel for Transfer Learned"
            " Distillation"
        )
    )
    parser.add_argument("--model_type", default="roberta", choices=["roberta", "gpt2"])
    parser.add_argument("--model_name", default="roberta-large", type=str)
    parser.add_argument("--dump_checkpoint", default="serialization_dir/tf_roberta_048131723.pth", type=str)
    parser.add_argument("--vocab_transform", action="store_true")
    _SCREAMING_SNAKE_CASE   =  parser.parse_args()

    if args.model_type == "roberta":
        _SCREAMING_SNAKE_CASE   =  RobertaForMaskedLM.from_pretrained(args.model_name)
        _SCREAMING_SNAKE_CASE   =  "roberta"
    elif args.model_type == "gpt2":
        _SCREAMING_SNAKE_CASE   =  GPTaLMHeadModel.from_pretrained(args.model_name)
        _SCREAMING_SNAKE_CASE   =  "transformer"

    _SCREAMING_SNAKE_CASE   =  model.state_dict()
    _SCREAMING_SNAKE_CASE   =  {}

    # Embeddings #
    if args.model_type == "gpt2":
        for param_name in ["wte.weight", "wpe.weight"]:
            _SCREAMING_SNAKE_CASE   =  state_dict[f'''{prefix}.{param_name}''']
    else:
        for w in ["word_embeddings", "position_embeddings", "token_type_embeddings"]:
            _SCREAMING_SNAKE_CASE   =  f'''{prefix}.embeddings.{w}.weight'''
            _SCREAMING_SNAKE_CASE   =  state_dict[param_name]
        for w in ["weight", "bias"]:
            _SCREAMING_SNAKE_CASE   =  f'''{prefix}.embeddings.LayerNorm.{w}'''
            _SCREAMING_SNAKE_CASE   =  state_dict[param_name]

    # Transformer Blocks #
    _SCREAMING_SNAKE_CASE   =  0
    for teacher_idx in [0, 2, 4, 7, 9, 11]:
        if args.model_type == "gpt2":
            for layer in ["ln_1", "attn.c_attn", "attn.c_proj", "ln_2", "mlp.c_fc", "mlp.c_proj"]:
                for w in ["weight", "bias"]:
                    _SCREAMING_SNAKE_CASE   =  state_dict[
                        f'''{prefix}.h.{teacher_idx}.{layer}.{w}'''
                    ]
            _SCREAMING_SNAKE_CASE   =  state_dict[f'''{prefix}.h.{teacher_idx}.attn.bias''']
        else:
            for layer in [
                "attention.self.query",
                "attention.self.key",
                "attention.self.value",
                "attention.output.dense",
                "attention.output.LayerNorm",
                "intermediate.dense",
                "output.dense",
                "output.LayerNorm",
            ]:
                for w in ["weight", "bias"]:
                    _SCREAMING_SNAKE_CASE   =  state_dict[
                        f'''{prefix}.encoder.layer.{teacher_idx}.{layer}.{w}'''
                    ]
        std_idx += 1

    # Language Modeling Head ###s
    if args.model_type == "roberta":
        for layer in ["lm_head.decoder.weight", "lm_head.bias"]:
            _SCREAMING_SNAKE_CASE   =  state_dict[f'''{layer}''']
        if args.vocab_transform:
            for w in ["weight", "bias"]:
                _SCREAMING_SNAKE_CASE   =  state_dict[f'''lm_head.dense.{w}''']
                _SCREAMING_SNAKE_CASE   =  state_dict[f'''lm_head.layer_norm.{w}''']
    elif args.model_type == "gpt2":
        for w in ["weight", "bias"]:
            _SCREAMING_SNAKE_CASE   =  state_dict[f'''{prefix}.ln_f.{w}''']
        _SCREAMING_SNAKE_CASE   =  state_dict["lm_head.weight"]

    print(f'''N layers selected for distillation: {std_idx}''')
    print(f'''Number of params transferred for distillation: {len(compressed_sd.keys())}''')

    print(f'''Save transferred checkpoint to {args.dump_checkpoint}.''')
    torch.save(compressed_sd, args.dump_checkpoint)










# Copyright 2023 The HuggingFace 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 TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_SCREAMING_SNAKE_CASE   =  {
    "configuration_xmod": [
        "XMOD_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "XmodConfig",
        "XmodOnnxConfig",
    ],
}

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _SCREAMING_SNAKE_CASE   =  [
        "XMOD_PRETRAINED_MODEL_ARCHIVE_LIST",
        "XmodForCausalLM",
        "XmodForMaskedLM",
        "XmodForMultipleChoice",
        "XmodForQuestionAnswering",
        "XmodForSequenceClassification",
        "XmodForTokenClassification",
        "XmodModel",
        "XmodPreTrainedModel",
    ]

if TYPE_CHECKING:
    from .configuration_xmod import XMOD_PRETRAINED_CONFIG_ARCHIVE_MAP, XmodConfig, XmodOnnxConfig

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_xmod import (
            XMOD_PRETRAINED_MODEL_ARCHIVE_LIST,
            XmodForCausalLM,
            XmodForMaskedLM,
            XmodForMultipleChoice,
            XmodForQuestionAnswering,
            XmodForSequenceClassification,
            XmodForTokenClassification,
            XmodModel,
            XmodPreTrainedModel,
        )

else:
    import sys

    _SCREAMING_SNAKE_CASE   =  _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


