


'''simple docstring'''

# coding=utf-8
# Copyright 2020 The HuggingFace Inc. team.
#
# 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.

# this script dumps information about the environment

import os
import sys

import transformers


lowerCamelCase							:   List[Any]  						=	'3'

print('Python version:', sys.version)
print('transformers version:', transformers.__version__)

try:
 import torch

 print('Torch version:', torch.__version__)
 print('Cuda available:', torch.cuda.is_available())
 print('Cuda version:', torch.version.cuda)
 print('CuDNN version:', torch.backends.cudnn.version())
 print('Number of GPUs available:', torch.cuda.device_count())
 print('NCCL version:', torch.cuda.nccl.version())
except ImportError:
 print('Torch version:', None)

try:
 import deepspeed

 print('DeepSpeed version:', deepspeed.__version__)
except ImportError:
 print('DeepSpeed version:', None)

try:
 import tensorflow as tf

 print('TensorFlow version:', tf.__version__)
 print('TF GPUs available:', bool(tf.config.list_physical_devices('GPU')))
 print('Number of TF GPUs available:', len(tf.config.list_physical_devices('GPU')))
except ImportError:
 print('TensorFlow version:', None)








'''simple docstring'''

import argparse

import torch

from transformers import BertForMaskedLM


if __name__ == "__main__":
 lowerCamelCase							:   List[str]  						=	argparse.ArgumentParser(
     description=(
         'Extraction some layers of the full BertForMaskedLM or RObertaForMaskedLM for Transfer Learned'
         ' Distillation'
     )
 )
 parser.add_argument('--model_type', default='bert', choices=['bert'])
 parser.add_argument('--model_name', default='bert-base-uncased', type=str)
 parser.add_argument('--dump_checkpoint', default='serialization_dir/tf_bert-base-uncased_0247911.pth', type=str)
 parser.add_argument('--vocab_transform', action='store_true')
 lowerCamelCase							:   str  						=	parser.parse_args()

 if args.model_type == "bert":
  lowerCamelCase							:   List[Any]  						=	BertForMaskedLM.from_pretrained(args.model_name)
  lowerCamelCase							:   Any  						=	'bert'
 else:
  raise ValueError('args.model_type should be "bert".')

 lowerCamelCase							:   int  						=	model.state_dict()
 lowerCamelCase							:   int  						=	{}

 for w in ["word_embeddings", "position_embeddings"]:
  lowerCamelCase							:   Any  						=	state_dict[f"""{prefix}.embeddings.{w}.weight"""]
 for w in ["weight", "bias"]:
  lowerCamelCase							:   Any  						=	state_dict[f"""{prefix}.embeddings.LayerNorm.{w}"""]

 lowerCamelCase							:   Tuple  						=	0
 for teacher_idx in [0, 2, 4, 7, 9, 11]:
  for w in ["weight", "bias"]:
   lowerCamelCase							:   Dict  						=	state_dict[
       f"""{prefix}.encoder.layer.{teacher_idx}.attention.self.query.{w}"""
   ]
   lowerCamelCase							:   Dict  						=	state_dict[
       f"""{prefix}.encoder.layer.{teacher_idx}.attention.self.key.{w}"""
   ]
   lowerCamelCase							:   List[Any]  						=	state_dict[
       f"""{prefix}.encoder.layer.{teacher_idx}.attention.self.value.{w}"""
   ]

   lowerCamelCase							:   Tuple  						=	state_dict[
       f"""{prefix}.encoder.layer.{teacher_idx}.attention.output.dense.{w}"""
   ]
   lowerCamelCase							:   Optional[int]  						=	state_dict[
       f"""{prefix}.encoder.layer.{teacher_idx}.attention.output.LayerNorm.{w}"""
   ]

   lowerCamelCase							:   Optional[Any]  						=	state_dict[
       f"""{prefix}.encoder.layer.{teacher_idx}.intermediate.dense.{w}"""
   ]
   lowerCamelCase							:   Dict  						=	state_dict[
       f"""{prefix}.encoder.layer.{teacher_idx}.output.dense.{w}"""
   ]
   lowerCamelCase							:   Any  						=	state_dict[
       f"""{prefix}.encoder.layer.{teacher_idx}.output.LayerNorm.{w}"""
   ]
  std_idx += 1

 lowerCamelCase							:   Optional[int]  						=	state_dict['cls.predictions.decoder.weight']
 lowerCamelCase							:   str  						=	state_dict['cls.predictions.bias']
 if args.vocab_transform:
  for w in ["weight", "bias"]:
   lowerCamelCase							:   str  						=	state_dict[f"""cls.predictions.transform.dense.{w}"""]
   lowerCamelCase							:   Any  						=	state_dict[f"""cls.predictions.transform.LayerNorm.{w}"""]

 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)




