


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()
__UpperCamelCase       :       Dict						       =				logging.get_logger(__name__)

__UpperCamelCase       :       Dict						       =				"The Nymphenburg Palace is a beautiful palace in Munich!"

def 			_a  (				SCREAMING_SNAKE_CASE	:				str    , SCREAMING_SNAKE_CASE	:				str     ):







 """simple docstring"""



 UpperCamelCase__					:    Any          =   {
     '''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,
 }

 UpperCamelCase__					:    Dict          =   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
 UpperCamelCase__					:    Tuple          =   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=SCREAMING_SNAKE_CASE    , output_all_encodings=SCREAMING_SNAKE_CASE    , use_residual=predefined_args['''use_residual''']    , activation=predefined_args.get('''activation'''    , '''gelu'''     )    , layer_norm_eps=predefined_args.get('''layer_norm_eps'''    , SCREAMING_SNAKE_CASE     )    , )

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

 # Specify download folder to Gluonnlp's vocab
 UpperCamelCase__					:    Union[str, Any]          =   os.path.join(get_home_dir()    , '''models'''     )
 UpperCamelCase__					:    Union[str, Any]          =   _load_vocab(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE    , cls=SCREAMING_SNAKE_CASE     )

 UpperCamelCase__					:    Optional[Any]          =   nlp.model.BERTModel(
     SCREAMING_SNAKE_CASE    , len(SCREAMING_SNAKE_CASE     )    , units=predefined_args['''units''']    , embed_size=predefined_args['''embed_size''']    , embed_dropout=predefined_args['''embed_dropout''']    , word_embed=predefined_args['''word_embed''']    , use_pooler=SCREAMING_SNAKE_CASE    , use_token_type_embed=SCREAMING_SNAKE_CASE    , token_type_vocab_size=predefined_args['''token_type_vocab_size''']    , use_classifier=SCREAMING_SNAKE_CASE    , use_decoder=SCREAMING_SNAKE_CASE    , )

 original_bort.load_parameters(SCREAMING_SNAKE_CASE    , cast_dtype=SCREAMING_SNAKE_CASE    , ignore_extra=SCREAMING_SNAKE_CASE     )
 UpperCamelCase__					:    Any          =   original_bort._collect_params_with_prefix()

 # Build our config 🤗
 UpperCamelCase__					:    Optional[int]          =   {
     '''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(SCREAMING_SNAKE_CASE     ),
 }

 UpperCamelCase__					:    Union[str, Any]          =   BertConfig.from_dict(SCREAMING_SNAKE_CASE     )
 UpperCamelCase__					:    Dict          =   BertForMaskedLM(SCREAMING_SNAKE_CASE     )
 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(SCREAMING_SNAKE_CASE	:				str     ) -> 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(SCREAMING_SNAKE_CASE	:				List[Any]    , SCREAMING_SNAKE_CASE	:				Any     ):
  UpperCamelCase__					:    Optional[int]          =   hf_param.shape

  UpperCamelCase__					:    List[Any]          =   to_torch(params[gluon_param]     )
  UpperCamelCase__					:    List[Any]          =   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

 UpperCamelCase__					:    Union[str, Any]          =   check_and_map_params(
     hf_bort_model.bert.embeddings.word_embeddings.weight    , '''word_embed.0.weight'''     )
 UpperCamelCase__					:    Dict          =   check_and_map_params(
     hf_bort_model.bert.embeddings.position_embeddings.weight    , '''encoder.position_weight'''     )
 UpperCamelCase__					:    int          =   check_and_map_params(
     hf_bort_model.bert.embeddings.LayerNorm.bias    , '''encoder.layer_norm.beta'''     )
 UpperCamelCase__					:    List[str]          =   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)
 UpperCamelCase__					:    int          =   torch.zeros_like(
     hf_bort_model.bert.embeddings.token_type_embeddings.weight.data     )

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

  # self attention
  UpperCamelCase__					:    BertSelfAttention          =   layer.attention.self

  UpperCamelCase__					:    int          =   check_and_map_params(
      self_attn.key.bias.data    , F"encoder.transformer_cells.{i}.attention_cell.proj_key.bias"     )

  UpperCamelCase__					:    Optional[Any]          =   check_and_map_params(
      self_attn.key.weight.data    , F"encoder.transformer_cells.{i}.attention_cell.proj_key.weight"     )
  UpperCamelCase__					:    Tuple          =   check_and_map_params(
      self_attn.query.bias.data    , F"encoder.transformer_cells.{i}.attention_cell.proj_query.bias"     )
  UpperCamelCase__					:    str          =   check_and_map_params(
      self_attn.query.weight.data    , F"encoder.transformer_cells.{i}.attention_cell.proj_query.weight"     )
  UpperCamelCase__					:    List[str]          =   check_and_map_params(
      self_attn.value.bias.data    , F"encoder.transformer_cells.{i}.attention_cell.proj_value.bias"     )
  UpperCamelCase__					:    Dict          =   check_and_map_params(
      self_attn.value.weight.data    , F"encoder.transformer_cells.{i}.attention_cell.proj_value.weight"     )

  # self attention output
  UpperCamelCase__					:    BertSelfOutput          =   layer.attention.output

  UpperCamelCase__					:    Any          =   check_and_map_params(
      self_output.dense.bias    , F"encoder.transformer_cells.{i}.proj.bias"     )
  UpperCamelCase__					:    Optional[int]          =   check_and_map_params(
      self_output.dense.weight    , F"encoder.transformer_cells.{i}.proj.weight"     )
  UpperCamelCase__					:    List[str]          =   check_and_map_params(
      self_output.LayerNorm.bias    , F"encoder.transformer_cells.{i}.layer_norm.beta"     )
  UpperCamelCase__					:    Dict          =   check_and_map_params(
      self_output.LayerNorm.weight    , F"encoder.transformer_cells.{i}.layer_norm.gamma"     )

  # intermediate
  UpperCamelCase__					:    BertIntermediate          =   layer.intermediate

  UpperCamelCase__					:    Optional[int]          =   check_and_map_params(
      intermediate.dense.bias    , F"encoder.transformer_cells.{i}.ffn.ffn_1.bias"     )
  UpperCamelCase__					:    Tuple          =   check_and_map_params(
      intermediate.dense.weight    , F"encoder.transformer_cells.{i}.ffn.ffn_1.weight"     )

  # output
  UpperCamelCase__					:    BertOutput          =   layer.output

  UpperCamelCase__					:    str          =   check_and_map_params(
      bert_output.dense.bias    , F"encoder.transformer_cells.{i}.ffn.ffn_2.bias"     )
  UpperCamelCase__					:    Any          =   check_and_map_params(
      bert_output.dense.weight    , F"encoder.transformer_cells.{i}.ffn.ffn_2.weight"     )
  UpperCamelCase__					:    List[Any]          =   check_and_map_params(
      bert_output.LayerNorm.bias    , F"encoder.transformer_cells.{i}.ffn.layer_norm.beta"     )
  UpperCamelCase__					:    List[str]          =   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
 UpperCamelCase__					:    Dict          =   RobertaTokenizer.from_pretrained('''roberta-base'''     )

 UpperCamelCase__					:    Union[str, Any]          =   tokenizer.encode_plus(SCREAMING_SNAKE_CASE     )['''input_ids''']

 # Get gluon output
 UpperCamelCase__					:    Any          =   mx.nd.array([input_ids]     )
 UpperCamelCase__					:    int          =   original_bort(inputs=SCREAMING_SNAKE_CASE    , token_types=[]     )

 # Get Transformer output (save and reload model again)
 hf_bort_model.save_pretrained(SCREAMING_SNAKE_CASE     )
 UpperCamelCase__					:    List[Any]          =   BertModel.from_pretrained(SCREAMING_SNAKE_CASE     )
 hf_bort_model.eval()

 UpperCamelCase__					:    Union[str, Any]          =   tokenizer.encode_plus(SCREAMING_SNAKE_CASE    , return_tensors='''pt'''     )
 UpperCamelCase__					:    Any          =   hf_bort_model(**SCREAMING_SNAKE_CASE     )[0]

 UpperCamelCase__					:    str          =   output_gluon[0].asnumpy()
 UpperCamelCase__					:    int          =   output_hf[0].detach().numpy()

 UpperCamelCase__					:    Dict          =   np.max(np.abs(hf_layer - gluon_layer     )     ).item()
 UpperCamelCase__					:    Optional[int]          =   np.allclose(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE    , 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:'''    , SCREAMING_SNAKE_CASE     )


if __name__ == "__main__":
       __UpperCamelCase       :       Optional[Any]						       =				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."
       )
       __UpperCamelCase       :       Tuple						       =				parser.parse_args()
       convert_bort_checkpoint_to_pytorch(args.bort_checkpoint_path, args.pytorch_dump_folder_path)






from __future__ import annotations

from collections.abc import Generator

import requests
from bsa import BeautifulSoup

__UpperCamelCase       :       int						       =				"https://www.indeed.co.in/jobs?q=mobile+app+development&l="

def 			_a  (				SCREAMING_SNAKE_CASE	:				str = "mumbai"     ):







 """simple docstring"""



 UpperCamelCase__					:    Optional[int]          =   BeautifulSoup(requests.get(url + location     ).content    , '''html.parser'''     )
 # This attribute finds out all the specifics listed in a job
 for job in soup.find_all('''div'''    , attrs={'''data-tn-component''': '''organicJob'''}     ):
  UpperCamelCase__					:    Optional[Any]          =   job.find('''a'''    , attrs={'''data-tn-element''': '''jobTitle'''}     ).text.strip()
  UpperCamelCase__					:    Union[str, Any]          =   job.find('''span'''    , {'''class''': '''company'''}     ).text.strip()
  yield job_title, company_name


if __name__ == "__main__":
       for i, job in enumerate(fetch_jobs("Bangalore"), 1):
              print(f"Job {i:>2} is {job[0]} at {job[1]}")


