code: 
  
  
  import json
  import os
  from collections.abc import Mapping
  from typing import Dict, List, Optional, Union
  
  import numpy as np
  import torch
  
  from .imports import is_safetensors_available
  
  
  
  
  
  
  
  def  _lowerCamelCase(			lowercase__     ,				lowercase__     ,				lowercase__     ,				lowercase__=None			)		->			int:
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		__lowercase=    None
  		# Check the string instead of the dtype to be compatible with versions of PyTorch that don't have bfloat16.
  		if str(weight.dtype			) == "torch.bfloat16":
  				# Need to reinterpret the underlined data as int16 since NumPy does not handle bfloat16s.
  				__lowercase=    weight.view(torch.intaa			)
  				__lowercase=    'bfloat16'
  		__lowercase=    weight.cpu().numpy()
  		__lowercase=    os.path.join(lowercase__     ,				F'{weight_name}.dat'			)
  		if index is not None:
  				if dtype is None:
  						__lowercase=    str(array.dtype			)
  				__lowercase=    {'dtype': dtype, 'shape': list(array.shape			)}
  		if array.ndim == 0:
  				__lowercase=    array[None]
  		__lowercase=    np.memmap(lowercase__     ,				dtype=array.dtype     ,				mode='w+'     ,				shape=array.shape			)
  		__lowercase=    array[:]
  		file_array.flush()
  		return index
  
  
  
  
  
  
  
  def  _lowerCamelCase(			lowercase__     ,				lowercase__			)		->			List[str]:
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		__lowercase=    tuple(weight_info['shape']			)
  		if shape == ():
  				# NumPy memory-mapped arrays can't have 0 dims so it was saved as 1d tensor
  				__lowercase=    (1,)
  
  		__lowercase=    weight_info['dtype']
  		if dtype == "bfloat16":
  				# NumPy does not support bfloat16 so this was saved as a int16
  				__lowercase=    'int16'
  
  		__lowercase=    np.memmap(lowercase__     ,				dtype=lowercase__     ,				shape=lowercase__     ,				mode='r'			)
  
  		if len(weight_info['shape']			) == 0:
  				__lowercase=    weight[0]
  		__lowercase=    torch.tensor(lowercase__			)
  		if weight_info["dtype"] == "bfloat16":
  				__lowercase=    weight.view(torch.bfloataa			)
  
  		return weight
  
  
  
  
  
  
  
  def  _lowerCamelCase(			lowercase__     ,				lowercase__			)		->			Optional[Any]:
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		if index is None or len(lowercase__			) == 0:
  				# Nothing to save
  				return
  
  		__lowercase=    os.path.join(lowercase__     ,				'index.json'			)
  		if os.path.isfile(lowercase__			):
  				with open(lowercase__     ,				'r'     ,				encoding='utf-8'			) as f:
  						__lowercase=    json.load(lowercase__			)
  		else:
  				__lowercase=    {}
  		current_index.update(lowercase__			)
  
  		with open(lowercase__     ,				'w'     ,				encoding='utf-8'			) as f:
  				json.dump(lowercase__     ,				lowercase__     ,				indent=2			)
  
  
  
  
  
  
  
  def  _lowerCamelCase(			lowercase__     ,				lowercase__			)		->			int:
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		os.makedirs(lowercase__     ,				exist_ok=lowercase__			)
  		__lowercase=    {}
  		for name, parameter in state_dict.items():
  				__lowercase=    offload_weight(lowercase__     ,				lowercase__     ,				lowercase__     ,				index=lowercase__			)
  
  		# Update index
  		save_offload_index(lowercase__     ,				lowercase__			)
  
  
  
  
  
  class    A					(     A_				):
  
  
  							def __init__(self   ,       lowerCAmelCase   ,       lowerCAmelCase      ):
  									__lowercase=    dataset
  									__lowercase=    prefix
  
  
  							def __getitem__(self   ,       lowerCAmelCase      ):
  									return self.dataset[f'{self.prefix}{key}']
  
  
  							def __iter__(self      ):
  									return iter([key for key in self.dataset if key.startswith(self.prefix      )]      )
  
  
  
  
  
  
  
  							def __len__(self      ):
  									return len(self.dataset      )
  
  
  
  
  
  class    A					(     A_				):
  
  
  							def __init__(self   ,       lowerCAmelCase = None   ,       lowerCAmelCase = None   ,       lowerCAmelCase = None   ,       lowerCAmelCase=None   ,       ):
  									if state_dict is None and save_folder is None:
  											raise ValueError('Need either a `state_dict` or a `save_folder` containing offloaded weights.'      )
  
  									__lowercase=    {} if state_dict is None else state_dict
  									__lowercase=    save_folder
  									if index is None and save_folder is not None:
  											with open(os.path.join(lowerCAmelCase   ,       'index.json'      )      ) as f:
  													__lowercase=    json.load(lowerCAmelCase      )
  									__lowercase=    {} if index is None else index
  									__lowercase=    list(self.state_dict.keys()      )
  									self.all_keys.extend([key for key in self.index if key not in self.all_keys]      )
  									__lowercase=    device
  
  
  							def __getitem__(self   ,       lowerCAmelCase      ):
  									# State dict gets priority
  									if key in self.state_dict:
  											return self.state_dict[key]
  									__lowercase=    self.index[key]
  									if weight_info.get('safetensors_file'      ) is not None:
  											if not is_safetensors_available():
  													raise ImportError('These offloaded weights require the use of safetensors: `pip install safetensors`.'      )
  
  											from safetensors import safe_open
  
  											__lowercase=    'cpu' if self.device is None else self.device
  											with safe_open(weight_info['safetensors_file']   ,       framework='pt'   ,       device=lowerCAmelCase      ) as f:
  													__lowercase=    f.get_tensor(weight_info.get('weight_name'   ,       lowerCAmelCase      )      )
  
  											if "dtype" in weight_info:
  													return tensor.to(getattr(lowerCAmelCase   ,       weight_info['dtype']      )      )
  											else:
  													return tensor
  
  									__lowercase=    os.path.join(self.save_folder   ,       f'{key}.dat'      )
  									return load_offloaded_weight(lowerCAmelCase   ,       lowerCAmelCase      )
  
  
  							def __iter__(self      ):
  									return iter(self.all_keys      )
  
  
  
  
  
  
  
  							def __len__(self      ):
  									return len(self.all_keys      )
  
  
  
  
  
  
  
  def  _lowerCamelCase(			lowercase__     ,				lowercase__			)		->			str:
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		__lowercase=    {}
  		for module_name in submodule_names:
  				# We want to catch module_name parameter (module_name.xxx) or potentially module_name, but not any of the
  				# submodules that could being like module_name (transformers.h.1 and transformers.h.10 for instance)
  				result.update(
  				    {
  				        key: param
  				        for key, param in state_dict.items()
  				        if key == module_name or key.startswith(module_name + '.'			)
  				    }			)
  		return result
  
  
  
  
  
  
  
style_context: 
  
  
  import unittest
  
  from transformers import is_torch_available
  from transformers.testing_utils import require_torch, slow, torch_device
  
  
  if is_torch_available():
  	import torch
  
  	from transformers import XLMProphetNetForConditionalGeneration, XLMProphetNetTokenizer
  
  
  
  
  
  @require_torch
  class    A					(     unittest.TestCase				):
  
  
  							@slow
  							def     _A (self      ):
  									__lowercase=    XLMProphetNetForConditionalGeneration.from_pretrained('microsoft/xprophetnet-large-wiki100-cased'      )
  									model.to(lowerCAmelCase      )
  
  									# encoder-decoder outputs
  									__lowercase=    torch.tensor([[1_7, 9_6_2_0_8, 1_0_3_4_7_1, 2]]      ).to(lowerCAmelCase      )
  									__lowercase=    torch.tensor(
  									    [[2, 2_5_0, 9_9_5_3, 3_4, 6_9_4_8_9, 1_6_2_0, 3_2, 1_1_8_4_2_4, 6_2_4, 2_1_0, 1_0_5, 2_9_1_3, 1_0_3_2, 3_5_1]]      ).to(lowerCAmelCase      )
  									__lowercase=    model(
  									    input_ids=lowerCAmelCase   ,       attention_mask=lowerCAmelCase   ,       encoder_outputs=lowerCAmelCase   ,       decoder_input_ids=lowerCAmelCase      )
  									__lowercase=    output[0]
  									__lowercase=    torch.Size((1, 1_4, 2_5_0_0_1_2)      )
  									self.assertEqual(output_predited_logis.shape   ,       lowerCAmelCase      )
  									__lowercase=    torch.tensor(
  									    [[[-6.39_86, -8.23_91, 12.51_89], [-6.32_89, -8.08_64, 12.62_11], [-6.24_18, -8.04_45, 12.79_68]]]      ).to(lowerCAmelCase      )
  									self.assertTrue(torch.allclose(output_predited_logis[:, :3, :3]   ,       lowerCAmelCase   ,       atol=1E-4      )      )
  
  									# encoder outputs
  									__lowercase=    model.prophetnet.encoder(lowerCAmelCase      )[0]
  									__lowercase=    torch.tensor(
  									    [[[-1.42_60, -0.76_28, 0.84_53], [-1.47_19, -0.13_91, 0.78_07], [-1.76_78, 0.01_14, 0.46_46]]]      ).to(lowerCAmelCase      )
  									__lowercase=    torch.Size((1, 4, 1_0_2_4)      )
  									self.assertEqual(encoder_outputs.shape   ,       lowerCAmelCase      )
  									self.assertTrue(torch.allclose(encoder_outputs[:, :3, :3]   ,       lowerCAmelCase   ,       atol=1E-4      )      )
  
  									# decoder outputs
  									__lowercase=    model.prophetnet.decoder(
  									    lowerCAmelCase   ,       encoder_hidden_states=lowerCAmelCase   ,       )
  									__lowercase=    decoder_outputs[1].view(1   ,       model.config.ngram   ,       1_4   ,       -1      )
  									__lowercase=    model.lm_head(lowerCAmelCase      )
  									__lowercase=    predicting_streams_logits[:, 0]
  									self.assertTrue(torch.allclose(next_first_stream_logits[:, :3, :3]   ,       lowerCAmelCase   ,       atol=1E-4      )      )
  
  
  							@slow
  							def     _A (self      ):
  									__lowercase=    XLMProphetNetForConditionalGeneration.from_pretrained(
  									    'microsoft/xprophetnet-large-wiki100-cased-xglue-ntg'      )
  									model.to(lowerCAmelCase      )
  
  									__lowercase=    torch.tensor([[1_7, 9_6_2_0_8, 1_0_3_4_7_1, 2]]      ).to(lowerCAmelCase      )
  									__lowercase=    torch.tensor(
  									    [[2, 2_5_0, 9_9_5_3, 3_4, 6_9_4_8_9, 1_6_2_0, 3_2, 1_1_8_4_2_4, 6_2_4, 2_1_0, 1_0_5, 2_9_1_3, 1_0_3_2, 3_5_1]]      ).to(lowerCAmelCase      )
  									__lowercase=    model(
  									    input_ids=lowerCAmelCase   ,       attention_mask=lowerCAmelCase   ,       encoder_outputs=lowerCAmelCase   ,       decoder_input_ids=lowerCAmelCase      )
  									__lowercase=    output[0]
  									__lowercase=    torch.Size((1, 1_4, 2_5_0_0_1_2)      )
  									self.assertEqual(output_predited_logis.shape   ,       lowerCAmelCase      )
  									# compare the actual values for a slice.
  									__lowercase=    torch.tensor(
  									    [[[-9.22_53, -9.71_73, -6.35_29], [-7.67_01, -9.01_45, -1.93_82], [-8.01_95, -7.00_04, -0.15_23]]]      ).to(lowerCAmelCase      )
  
  									self.assertTrue(torch.allclose(output_predited_logis[:, :3, :3]   ,       lowerCAmelCase   ,       atol=1E-4      )      )
  
  
  
  
  
  
  
  							@slow
  							def     _A (self      ):
  									__lowercase=    XLMProphetNetForConditionalGeneration.from_pretrained(
  									    'microsoft/xprophetnet-large-wiki100-cased-xglue-ntg'      )
  									model.to(lowerCAmelCase      )
  									__lowercase=    5_1_2
  
  									__lowercase=    XLMProphetNetTokenizer.from_pretrained('microsoft/xprophetnet-large-wiki100-cased-xglue-ntg'      )
  
  									__lowercase=    (
  									    'Microsoft Corporation intends to officially end free support for the Windows 7 operating system after'
  									    ' January 14, 2020, according to the official portal of the organization. From that day, users of this'
  									    ' system will not be able to receive security updates, which could make their computers vulnerable to'
  									    ' cyber attacks.'
  									)
  									__lowercase=    (
  									    'орпорация Microsoft намерена официально прекратить бесплатную поддержку операционной системы Windows 7'
  									    ' после 14 января 2020 года, сообщается на официальном портале организации . С указанного дня пользователи'
  									    ' этой системы не смогут получать обновления безопасности, из-за чего их компьютеры могут стать уязвимыми'
  									    ' к кибератакам.'
  									)
  									__lowercase=    (
  									    '根据该组织的官方门户网站，微软公司打算在2020年1月14日之后正式终止对Windows 7操作系统的免费支持。从那时起，该系统的用户将无法接收安全更新，这可能会使他们的计算机容易受到网络攻击。'
  									)
  
  									__lowercase=    tokenizer(
  									    [EN_SENTENCE, RU_SENTENCE, ZH_SENTENCE]   ,       padding=lowerCAmelCase   ,       max_length=2_5_5   ,       return_tensors='pt'      ).input_ids
  									__lowercase=    input_ids.to(lowerCAmelCase      )
  
  									__lowercase=    model.generate(
  									    lowerCAmelCase   ,       num_beams=1_0   ,       length_penalty=1.0   ,       no_repeat_ngram_size=3   ,       early_stopping=lowerCAmelCase      )
  									__lowercase=    [tokenizer.decode(lowerCAmelCase   ,       skip_special_tokens=lowerCAmelCase      ) for g in summary_ids]
  									__lowercase=    'Microsoft to end Windows 7 free support after January 14, 2020'
  									__lowercase=    'Microsoft намерена прекратить бесплатную поддержку Windows 7 после 14 января 2020 года'
  									__lowercase=    '微软打算终止对Windows 7操作系统的免费支持'
  									self.assertListEqual(
  									    [EXPECTED_TITLE_EN, EXPECTED_TITLE_RU, EXPECTED_TITLE_ZH]   ,       lowerCAmelCase   ,       )
  
  									__lowercase=    model.generate(
  									    lowerCAmelCase   ,       num_beams=1   ,       length_penalty=1.0   ,       no_repeat_ngram_size=3   ,       early_stopping=lowerCAmelCase      )
  									__lowercase=    [
  									    tokenizer.convert_ids_to_tokens(lowerCAmelCase   ,       skip_special_tokens=lowerCAmelCase      ) for g in summary_ids_beama
  									]
  									__lowercase=    '▁Microsoft ▁to ▁end ▁free ▁support ▁for ▁Windows ▁7'.split(' '      )
  									__lowercase=    '▁Microsoft ▁намерен а ▁прекрати ть ▁бес плат ную ▁поддержку ▁Windows ▁7 ▁после ▁14 ▁января ▁2020 ▁года'.split(
  									    ' '      )
  									__lowercase=    '微软 公司 打算 终止 对 Windows ▁7 操作 系统的 免费 支持'.split(' '      )
  									self.assertListEqual(
  									    [EXPECTED_TITLE_EN_BEAM1_TOK, EXPECTED_TITLE_RU_BEAM1_TOK, EXPECTED_TITLE_ZH_BEAM1_TOK]   ,       lowerCAmelCase   ,       )
  
  
  
  
  
  
  