code: 
  
  import tempfile
  import unittest
  
  import transformers
  from transformers import XGLMConfig, XGLMTokenizer, is_flax_available, is_torch_available
  from transformers.testing_utils import is_pt_flax_cross_test, require_flax, require_sentencepiece, slow
  
  from ...generation.test_flax_utils import FlaxGenerationTesterMixin
  from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
  
  
  if is_flax_available():
         import jax
         import jax.numpy as jnp
         import numpy as np
  
         from transformers.modeling_flax_pytorch_utils import (
             convert_pytorch_state_dict_to_flax,
             load_flax_weights_in_pytorch_model,
         )
         from transformers.models.xglm.modeling_flax_xglm import FlaxXGLMForCausalLM, FlaxXGLMModel
  
  
  if is_torch_available():
         import torch
  
  
  
  
  
  
  
  @require_flax
  class 		__magic_name__    :
  
     '''simple docstring'''
  
  
  
  
     def __init__(       self,					lowercase_,					lowercase_=14,					lowercase_=7,					lowercase_=True,					lowercase_=True,					lowercase_=True,					lowercase_=99,					lowercase_=32,					lowercase_=5,					lowercase_=4,					lowercase_=37,					lowercase_="gelu",					lowercase_=0.1,					lowercase_=0.1,					lowercase_=512,					lowercase_=0.02,					lowercase_=None,					)							->					Optional[int]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=parent
       a__						=batch_size
       a__						=seq_length
       a__						=is_training
       a__						=use_input_mask
       a__						=use_labels
       a__						=vocab_size
       a__						=d_model
       a__						=num_hidden_layers
       a__						=num_attention_heads
       a__						=ffn_dim
       a__						=activation_function
       a__						=activation_dropout
       a__						=attention_dropout
       a__						=max_position_embeddings
       a__						=initializer_range
       a__						=None
       a__						=0
       a__						=2
       a__						=1
  
  
  
     def 				_UpperCAmelCase				(       self )							->					str:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=np.clip(ids_tensor([self.batch_size, self.seq_length],					self.vocab_size ),					3,					self.vocab_size )
  
       a__						=None
       if self.use_input_mask:
         a__						=random_attention_mask([self.batch_size, self.seq_length] )
  
       a__						=XGLMConfig(
           vocab_size=self.vocab_size,					d_model=self.hidden_size,					num_layers=self.num_hidden_layers,					attention_heads=self.num_attention_heads,					ffn_dim=self.ffn_dim,					activation_function=self.activation_function,					activation_dropout=self.activation_dropout,					attention_dropout=self.attention_dropout,					max_position_embeddings=self.max_position_embeddings,					initializer_range=self.initializer_range,					use_cache=_A,					bos_token_id=self.bos_token_id,					eos_token_id=self.eos_token_id,					pad_token_id=self.pad_token_id,					)
  
       return (config, input_ids, input_mask)
  
  
  
     def 				_UpperCAmelCase				(       self )							->					Dict:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=self.prepare_config_and_inputs()
       a__						=config_and_inputs
       a__						={'input_ids': input_ids, 'attention_mask': attention_mask}
       return config, inputs_dict
  
  
  
     def 				_UpperCAmelCase				(       self )							->					List[Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=self.prepare_config_and_inputs()
  
       a__						=floats_tensor([self.batch_size, self.seq_length, self.hidden_size] )
       a__						=ids_tensor([self.batch_size, self.seq_length],					vocab_size=2 )
  
       return (
           config,
           input_ids,
           attention_mask,
           encoder_hidden_states,
           encoder_attention_mask,
       )
  
  
  
     def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_,					lowercase_,					lowercase_ )							->					Optional[Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=20
       a__						=model_class_name(_A )
  
       a__						=model.init_cache(input_ids.shape[0],					_A )
       a__						=jnp.ones((input_ids.shape[0], max_decoder_length),					dtype='''i4''' )
  
       a__						=jnp.broadcast_to(
           jnp.arange(input_ids.shape[-1] - 1 )[None, :],					(input_ids.shape[0], input_ids.shape[-1] - 1) )
       a__						=model(
           input_ids[:, :-1],					attention_mask=_A,					past_key_values=_A,					position_ids=_A,					)
  
       a__						=jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]],					dtype='''i4''' )
       a__						=model(
           input_ids[:, -1:],					attention_mask=_A,					past_key_values=outputs_cache.past_key_values,					position_ids=_A,					)
  
       a__						=model(_A )
  
       a__						=np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5]) ) )
       self.parent.assertTrue(diff < 1E-3,					msg=F"""Max diff is {diff}""" )
  
  
  
     def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_,					lowercase_,					lowercase_ )							->					Optional[int]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=20
       a__						=model_class_name(_A )
  
       a__						=jnp.concatenate(
           [attention_mask, jnp.zeros((attention_mask.shape[0], max_decoder_length - attention_mask.shape[1]) )],					axis=-1,					)
  
       a__						=model.init_cache(input_ids.shape[0],					_A )
       a__						=jnp.broadcast_to(
           jnp.arange(input_ids.shape[-1] - 1 )[None, :],					(input_ids.shape[0], input_ids.shape[-1] - 1) )
  
       a__						=model(
           input_ids[:, :-1],					attention_mask=_A,					past_key_values=_A,					position_ids=_A,					)
       a__						=jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]],					dtype='''i4''' )
       a__						=model(
           input_ids[:, -1:],					past_key_values=outputs_cache.past_key_values,					attention_mask=_A,					position_ids=_A,					)
  
       a__						=model(_A,					attention_mask=_A )
       a__						=np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5]) ) )
       self.parent.assertTrue(diff < 1E-3,					msg=F"""Max diff is {diff}""" )
  
  
  
  
  
  
  
  @require_sentencepiece
  @require_flax
  class 		__magic_name__    (							lowercase__	, lowercase__	, unittest.TestCase							):
  
     '''simple docstring'''
  
  
  
  
     lowerCamelCase__				:			List[Any]												=     (FlaxXGLMModel, FlaxXGLMForCausalLM) if is_flax_available() else ()
     lowerCamelCase__				:			Tuple												=     (FlaxXGLMForCausalLM,) if is_flax_available() else ()
  
  
  
     def 				_UpperCAmelCase				(       self )							->					Tuple:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=FlaxXGLMModelTester(self )
  
  
  
     def 				_UpperCAmelCase				(       self )							->					Any:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       for model_class_name in self.all_model_classes:
         a__						=self.model_tester.prepare_config_and_inputs()
         self.model_tester.check_use_cache_forward(_A,					_A,					_A,					_A )
  
  
  
     def 				_UpperCAmelCase				(       self )							->					Any:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       for model_class_name in self.all_model_classes:
         a__						=self.model_tester.prepare_config_and_inputs()
         self.model_tester.check_use_cache_forward_with_attn_mask(
             _A,					_A,					_A,					_A )
  
  
  
     @slow
     def 				_UpperCAmelCase				(       self )							->					Optional[Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=XGLMTokenizer.from_pretrained('''XGLM''',					padding_side='''left''' )
       a__						=tokenizer(['''Hello this is a long string''', '''Hey'''],					return_tensors='''np''',					padding=_A,					truncation=_A )
  
       a__						=FlaxXGLMForCausalLM.from_pretrained('''facebook/xglm-564M''' )
       a__						=1
       a__						=False
  
       a__						=jax.jit(model.generate )
  
       a__						=jit_generate(inputs['''input_ids'''],					attention_mask=inputs['''attention_mask'''] ).sequences
  
       a__						=tokenizer.batch_decode(_A,					skip_special_tokens=_A )
  
       a__						=[
           'Hello this is a long string of questions, but I\'m not sure if I\'m',
           'Hey, I\'m a newbie to the forum and I\'',
       ]
  
       self.assertListEqual(_A,					_A )
  
  
  
     @is_pt_flax_cross_test
     def 				_UpperCAmelCase				(       self )							->					Optional[int]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=self.model_tester.prepare_config_and_inputs_for_common()
  
       for model_class in self.all_model_classes:
         with self.subTest(model_class.__name__ ):
           # prepare inputs
           a__						=self._prepare_for_class(_A,					_A )
           a__						={k: torch.tensor(v.tolist() ) for k, v in prepared_inputs_dict.items()}
  
           # load corresponding PyTorch class
           a__						=model_class.__name__[4:]  # Skip the "Flax" at the beginning
           a__						=getattr(_A,					_A )
  
           a__						=pt_inputs['input_ids'].shape
           a__						=np.random.randint(0,					seq_length - 1,					size=(batch_size,) )
           for batch_idx, start_index in enumerate(_A ):
             a__						=0
             a__						=1
             a__						=0
             a__						=1
           a__						=pt_model_class(_A ).eval()
           # Flax models don't use the `use_cache` option and cache is not returned as a default.
           # So we disable `use_cache` here for PyTorch model.
           a__						=False
           a__						=model_class(_A,					dtype=jnp.floataa )
           a__						=convert_pytorch_state_dict_to_flax(pt_model.state_dict(),					_A )
           a__						=fx_state
  
           with torch.no_grad():
             a__						=pt_model(**_A ).to_tuple()
  
           a__						=fx_model(**_A ).to_tuple()
           self.assertEqual(len(_A ),					len(_A ),					'''Output lengths differ between Flax and PyTorch''' )
           for fx_output, pt_output in zip(_A,					_A ):
             self.assert_almost_equals(fx_output[:, -1],					pt_output[:, -1].numpy(),					4E-2 )
  
           with tempfile.TemporaryDirectory() as tmpdirname:
             pt_model.save_pretrained(_A )
             a__						=model_class.from_pretrained(_A,					from_pt=_A )
  
           a__						=fx_model_loaded(**_A ).to_tuple()
           self.assertEqual(
               len(_A ),					len(_A ),					'''Output lengths differ between Flax and PyTorch''' )
           for fx_output_loaded, pt_output in zip(_A,					_A ):
             self.assert_almost_equals(fx_output_loaded[:, -1],					pt_output[:, -1].numpy(),					4E-2 )
  
  
  
     @is_pt_flax_cross_test
     def 				_UpperCAmelCase				(       self )							->					Any:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=self.model_tester.prepare_config_and_inputs_for_common()
       for model_class in self.all_model_classes:
         with self.subTest(model_class.__name__ ):
           # prepare inputs
           a__						=self._prepare_for_class(_A,					_A )
           a__						={k: torch.tensor(v.tolist() ) for k, v in prepared_inputs_dict.items()}
  
           # load corresponding PyTorch class
           a__						=model_class.__name__[4:]  # Skip the "Flax" at the beginning
           a__						=getattr(_A,					_A )
  
           a__						=pt_model_class(_A ).eval()
           a__						=False
           a__						=model_class(_A,					dtype=jnp.floataa )
  
           a__						=load_flax_weights_in_pytorch_model(_A,					fx_model.params )
           a__						=pt_inputs['input_ids'].shape
           a__						=np.random.randint(0,					seq_length - 1,					size=(batch_size,) )
           for batch_idx, start_index in enumerate(_A ):
             a__						=0
             a__						=1
             a__						=0
             a__						=1
  
           # make sure weights are tied in PyTorch
           pt_model.tie_weights()
  
           with torch.no_grad():
             a__						=pt_model(**_A ).to_tuple()
  
           a__						=fx_model(**_A ).to_tuple()
           self.assertEqual(len(_A ),					len(_A ),					'''Output lengths differ between Flax and PyTorch''' )
           for fx_output, pt_output in zip(_A,					_A ):
             self.assert_almost_equals(fx_output[:, -1],					pt_output[:, -1].numpy(),					4E-2 )
  
           with tempfile.TemporaryDirectory() as tmpdirname:
             fx_model.save_pretrained(_A )
             a__						=pt_model_class.from_pretrained(_A,					from_flax=_A )
  
           with torch.no_grad():
             a__						=pt_model_loaded(**_A ).to_tuple()
  
           self.assertEqual(
               len(_A ),					len(_A ),					'''Output lengths differ between Flax and PyTorch''' )
           for fx_output, pt_output in zip(_A,					_A ):
             self.assert_almost_equals(fx_output[:, -1],					pt_output[:, -1].numpy(),					4E-2 )
  
  
  
     @slow
     def 				_UpperCAmelCase				(       self )							->					int:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       for model_class_name in self.all_model_classes:
         a__						=model_class_name.from_pretrained('''facebook/xglm-564M''' )
         a__						=model(np.ones((1, 1) ) )
         self.assertIsNotNone(_A )
  
style_context: 
  
  import torch
  from transformers import AutoModelForSequenceClassification, AutoTokenizer, Trainer, TrainingArguments
  
  import datasets
  
  
  lowerCamelCase     =      '''\
  @article{eddine2021frugalscore,
    title={FrugalScore: Learning Cheaper, Lighter and Faster Evaluation Metrics for Automatic Text Generation},
    author={Eddine, Moussa Kamal and Shang, Guokan and Tixier, Antoine J-P and Vazirgiannis, Michalis},
    journal={arXiv preprint arXiv:2110.08559},
    year={2021}
  }
  '''
  
  lowerCamelCase     =      '''\
  FrugalScore is a reference-based metric for NLG models evaluation. It is based on a distillation approach that allows to learn a fixed, low cost version of any expensive NLG metric, while retaining most of its original performance.
  '''
  
  
  lowerCamelCase     =      '''
  Calculates how good are predictions given some references, using certain scores.
  Args:
      predictions (list of str): list of predictions to score. Each predictions
          should be a string.
      references (list of str): list of reference for each prediction. Each
          reference should be a string.
      batch_size (int): the batch size for predictions.
      max_length (int): maximum sequence length.
      device (str): either gpu or cpu
  Returns:
      scores (list of int): list of scores.
  Examples:
      >>> frugalscore = datasets.load_metric("frugalscore")
      >>> results = frugalscore.compute(predictions=[\'hello there\', \'huggingface\'], references=[\'hello world\', \'hugging face\'])
      >>> print([round(s, 3) for s in results["scores"]])
      [0.631, 0.645]
  '''
  
  
  
  
  
  
  
  @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION	, _KWARGS_DESCRIPTION							)
  class 		__magic_name__    (							datasets.Metric							):
  
     '''simple docstring'''
  
  
  
  
     def 				_UpperCAmelCase				(       self )							->					Optional[int]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       return datasets.MetricInfo(
           description=_DESCRIPTION,					citation=_CITATION,					inputs_description=_KWARGS_DESCRIPTION,					features=datasets.Features(
               {
                   '''predictions''': datasets.Value('''string''' ),
                   '''references''': datasets.Value('''string''' ),
               } ),					homepage='''https://github.com/moussaKam/FrugalScore''',					)
  
  
  
     def 				_UpperCAmelCase				(       self,					lowercase_ )							->					Dict:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       if self.config_name == "default":
         a__						='''moussaKam/frugalscore_tiny_bert-base_bert-score'''
       else:
         a__						=self.config_name
       a__						=AutoModelForSequenceClassification.from_pretrained(lowercase_ )
       a__						=AutoTokenizer.from_pretrained(lowercase_ )
  
  
  
     def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_,					lowercase_=32,					lowercase_=128,					lowercase_=None,					)							->					Union[str, Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       assert len(lowercase_ ) == len(
           lowercase_ ), "predictions and references should have the same number of sentences."
       if device is not None:
         assert device in ["gpu", "cpu"], "device should be either gpu or cpu."
       else:
         a__						='''gpu''' if torch.cuda.is_available() else '''cpu'''
       a__						=TrainingArguments(
           '''trainer''',					fpaa=(device == '''gpu'''),					per_device_eval_batch_size=lowercase_,					report_to='''all''',					no_cuda=(device == '''cpu'''),					log_level='''warning''',					)
       a__						={'''sentence1''': predictions, '''sentence2''': references}
       a__						=datasets.Dataset.from_dict(lowercase_ )
  
       def tokenize_function(lowercase_ ):
         return self.tokenizer(
             data['''sentence1'''],					data['''sentence2'''],					max_length=lowercase_,					truncation=lowercase_,					padding=lowercase_ )
  
       a__						=raw_datasets.map(lowercase_,					batched=lowercase_ )
       tokenized_datasets.remove_columns(['''sentence1''', '''sentence2'''] )
       a__						=Trainer(self.model,					lowercase_,					tokenizer=self.tokenizer )
       a__						=trainer.predict(lowercase_ )
       return {"scores": list(predictions.predictions.squeeze(-1 ) )}
  