




'''simple docstring'''


import argparse
import os

import gluonnlp as nlp
import mxnet as mx
import numpy as np
import torch
from gluonnlp.base import get_home_dir
from gluonnlp.model.bert import BERTEncoder
from gluonnlp.model.utils import _load_vocab
from gluonnlp.vocab import Vocab
from packaging import version
from torch import nn

from transformers import BertConfig, BertForMaskedLM, BertModel, RobertaTokenizer
from transformers.models.bert.modeling_bert import (
    BertIntermediate,
    BertLayer,
    BertOutput,
    BertSelfAttention,
    BertSelfOutput,
)
from transformers.utils import logging


if version.parse(nlp.__version__) != version.parse('0.8.3'):
				raise Exception('requires gluonnlp == 0.8.3')

if version.parse(mx.__version__) != version.parse('1.5.0'):
				raise Exception('requires mxnet == 1.5.0')

logging.set_verbosity_info()
_snake_case				:				str       							=		logging.get_logger(__name__)

_snake_case				:				int       							=		'The Nymphenburg Palace is a beautiful palace in Munich!'
def 		snake_case_   (UpperCamelCase	:  str			,						UpperCamelCase	:  str				):





							'''simple docstring'''


							_a     					=    {
							    '''attention_cell''': '''multi_head''',
							    '''num_layers''': 4,
							    '''units''': 1024,
							    '''hidden_size''': 768,
							    '''max_length''': 512,
							    '''num_heads''': 8,
							    '''scaled''': True,
							    '''dropout''': 0.1,
							    '''use_residual''': True,
							    '''embed_size''': 1024,
							    '''embed_dropout''': 0.1,
							    '''word_embed''': None,
							    '''layer_norm_eps''': 1e-5,
							    '''token_type_vocab_size''': 2,
							}

							_a     					=    bort_4_8_768_1024_hparams

							# Let's construct the original Bort model here
							# Taken from official BERT implementation, see:
							# https://github.com/alexa/bort/blob/master/bort/bort.py
							_a     					=    BERTEncoder(
							    attention_cell=predefined_args['''attention_cell''']			,						num_layers=predefined_args['''num_layers''']			,						units=predefined_args['''units''']			,						hidden_size=predefined_args['''hidden_size''']			,						max_length=predefined_args['''max_length''']			,						num_heads=predefined_args['''num_heads''']			,						scaled=predefined_args['''scaled''']			,						dropout=predefined_args['''dropout''']			,						output_attention=UpperCamelCase			,						output_all_encodings=UpperCamelCase			,						use_residual=predefined_args['''use_residual''']			,						activation=predefined_args.get('''activation'''			,						'''gelu'''				)			,						layer_norm_eps=predefined_args.get('''layer_norm_eps'''			,						UpperCamelCase				)			,						)

							# Vocab information needs to be fetched first
							# It's the same as RoBERTa, so RobertaTokenizer can be used later
							_a     					=    '''openwebtext_ccnews_stories_books_cased'''

							# Specify download folder to Gluonnlp's vocab
							_a     					=    os.path.join(get_home_dir()			,						'''models'''				)
							_a     					=    _load_vocab(UpperCamelCase			,						UpperCamelCase			,						UpperCamelCase			,						cls=UpperCamelCase				)

							_a     					=    nlp.model.BERTModel(
							    UpperCamelCase			,						len(UpperCamelCase				)			,						units=predefined_args['''units''']			,						embed_size=predefined_args['''embed_size''']			,						embed_dropout=predefined_args['''embed_dropout''']			,						word_embed=predefined_args['''word_embed''']			,						use_pooler=UpperCamelCase			,						use_token_type_embed=UpperCamelCase			,						token_type_vocab_size=predefined_args['''token_type_vocab_size''']			,						use_classifier=UpperCamelCase			,						use_decoder=UpperCamelCase			,						)

							original_bort.load_parameters(UpperCamelCase			,						cast_dtype=UpperCamelCase			,						ignore_extra=UpperCamelCase				)
							_a     					=    original_bort._collect_params_with_prefix()

							# Build our config 🤗
							_a     					=    {
							    '''architectures''': ['''BertForMaskedLM'''],
							    '''attention_probs_dropout_prob''': predefined_args['''dropout'''],
							    '''hidden_act''': '''gelu''',
							    '''hidden_dropout_prob''': predefined_args['''dropout'''],
							    '''hidden_size''': predefined_args['''embed_size'''],
							    '''initializer_range''': 0.02,
							    '''intermediate_size''': predefined_args['''hidden_size'''],
							    '''layer_norm_eps''': predefined_args['''layer_norm_eps'''],
							    '''max_position_embeddings''': predefined_args['''max_length'''],
							    '''model_type''': '''bort''',
							    '''num_attention_heads''': predefined_args['''num_heads'''],
							    '''num_hidden_layers''': predefined_args['''num_layers'''],
							    '''pad_token_id''': 1,  # 2 = BERT, 1 = RoBERTa
							    '''type_vocab_size''': 1,  # 2 = BERT, 1 = RoBERTa
							    '''vocab_size''': len(UpperCamelCase				),
							}

							_a     					=    BertConfig.from_dict(UpperCamelCase				)
							_a     					=    BertForMaskedLM(UpperCamelCase				)
							hf_bort_model.eval()

							# Parameter mapping table (Gluonnlp to Transformers)
							# * denotes layer index
							#
							# | Gluon Parameter                                                | Transformers Parameter
							# | -------------------------------------------------------------- | ----------------------
							# | `encoder.layer_norm.beta`                                      | `bert.embeddings.LayerNorm.bias`
							# | `encoder.layer_norm.gamma`                                     | `bert.embeddings.LayerNorm.weight`
							# | `encoder.position_weight`                                      | `bert.embeddings.position_embeddings.weight`
							# | `word_embed.0.weight`                                          | `bert.embeddings.word_embeddings.weight`
							# | `encoder.transformer_cells.*.attention_cell.proj_key.bias`     | `bert.encoder.layer.*.attention.self.key.bias`
							# | `encoder.transformer_cells.*.attention_cell.proj_key.weight`   | `bert.encoder.layer.*.attention.self.key.weight`
							# | `encoder.transformer_cells.*.attention_cell.proj_query.bias`   | `bert.encoder.layer.*.attention.self.query.bias`
							# | `encoder.transformer_cells.*.attention_cell.proj_query.weight` | `bert.encoder.layer.*.attention.self.query.weight`
							# | `encoder.transformer_cells.*.attention_cell.proj_value.bias`   | `bert.encoder.layer.*.attention.self.value.bias`
							# | `encoder.transformer_cells.*.attention_cell.proj_value.weight` | `bert.encoder.layer.*.attention.self.value.weight`
							# | `encoder.transformer_cells.*.ffn.ffn_2.bias`                   | `bert.encoder.layer.*.attention.output.dense.bias`
							# | `encoder.transformer_cells.*.ffn.ffn_2.weight`                 | `bert.encoder.layer.*.attention.output.dense.weight`
							# | `encoder.transformer_cells.*.layer_norm.beta`                  | `bert.encoder.layer.*.attention.output.LayerNorm.bias`
							# | `encoder.transformer_cells.*.layer_norm.gamma`                 | `bert.encoder.layer.*.attention.output.LayerNorm.weight`
							# | `encoder.transformer_cells.*.ffn.ffn_1.bias`                   | `bert.encoder.layer.*.intermediate.dense.bias`
							# | `encoder.transformer_cells.*.ffn.ffn_1.weight`                 | `bert.encoder.layer.*.intermediate.dense.weight`
							# | `encoder.transformer_cells.*.ffn.layer_norm.beta`              | `bert.encoder.layer.*.output.LayerNorm.bias`
							# | `encoder.transformer_cells.*.ffn.layer_norm.gamma`             | `bert.encoder.layer.*.output.LayerNorm.weight`
							# | `encoder.transformer_cells.*.proj.bias`                        | `bert.encoder.layer.*.output.dense.bias`
							# | `encoder.transformer_cells.*.proj.weight`                      | `bert.encoder.layer.*.output.dense.weight`

							# Helper function to convert MXNET Arrays to PyTorch
							def to_torch(UpperCamelCase	:  Optional[Any]				) -> nn.Parameter:
														return nn.Parameter(torch.FloatTensor(mx_array.data().asnumpy()				)				)

							# Check param shapes and map new HF param back
							def check_and_map_params(UpperCamelCase	:  int			,						UpperCamelCase	:  int				):
														_a     					=    hf_param.shape

														_a     					=    to_torch(params[gluon_param]				)
														_a     					=    gluon_param.shape

														assert (
														    shape_hf == shape_gluon
														), f'The gluon parameter {gluon_param} has shape {shape_gluon}, but expects shape {shape_hf} for Transformers'

														return gluon_param

							_a     					=    check_and_map_params(
							    hf_bort_model.bert.embeddings.word_embeddings.weight			,						'''word_embed.0.weight'''				)
							_a     					=    check_and_map_params(
							    hf_bort_model.bert.embeddings.position_embeddings.weight			,						'''encoder.position_weight'''				)
							_a     					=    check_and_map_params(
							    hf_bort_model.bert.embeddings.LayerNorm.bias			,						'''encoder.layer_norm.beta'''				)
							_a     					=    check_and_map_params(
							    hf_bort_model.bert.embeddings.LayerNorm.weight			,						'''encoder.layer_norm.gamma'''				)

							# Inspired by RoBERTa conversion script, we just zero them out (Bort does not use them)
							_a     					=    torch.zeros_like(
							    hf_bort_model.bert.embeddings.token_type_embeddings.weight.data				)

							for i in range(hf_bort_config.num_hidden_layers				):
														_a     					=    hf_bort_model.bert.encoder.layer[i]

														# self attention
														_a     					=    layer.attention.self

														_a     					=    check_and_map_params(
														    self_attn.key.bias.data			,						f'encoder.transformer_cells.{i}.attention_cell.proj_key.bias'				)

														_a     					=    check_and_map_params(
														    self_attn.key.weight.data			,						f'encoder.transformer_cells.{i}.attention_cell.proj_key.weight'				)
														_a     					=    check_and_map_params(
														    self_attn.query.bias.data			,						f'encoder.transformer_cells.{i}.attention_cell.proj_query.bias'				)
														_a     					=    check_and_map_params(
														    self_attn.query.weight.data			,						f'encoder.transformer_cells.{i}.attention_cell.proj_query.weight'				)
														_a     					=    check_and_map_params(
														    self_attn.value.bias.data			,						f'encoder.transformer_cells.{i}.attention_cell.proj_value.bias'				)
														_a     					=    check_and_map_params(
														    self_attn.value.weight.data			,						f'encoder.transformer_cells.{i}.attention_cell.proj_value.weight'				)

														# self attention output
														_a     					=    layer.attention.output

														_a     					=    check_and_map_params(
														    self_output.dense.bias			,						f'encoder.transformer_cells.{i}.proj.bias'				)
														_a     					=    check_and_map_params(
														    self_output.dense.weight			,						f'encoder.transformer_cells.{i}.proj.weight'				)
														_a     					=    check_and_map_params(
														    self_output.LayerNorm.bias			,						f'encoder.transformer_cells.{i}.layer_norm.beta'				)
														_a     					=    check_and_map_params(
														    self_output.LayerNorm.weight			,						f'encoder.transformer_cells.{i}.layer_norm.gamma'				)

														# intermediate
														_a     					=    layer.intermediate

														_a     					=    check_and_map_params(
														    intermediate.dense.bias			,						f'encoder.transformer_cells.{i}.ffn.ffn_1.bias'				)
														_a     					=    check_and_map_params(
														    intermediate.dense.weight			,						f'encoder.transformer_cells.{i}.ffn.ffn_1.weight'				)

														# output
														_a     					=    layer.output

														_a     					=    check_and_map_params(
														    bert_output.dense.bias			,						f'encoder.transformer_cells.{i}.ffn.ffn_2.bias'				)
														_a     					=    check_and_map_params(
														    bert_output.dense.weight			,						f'encoder.transformer_cells.{i}.ffn.ffn_2.weight'				)
														_a     					=    check_and_map_params(
														    bert_output.LayerNorm.bias			,						f'encoder.transformer_cells.{i}.ffn.layer_norm.beta'				)
														_a     					=    check_and_map_params(
														    bert_output.LayerNorm.weight			,						f'encoder.transformer_cells.{i}.ffn.layer_norm.gamma'				)

							# Save space and energy 🎄
							hf_bort_model.half()

							# Compare output of both models
							_a     					=    RobertaTokenizer.from_pretrained('''roberta-base'''				)

							_a     					=    tokenizer.encode_plus(UpperCamelCase				)['''input_ids''']

							# Get gluon output
							_a     					=    mx.nd.array([input_ids]				)
							_a     					=    original_bort(inputs=UpperCamelCase			,						token_types=[]				)

							# Get Transformer output (save and reload model again)
							hf_bort_model.save_pretrained(UpperCamelCase				)
							_a     					=    BertModel.from_pretrained(UpperCamelCase				)
							hf_bort_model.eval()

							_a     					=    tokenizer.encode_plus(UpperCamelCase			,						return_tensors='''pt'''				)
							_a     					=    hf_bort_model(**UpperCamelCase				)[0]

							_a     					=    output_gluon[0].asnumpy()
							_a     					=    output_hf[0].detach().numpy()

							_a     					=    np.max(np.abs(hf_layer - gluon_layer				)				).item()
							_a     					=    np.allclose(UpperCamelCase			,						UpperCamelCase			,						atol=1e-3				)

							if success:
														print('''✔️ Both model do output the same tensors'''				)
							else:
														print('''❌ Both model do **NOT** output the same tensors'''				)
														print('''Absolute difference is:'''			,						UpperCamelCase				)


if __name__ == "__main__":
				_snake_case				:				Dict       							=		argparse.ArgumentParser()
				# Required parameters
				parser.add_argument(
				    '--bort_checkpoint_path', default=None, type=str, required=True, help='Path the official Bort params file.'
				)
				parser.add_argument(
				    '--pytorch_dump_folder_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
				)
				_snake_case				:				Any       							=		parser.parse_args()
				convert_bort_checkpoint_to_pytorch(args.bort_checkpoint_path, args.pytorch_dump_folder_path)







'''simple docstring'''


import argparse
import math
import traceback

import dateutil.parser as date_parser
import requests
def 		snake_case_   (UpperCamelCase	:  Dict				):





							'''simple docstring'''


							_a     					=    {}

							_a     					=    job['''started_at''']
							_a     					=    job['''completed_at''']

							_a     					=    date_parser.parse(UpperCamelCase				)
							_a     					=    date_parser.parse(UpperCamelCase				)

							_a     					=    round((end_datetime - start_datetime).total_seconds() / 60.0				)

							_a     					=    start
							_a     					=    end
							_a     					=    duration_in_min

							return job_info
def 		snake_case_   (UpperCamelCase	:  int			,						UpperCamelCase	:  int=None				):





							'''simple docstring'''


							_a     					=    None
							if token is not None:
														_a     					=    {'''Accept''': '''application/vnd.github+json''', '''Authorization''': f'Bearer {token}'}

							_a     					=    f'https://api.github.com/repos/huggingface/transformers/actions/runs/{workflow_run_id}/jobs?per_page=100'
							_a     					=    requests.get(UpperCamelCase			,						headers=UpperCamelCase				).json()
							_a     					=    {}

							try:
														job_time.update({job['''name''']: extract_time_from_single_job(UpperCamelCase				) for job in result['''jobs''']}				)
														_a     					=    math.ceil((result['''total_count'''] - 100) / 100				)

														for i in range(UpperCamelCase				):
																					_a     					=    requests.get(url + f'&page={i + 2}'			,						headers=UpperCamelCase				).json()
																					job_time.update({job['''name''']: extract_time_from_single_job(UpperCamelCase				) for job in result['''jobs''']}				)

														return job_time
							except Exception:
														print(f'Unknown error, could not fetch links:\n{traceback.format_exc()}'				)

							return {}


if __name__ == "__main__":
				_snake_case				:				int       							=		argparse.ArgumentParser()
				# Required parameters
				parser.add_argument('--workflow_run_id', type=str, required=True, help='A GitHub Actions workflow run id.')
				_snake_case				:				Tuple       							=		parser.parse_args()

				_snake_case				:				int       							=		get_job_time(args.workflow_run_id)
				_snake_case				:				int       							=		dict(sorted(job_time.items(), key=lambda item: item[1]["duration"], reverse=True))

				for k, v in job_time.items():
								print(F'''{k}: {v['duration']}''')

