



'''simple docstring'''





import unittest

from transformers import GPTNeoXJapaneseConfig, is_torch_available
from transformers.models.gpt_neox_japanese.tokenization_gpt_neox_japanese import GPTNeoXJapaneseTokenizer
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers import GPTNeoXJapaneseForCausalLM, GPTNeoXJapaneseModel






class __A    :



 '''simple docstring'''







 def __init__(self				,     A				,     A=13				,     A=7				,     A=True				,     A=True				,     A=True				,     A=True				,     A=99				,     A=32				,     A=5				,     A=4				,     A=4				,     A="gelu"				,     A=0.0				,     A=0.1				,     A=True				,     A=512				,     A=16				,     A=2				,     A=0.02				,     A=3				,     A=4				,     A=None				,     )					->  int:


      """simple docstring"""



      _a											=						parent
      _a											=						batch_size
      _a											=						seq_length
      _a											=						is_training
      _a											=						use_input_mask
      _a											=						use_token_type_ids
      _a											=						use_labels
      _a											=						vocab_size
      _a											=						hidden_size
      _a											=						num_hidden_layers
      _a											=						num_attention_heads
      _a											=						intermediate_multiple_size
      _a											=						hidden_act
      _a											=						hidden_dropout
      _a											=						attention_dropout
      _a											=						weight_tying
      _a											=						max_position_embeddings
      _a											=						type_vocab_size
      _a											=						type_sequence_label_size
      _a											=						initializer_range
      _a											=						num_labels
      _a											=						num_choices
      _a											=						scope



 def       a__						(self )					->  Union[str, Any]:


      """simple docstring"""



      _a											=						ids_tensor([self.batch_size, self.seq_length]				,     self.vocab_size )

      _a											=						None
      if self.use_input_mask:
           _a											=						random_attention_mask([self.batch_size, self.seq_length] )

      _a											=						None
      if self.use_labels:
           _a											=						ids_tensor([self.batch_size, self.seq_length]				,     self.num_labels )

      _a											=						self.get_config()

      return config, input_ids, input_mask, token_labels



 def       a__						(self )					->  List[str]:


      """simple docstring"""



      return GPTNeoXJapaneseConfig(
          vocab_size=self.vocab_size				,     hidden_size=self.hidden_size				,     num_hidden_layers=self.num_hidden_layers				,     num_attention_heads=self.num_attention_heads				,     intermediate_multiple_size=self.intermediate_multiple_size				,     hidden_act=self.hidden_act				,     hidden_dropout=self.hidden_dropout				,     attention_dropout=self.attention_dropout				,     weight_tying=self.weight_tying				,     max_position_embeddings=self.max_position_embeddings				,     type_vocab_size=self.type_vocab_size				,     is_decoder=A				,     initializer_range=self.initializer_range				,     )



 def       a__						(self )					->  str:


      """simple docstring"""



      _a						,					_a						,					_a						,					_a											=						self.prepare_config_and_inputs()

      _a											=						True

      return config, input_ids, input_mask, token_labels



 def       a__						(self				,     A				,     A				,     A )					->  Optional[int]:


      """simple docstring"""



      _a											=						GPTNeoXJapaneseModel(config=A )
      model.to(A )
      model.eval()
      _a											=						model(A				,     attention_mask=A )
      _a											=						model(A )
      self.parent.assertEqual(result.last_hidden_state.shape				,     (self.batch_size, self.seq_length, self.hidden_size) )



 def       a__						(self				,     A				,     A				,     A )					->  Optional[int]:


      """simple docstring"""



      _a											=						True
      _a											=						GPTNeoXJapaneseModel(A )
      model.to(A )
      model.eval()
      _a											=						model(A				,     attention_mask=A )
      self.parent.assertEqual(result.last_hidden_state.shape				,     (self.batch_size, self.seq_length, self.hidden_size) )



 def       a__						(self				,     A				,     A				,     A				,     A )					->  str:


      """simple docstring"""



      _a											=						GPTNeoXJapaneseForCausalLM(config=A )
      model.to(A )
      model.eval()
      _a											=						model(A				,     attention_mask=A				,     labels=A )
      self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.seq_length, self.vocab_size) )



 def       a__						(self				,     A				,     A				,     A )					->  Optional[Any]:


      """simple docstring"""



      _a											=						True
      _a											=						GPTNeoXJapaneseForCausalLM(config=A )
      model.to(A )
      model.eval()

      # first forward pass
      _a											=						model(A				,     attention_mask=A				,     use_cache=A )
      _a											=						outputs.past_key_values

      # create hypothetical multiple next token and extent to next_input_ids
      _a											=						ids_tensor((self.batch_size, 3)				,     config.vocab_size )
      _a											=						ids_tensor((self.batch_size, 3)				,     vocab_size=2 )

      # append to next input_ids and
      _a											=						torch.cat([input_ids, next_tokens]				,     dim=-1 )
      _a											=						torch.cat([input_mask, next_mask]				,     dim=-1 )

      _a											=						model(A				,     attention_mask=A				,     output_hidden_states=A )
      _a											=						output_from_no_past['''hidden_states'''][0]
      _a											=						model(
          A				,     attention_mask=A				,     past_key_values=A				,     output_hidden_states=A				,     )['''hidden_states'''][0]

      # select random slice
      _a											=						ids_tensor((1,)				,     output_from_past.shape[-1] ).item()
      _a											=						output_from_no_past[:, -3:, random_slice_idx].detach()
      _a											=						output_from_past[:, :, random_slice_idx].detach()

      self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1] )

      # test that outputs are equal for slice
      self.parent.assertTrue(torch.allclose(A				,     A				,     atol=1E-3 ) )



 def       a__						(self )					->  List[Any]:


      """simple docstring"""



      _a											=						self.prepare_config_and_inputs()
      _a						,					_a						,					_a						,					_a											=						config_and_inputs
      _a											=						{'''input_ids''': input_ids, '''attention_mask''': input_mask}
      return config, inputs_dict






@require_torch
class __A    (						A     ,     A     ,     unittest.TestCase		):



 '''simple docstring'''







 __lowerCamelCase					: List[Any]    = (GPTNeoXJapaneseModel, GPTNeoXJapaneseForCausalLM) if is_torch_available() else ()
 __lowerCamelCase					: str    = (GPTNeoXJapaneseForCausalLM,) if is_torch_available() else ()
 __lowerCamelCase					: Dict    = (
     {'feature-extraction': GPTNeoXJapaneseModel, 'text-generation': GPTNeoXJapaneseForCausalLM}
     if is_torch_available()
     else {}
 )
 __lowerCamelCase					: Any    = False
 __lowerCamelCase					: Union[str, Any]    = False
 __lowerCamelCase					: int    = False
 __lowerCamelCase					: int    = False



 def       a__						(self )					->  Tuple:


      """simple docstring"""



      _a											=						GPTNeoXJapaneseModelTester(self )
      _a											=						ConfigTester(self				,     config_class=A				,     hidden_size=37 )



 def       a__						(self )					->  Any:


      """simple docstring"""



      self.config_tester.run_common_tests()



 def       a__						(self )					->  Tuple:


      """simple docstring"""



      _a						,					_a						,					_a						,					_a											=						self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(A				,     A				,     A )



 def       a__						(self )					->  Dict:


      """simple docstring"""



      _a						,					_a						,					_a						,					_a											=						self.model_tester.prepare_config_and_inputs_for_decoder()
      self.model_tester.create_and_check_model_as_decoder(A				,     A				,     A )



 def       a__						(self )					->  Tuple:


      """simple docstring"""



      _a						,					_a						,					_a						,					_a											=						self.model_tester.prepare_config_and_inputs_for_decoder()

      _a											=						None

      self.model_tester.create_and_check_model_as_decoder(A				,     A				,     A )



 def       a__						(self )					->  List[Any]:


      """simple docstring"""



      _a						,					_a						,					_a						,					_a											=						self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_decoder_model_past_large_inputs(A				,     A				,     A )



 def       a__						(self )					->  Optional[Any]:


      """simple docstring"""



      _a											=						self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_causal_lm(*A )



 @slow
 def       a__						(self )					->  Optional[int]:


      """simple docstring"""



      _a											=						'''abeja/gpt-neox-japanese-2.7b'''

      _a											=						['''データサイエンティストとは、''', '''100年後に必要とされる会社は、''', '''フルリモートの環境で働くために必要なことは、''', '''国境の長いトンネルを抜けると''', '''美味しい日本食といえば、''']

      _a											=						[
          '''データサイエンティストとは、データを分析し、ビジネスに役立つ知見を導き出す専門家のことです。''',
          '''100年後に必要とされる会社は、「人」が中心の会社です。''',
          '''フルリモートの環境で働くために必要なことは、「自分の時間をコントロールする」ことです。''',
          '''国境の長いトンネルを抜けると、そこは雪国だった。''',
          '''美味しい日本食といえば、やっぱりお寿司ですよね。''',
      ]

      _a											=						GPTNeoXJapaneseTokenizer.from_pretrained(A )
      _a											=						GPTNeoXJapaneseForCausalLM.from_pretrained(A )

      _a											=						[]
      for prompt in prompts:
           _a											=						tokenizer(A				,     return_tensors='''pt''' ).input_ids
           _a											=						model.generate(A				,     max_length=50 )
           _a											=						tokenizer.batch_decode(A				,     skip_special_tokens=A )
           predicted_outputs += generated_string
      self.assertListEqual(A				,     A )








'''simple docstring'''





import numpy as np
import qiskit




def lowerCAmelCase						(__A = 8						,			__A = None):



     """simple docstring"""



     _a											=						np.random.default_rng(seed=__A)

     # Roughly 25% of the qubits will contribute to the key.
     # So we take more than we need.
     _a											=						6 * key_len
     # Measurement basis for Alice's qubits.
     _a											=						rng.integers(2						,			size=__A)
     # The set of states Alice will prepare.
     _a											=						rng.integers(2						,			size=__A)
     # Measurement basis for Bob's qubits.
     _a											=						rng.integers(2						,			size=__A)

     # Quantum Circuit to simulate BB84
     _a											=						qiskit.QuantumCircuit(__A						,			name='''BB84''')

     # Alice prepares her qubits according to rules above.
     for index, _ in enumerate(__A):
          if alice_state[index] == 1:
               bbaa_circ.x(__A)
          if alice_basis[index] == 1:
               bbaa_circ.h(__A)
     bbaa_circ.barrier()

     # Bob measures the received qubits according to rules above.
     for index, _ in enumerate(__A):
          if bob_basis[index] == 1:
               bbaa_circ.h(__A)

     bbaa_circ.barrier()
     bbaa_circ.measure_all()

     # Simulate the quantum circuit.
     _a											=						qiskit.Aer.get_backend('''aer_simulator''')
     # We only need to run one shot because the key is unique.
     # Multiple shots will produce the same key.
     _a											=						qiskit.execute(__A						,			__A						,			shots=1						,			seed_simulator=__A)
     # Returns the result of measurement.
     _a											=						job.result().get_counts(__A).most_frequent()

     # Extracting the generated key from the simulation results.
     # Only keep measurement results where Alice and Bob chose the same basis.
     _a											=						''''''.join(
         [
             result_bit
             for alice_basis_bit, bob_basis_bit, result_bit in zip(
                 __A						,			__A						,			__A)
             if alice_basis_bit == bob_basis_bit
         ])

     # Get final key. Pad with 0 if too short, otherwise truncate.
     _a											=						gen_key[:key_len] if len(__A) >= key_len else gen_key.ljust(__A						,			'''0''')
     return key


if __name__ == "__main__":
  print(F"""The generated key is : {bbaa(8, seed=0)}""")
  from doctest import testmod

  testmod()



