


import unittest

import numpy as np
import timeout_decorator  # noqa

from transformers import MBartConfig, is_flax_available
from transformers.testing_utils import require_flax, require_sentencepiece, require_tokenizers, slow
from transformers.utils import cached_property

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor


if is_flax_available():
  import os

  # The slow tests are often failing with OOM error on GPU
  # This makes JAX allocate exactly what is needed on demand, and deallocate memory that is no longer needed
  # but will be slower as stated here https://jax.readthedocs.io/en/latest/gpu_memory_allocation.html
  __a   				=      '''platform'''

  import jax
  import jax.numpy as jnp

  from transformers import AutoTokenizer
  from transformers.models.mbart.modeling_flax_mbart import (
      FlaxMBartForConditionalGeneration,
      FlaxMBartForQuestionAnswering,
      FlaxMBartForSequenceClassification,
      FlaxMBartModel,
      shift_tokens_right,
  )




def 			__lowercase	(						_UpperCamelCase,    _UpperCamelCase,    _UpperCamelCase=None,    _UpperCamelCase=None,    _UpperCamelCase=None,    _UpperCamelCase=None,    _UpperCamelCase=None,    _UpperCamelCase=None,    )    ->Optional[int]:







      """simple docstring"""

      if attention_mask is None:
            lowercase			:   str					   =		np.where(input_ids != config.pad_token_id,    1,    0     )
      if decoder_attention_mask is None:
            lowercase			:   Dict					   =		np.where(decoder_input_ids != config.pad_token_id,    1,    0     )
      if head_mask is None:
            lowercase			:   Union[str, Any]					   =		np.ones((config.encoder_layers, config.encoder_attention_heads)     )
      if decoder_head_mask is None:
            lowercase			:   Optional[Any]					   =		np.ones((config.decoder_layers, config.decoder_attention_heads)     )
      if cross_attn_head_mask is None:
            lowercase			:   Optional[int]					   =		np.ones((config.decoder_layers, config.decoder_attention_heads)     )
      return {
          "input_ids": input_ids,
          "decoder_input_ids": decoder_input_ids,
          "attention_mask": attention_mask,
          "decoder_attention_mask": decoder_attention_mask,
      }







class 				__SCREAMING_SNAKE_CASE   (			unittest.TestCase   ):


      def __init__(							self							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__=13							,						SCREAMING_SNAKE_CASE__=7							,						SCREAMING_SNAKE_CASE__=True							,						SCREAMING_SNAKE_CASE__=False							,						SCREAMING_SNAKE_CASE__=99							,						SCREAMING_SNAKE_CASE__=16							,						SCREAMING_SNAKE_CASE__=2							,						SCREAMING_SNAKE_CASE__=4							,						SCREAMING_SNAKE_CASE__=4							,						SCREAMING_SNAKE_CASE__="gelu"							,						SCREAMING_SNAKE_CASE__=0.1							,						SCREAMING_SNAKE_CASE__=0.1							,						SCREAMING_SNAKE_CASE__=32							,						SCREAMING_SNAKE_CASE__=2							,						SCREAMING_SNAKE_CASE__=1							,						SCREAMING_SNAKE_CASE__=0							,						SCREAMING_SNAKE_CASE__=2							,						SCREAMING_SNAKE_CASE__=0.02							,						):
            lowercase			:   Optional[int]					   =		parent
            lowercase			:   List[str]					   =		batch_size
            lowercase			:   List[str]					   =		seq_length
            lowercase			:   Tuple					   =		is_training
            lowercase			:   str					   =		use_labels
            lowercase			:   str					   =		vocab_size
            lowercase			:   List[Any]					   =		hidden_size
            lowercase			:   int					   =		num_hidden_layers
            lowercase			:   List[Any]					   =		num_attention_heads
            lowercase			:   Union[str, Any]					   =		intermediate_size
            lowercase			:   str					   =		hidden_act
            lowercase			:   str					   =		hidden_dropout_prob
            lowercase			:   Optional[Any]					   =		attention_probs_dropout_prob
            lowercase			:   List[str]					   =		max_position_embeddings
            lowercase			:   List[str]					   =		eos_token_id
            lowercase			:   Dict					   =		pad_token_id
            lowercase			:   str					   =		bos_token_id
            lowercase			:   List[str]					   =		decoder_start_token_id
            lowercase			:   Dict					   =		initializer_range


      def        __lowerCamelCase			(							self		):
            lowercase			:   str					   =		np.clip(ids_tensor([self.batch_size, self.seq_length - 1]							,						self.vocab_size		)							,						3							,						self.vocab_size		)
            lowercase			:   Any					   =		np.concatenate((input_ids, 2 * np.ones((self.batch_size, 1)							,						dtype=np.intaa		))							,						-1		)

            lowercase			:   Optional[Any]					   =		shift_tokens_right(SCREAMING_SNAKE_CASE__							,						1		)

            lowercase			:   Optional[Any]					   =		MBartConfig(
                vocab_size=self.vocab_size							,						d_model=self.hidden_size							,						encoder_layers=self.num_hidden_layers							,						decoder_layers=self.num_hidden_layers							,						encoder_attention_heads=self.num_attention_heads							,						decoder_attention_heads=self.num_attention_heads							,						encoder_ffn_dim=self.intermediate_size							,						decoder_ffn_dim=self.intermediate_size							,						dropout=self.hidden_dropout_prob							,						attention_dropout=self.attention_probs_dropout_prob							,						max_position_embeddings=self.max_position_embeddings							,						eos_token_id=self.eos_token_id							,						bos_token_id=self.bos_token_id							,						pad_token_id=self.pad_token_id							,						decoder_start_token_id=self.decoder_start_token_id							,						initializer_range=self.initializer_range							,						use_cache=SCREAMING_SNAKE_CASE__							,						)
            lowercase			:   str					   =		prepare_mbart_inputs_dict(SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__		)
            return config, inputs_dict


      def        __lowerCamelCase			(							self		):
            lowercase   ,			lowercase			:   Tuple					   =		self.prepare_config_and_inputs()
            return config, inputs_dict


      def        __lowerCamelCase			(							self							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__		):
            lowercase			:   Union[str, Any]					   =		20
            lowercase			:   Optional[int]					   =		model_class_name(SCREAMING_SNAKE_CASE__		)

            lowercase			:   Tuple					   =		model.encode(inputs_dict['''input_ids''']		)

            lowercase   ,			lowercase			:   Tuple					   =		(
                inputs_dict['''decoder_input_ids'''],
                inputs_dict['''decoder_attention_mask'''],
            )

            lowercase			:   str					   =		model.init_cache(decoder_input_ids.shape[0]							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__		)
            lowercase			:   Union[str, Any]					   =		jnp.ones((decoder_input_ids.shape[0], max_decoder_length)							,						dtype='''i4'''		)

            lowercase			:   Dict					   =		jnp.broadcast_to(
                jnp.arange(decoder_input_ids.shape[-1] - 1		)[None, :]							,						(decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)							,						)
            lowercase			:   Any					   =		model.decode(
                decoder_input_ids[:, :-1]							,						SCREAMING_SNAKE_CASE__							,						decoder_attention_mask=SCREAMING_SNAKE_CASE__							,						past_key_values=SCREAMING_SNAKE_CASE__							,						decoder_position_ids=SCREAMING_SNAKE_CASE__							,						)

            lowercase			:   List[str]					   =		jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]							,						dtype='''i4'''		)
            lowercase			:   Optional[int]					   =		model.decode(
                decoder_input_ids[:, -1:]							,						SCREAMING_SNAKE_CASE__							,						decoder_attention_mask=SCREAMING_SNAKE_CASE__							,						past_key_values=outputs_cache.past_key_values							,						decoder_position_ids=SCREAMING_SNAKE_CASE__							,						)

            lowercase			:   int					   =		model.decode(SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__		)

            lowercase			:   Optional[Any]					   =		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        __lowerCamelCase			(							self							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__		):
            lowercase			:   Any					   =		20
            lowercase			:   Optional[int]					   =		model_class_name(SCREAMING_SNAKE_CASE__		)

            lowercase			:   Any					   =		model.encode(inputs_dict['''input_ids''']		)

            lowercase   ,			lowercase			:   Tuple					   =		(
                inputs_dict['''decoder_input_ids'''],
                inputs_dict['''decoder_attention_mask'''],
            )

            lowercase			:   Union[str, Any]					   =		jnp.concatenate(
                [
                    decoder_attention_mask,
                    jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1])		),
                ]							,						axis=-1							,						)

            lowercase			:   str					   =		model.init_cache(decoder_input_ids.shape[0]							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__		)
            lowercase			:   Optional[Any]					   =		jnp.broadcast_to(
                jnp.arange(decoder_input_ids.shape[-1] - 1		)[None, :]							,						(decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)							,						)

            lowercase			:   Any					   =		model.decode(
                decoder_input_ids[:, :-1]							,						SCREAMING_SNAKE_CASE__							,						decoder_attention_mask=SCREAMING_SNAKE_CASE__							,						past_key_values=SCREAMING_SNAKE_CASE__							,						decoder_position_ids=SCREAMING_SNAKE_CASE__							,						)
            lowercase			:   int					   =		jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]							,						dtype='''i4'''		)
            lowercase			:   Union[str, Any]					   =		model.decode(
                decoder_input_ids[:, -1:]							,						SCREAMING_SNAKE_CASE__							,						past_key_values=outputs_cache.past_key_values							,						decoder_attention_mask=SCREAMING_SNAKE_CASE__							,						decoder_position_ids=SCREAMING_SNAKE_CASE__							,						)

            lowercase			:   Union[str, Any]					   =		model.decode(SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__							,						decoder_attention_mask=SCREAMING_SNAKE_CASE__		)

            lowercase			:   Any					   =		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_flax
class 				__SCREAMING_SNAKE_CASE   (			unittest.TestCase   ):
      A				:							List[str]    							=     99


      def        __lowerCamelCase			(							self		):
            lowercase			:   int					   =		np.array(
                [
                    [71, 82, 18, 33, 46, 91, 2],
                    [68, 34, 26, 58, 30, 82, 2],
                    [5, 97, 17, 39, 94, 40, 2],
                    [76, 83, 94, 25, 70, 78, 2],
                    [87, 59, 41, 35, 48, 66, 2],
                    [55, 13, 16, 58, 5, 2, 1],  # note padding
                    [64, 27, 31, 51, 12, 75, 2],
                    [52, 64, 86, 17, 83, 39, 2],
                    [48, 61, 9, 24, 71, 82, 2],
                    [26, 1, 60, 48, 22, 13, 2],
                    [21, 5, 62, 28, 14, 76, 2],
                    [45, 98, 37, 86, 59, 48, 2],
                    [70, 70, 50, 9, 28, 0, 2],
                ]							,						dtype=np.intaa							,						)

            lowercase			:   str					   =		input_ids.shape[0]
            lowercase			:   List[Any]					   =		MBartConfig(
                vocab_size=self.vocab_size							,						d_model=24							,						encoder_layers=2							,						decoder_layers=2							,						encoder_attention_heads=2							,						decoder_attention_heads=2							,						encoder_ffn_dim=32							,						decoder_ffn_dim=32							,						max_position_embeddings=48							,						eos_token_id=2							,						pad_token_id=1							,						bos_token_id=0							,						)
            return config, input_ids, batch_size


      def        __lowerCamelCase			(							self		):
            lowercase   ,			lowercase   ,			lowercase			:   Optional[int]					   =		self._get_config_and_data()
            lowercase			:   str					   =		FlaxMBartForSequenceClassification(SCREAMING_SNAKE_CASE__		)
            lowercase			:   Any					   =		model(input_ids=SCREAMING_SNAKE_CASE__							,						decoder_input_ids=SCREAMING_SNAKE_CASE__		)
            lowercase			:   Dict					   =		(batch_size, config.num_labels)
            self.assertEqual(outputs['''logits'''].shape							,						SCREAMING_SNAKE_CASE__		)


      def        __lowerCamelCase			(							self		):
            lowercase   ,			lowercase   ,			lowercase			:   int					   =		self._get_config_and_data()
            lowercase			:   Optional[Any]					   =		FlaxMBartForQuestionAnswering(SCREAMING_SNAKE_CASE__		)
            lowercase			:   Dict					   =		model(input_ids=SCREAMING_SNAKE_CASE__		)

            self.assertEqual(outputs['''start_logits'''].shape							,						input_ids.shape		)
            self.assertEqual(outputs['''end_logits'''].shape							,						input_ids.shape		)


      def        __lowerCamelCase			(							self		):
            lowercase   ,			lowercase   ,			lowercase			:   Optional[Any]					   =		self._get_config_and_data()
            lowercase			:   List[str]					   =		FlaxMBartForConditionalGeneration(SCREAMING_SNAKE_CASE__		)
            lowercase			:   str					   =		lm_model(input_ids=SCREAMING_SNAKE_CASE__		)
            lowercase			:   Union[str, Any]					   =		(batch_size, input_ids.shape[1], config.vocab_size)
            self.assertEqual(outputs['''logits'''].shape							,						SCREAMING_SNAKE_CASE__		)


      def        __lowerCamelCase			(							self		):
            lowercase			:   int					   =		MBartConfig(
                vocab_size=self.vocab_size							,						d_model=14							,						encoder_layers=2							,						decoder_layers=2							,						encoder_attention_heads=2							,						decoder_attention_heads=2							,						encoder_ffn_dim=8							,						decoder_ffn_dim=8							,						max_position_embeddings=48							,						)
            lowercase			:   Dict					   =		FlaxMBartForConditionalGeneration(SCREAMING_SNAKE_CASE__		)
            lowercase			:   List[Any]					   =		np.array([[71, 82, 18, 33, 46, 91, 2], [68, 34, 26, 58, 30, 2, 1]]							,						dtype=np.intaa		)
            lowercase			:   Dict					   =		np.array([[82, 71, 82, 18, 2], [58, 68, 2, 1, 1]]							,						dtype=np.intaa		)
            lowercase			:   Optional[Any]					   =		lm_model(input_ids=SCREAMING_SNAKE_CASE__							,						decoder_input_ids=SCREAMING_SNAKE_CASE__		)
            lowercase			:   Any					   =		(*summary.shape, config.vocab_size)
            self.assertEqual(outputs['''logits'''].shape							,						SCREAMING_SNAKE_CASE__		)






      def        __lowerCamelCase			(							self		):
            lowercase			:   str					   =		np.array([[71, 82, 18, 33, 2, 1, 1], [68, 34, 26, 58, 30, 82, 2]]							,						dtype=np.intaa		)
            lowercase			:   Union[str, Any]					   =		shift_tokens_right(SCREAMING_SNAKE_CASE__							,						1		)
            lowercase			:   List[str]					   =		np.equal(SCREAMING_SNAKE_CASE__							,						1		).astype(np.floataa		).sum()
            lowercase			:   List[str]					   =		np.equal(SCREAMING_SNAKE_CASE__							,						1		).astype(np.floataa		).sum()
            self.assertEqual(shifted.shape							,						input_ids.shape		)
            self.assertEqual(SCREAMING_SNAKE_CASE__							,						n_pad_before - 1		)
            self.assertTrue(np.equal(shifted[:, 0]							,						2		).all()		)







@require_flax
class 				__SCREAMING_SNAKE_CASE   (			A__  ,						unittest.TestCase  ,						A__   ):
      A				:							Tuple    							=     True
      A				:							Optional[Any]    							=     (
          (
              FlaxMBartModel,
              FlaxMBartForConditionalGeneration,
              FlaxMBartForSequenceClassification,
              FlaxMBartForQuestionAnswering,
          )
          if is_flax_available()
          else ()
      )
      A				:							Optional[Any]    							=     (FlaxMBartForConditionalGeneration,) if is_flax_available() else ()


      def        __lowerCamelCase			(							self		):
            lowercase			:   Optional[int]					   =		FlaxMBartModelTester(self		)


      def        __lowerCamelCase			(							self		):
            lowercase   ,			lowercase			:   Dict					   =		self.model_tester.prepare_config_and_inputs()
            for model_class in self.all_model_classes:
                  self.model_tester.check_use_cache_forward(SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__		)


      def        __lowerCamelCase			(							self		):
            lowercase   ,			lowercase			:   Dict					   =		self.model_tester.prepare_config_and_inputs()
            for model_class in self.all_model_classes:
                  self.model_tester.check_use_cache_forward_with_attn_mask(SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__		)


      def        __lowerCamelCase			(							self		):
            lowercase   ,			lowercase			:   List[str]					   =		self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                  with self.subTest(model_class.__name__		):
                        lowercase			:   str					   =		self._prepare_for_class(SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__		)
                        lowercase			:   Tuple					   =		model_class(SCREAMING_SNAKE_CASE__		)

                        @jax.jit
                        def encode_jitted(SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__=None							,						**SCREAMING_SNAKE_CASE__		):
                              return model.encode(input_ids=SCREAMING_SNAKE_CASE__							,						attention_mask=SCREAMING_SNAKE_CASE__		)

                        with self.subTest('''JIT Enabled'''		):
                              lowercase			:   Dict					   =		encode_jitted(**SCREAMING_SNAKE_CASE__		).to_tuple()

                        with self.subTest('''JIT Disabled'''		):
                              with jax.disable_jit():
                                    lowercase			:   Union[str, Any]					   =		encode_jitted(**SCREAMING_SNAKE_CASE__		).to_tuple()

                        self.assertEqual(len(SCREAMING_SNAKE_CASE__		)							,						len(SCREAMING_SNAKE_CASE__		)		)
                        for jitted_output, output in zip(SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__		):
                              self.assertEqual(jitted_output.shape							,						output.shape		)


      def        __lowerCamelCase			(							self		):
            lowercase   ,			lowercase			:   List[str]					   =		self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                  with self.subTest(model_class.__name__		):
                        lowercase			:   Optional[int]					   =		model_class(SCREAMING_SNAKE_CASE__		)
                        lowercase			:   Any					   =		model.encode(inputs_dict['''input_ids''']							,						inputs_dict['''attention_mask''']		)

                        lowercase			:   int					   =		{
                            '''decoder_input_ids''': inputs_dict['''decoder_input_ids'''],
                            '''decoder_attention_mask''': inputs_dict['''decoder_attention_mask'''],
                            '''encoder_outputs''': encoder_outputs,
                        }

                        @jax.jit
                        def decode_jitted(SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__		):
                              return model.decode(
                                  decoder_input_ids=SCREAMING_SNAKE_CASE__							,						decoder_attention_mask=SCREAMING_SNAKE_CASE__							,						encoder_outputs=SCREAMING_SNAKE_CASE__							,						)

                        with self.subTest('''JIT Enabled'''		):
                              lowercase			:   str					   =		decode_jitted(**SCREAMING_SNAKE_CASE__		).to_tuple()

                        with self.subTest('''JIT Disabled'''		):
                              with jax.disable_jit():
                                    lowercase			:   List[str]					   =		decode_jitted(**SCREAMING_SNAKE_CASE__		).to_tuple()

                        self.assertEqual(len(SCREAMING_SNAKE_CASE__		)							,						len(SCREAMING_SNAKE_CASE__		)		)
                        for jitted_output, output in zip(SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__		):
                              self.assertEqual(jitted_output.shape							,						output.shape		)






      @slow
      def        __lowerCamelCase			(							self		):
            for model_class_name in self.all_model_classes:
                  lowercase			:   Optional[int]					   =		model_class_name.from_pretrained('''facebook/mbart-large-cc25'''							,						from_pt=SCREAMING_SNAKE_CASE__		)
                  # FlaxMBartForSequenceClassification expects eos token in input_ids
                  lowercase			:   int					   =		np.ones((1, 1)		) * model.config.eos_token_id
                  lowercase			:   List[Any]					   =		model(SCREAMING_SNAKE_CASE__		)
                  self.assertIsNotNone(SCREAMING_SNAKE_CASE__		)







@require_flax
@require_sentencepiece
@require_tokenizers
class 				__SCREAMING_SNAKE_CASE   (			unittest.TestCase   ):
      A				:							str    							=     [
          ' UN Chief Says There Is No Military Solution in Syria',
      ]
      A				:							str    							=     [
          'Şeful ONU declară că nu există o soluţie militară în Siria',
      ]
      A				:							List[str]    							=     'facebook/mbart-large-en-ro'


      @cached_property
      def        __lowerCamelCase			(							self		):
            return AutoTokenizer.from_pretrained(self.model_name		)


      @cached_property
      def        __lowerCamelCase			(							self		):
            lowercase			:   Tuple					   =		FlaxMBartForConditionalGeneration.from_pretrained(self.model_name							,						from_pt=SCREAMING_SNAKE_CASE__		)
            return model


      def        __lowerCamelCase			(							self							,						**SCREAMING_SNAKE_CASE__		):
            lowercase			:   int					   =		self.translate_src_text(**SCREAMING_SNAKE_CASE__		)
            self.assertListEqual(self.expected_text							,						SCREAMING_SNAKE_CASE__		)


      def        __lowerCamelCase			(							self							,						**SCREAMING_SNAKE_CASE__		):
            lowercase			:   Optional[Any]					   =		self.tokenizer(self.src_text							,						**SCREAMING_SNAKE_CASE__							,						return_tensors='''np'''		)
            lowercase			:   Optional[int]					   =		self.model.generate(
                model_inputs.input_ids							,						attention_mask=model_inputs.attention_mask							,						decoder_start_token_id=self.tokenizer.lang_code_to_id['''ro_RO''']							,						early_stopping=SCREAMING_SNAKE_CASE__							,						num_beams=2							,						).sequences
            lowercase			:   List[str]					   =		self.tokenizer.batch_decode(SCREAMING_SNAKE_CASE__							,						skip_special_tokens=SCREAMING_SNAKE_CASE__		)
            return generated_words






      @slow
      def        __lowerCamelCase			(							self		):
            self._assert_generated_batch_equal_expected()





import numpy as np




def 			__lowercase	(						_UpperCamelCase,    _UpperCamelCase     )    ->Dict:







      """simple docstring"""

      lowercase			:   Optional[Any]					   =		np.array(_UpperCamelCase     )
      lowercase			:   Dict					   =		np.array(_UpperCamelCase     )

      lowercase			:   List[Any]					   =		abs(predict - actual     )
      lowercase			:   int					   =		difference.mean()

      return score




def 			__lowercase	(						_UpperCamelCase,    _UpperCamelCase     )    ->List[Any]:







      """simple docstring"""

      lowercase			:   Tuple					   =		np.array(_UpperCamelCase     )
      lowercase			:   str					   =		np.array(_UpperCamelCase     )

      lowercase			:   List[str]					   =		predict - actual
      lowercase			:   Tuple					   =		np.square(_UpperCamelCase     )

      lowercase			:   Union[str, Any]					   =		square_diff.mean()
      return score




def 			__lowercase	(						_UpperCamelCase,    _UpperCamelCase     )    ->str:







      """simple docstring"""

      lowercase			:   Union[str, Any]					   =		np.array(_UpperCamelCase     )
      lowercase			:   Optional[Any]					   =		np.array(_UpperCamelCase     )

      lowercase			:   Tuple					   =		predict - actual
      lowercase			:   Dict					   =		np.square(_UpperCamelCase     )
      lowercase			:   Union[str, Any]					   =		square_diff.mean()
      lowercase			:   Union[str, Any]					   =		np.sqrt(_UpperCamelCase     )
      return score




def 			__lowercase	(						_UpperCamelCase,    _UpperCamelCase     )    ->List[Any]:







      """simple docstring"""

      lowercase			:   List[str]					   =		np.array(_UpperCamelCase     )
      lowercase			:   List[Any]					   =		np.array(_UpperCamelCase     )

      lowercase			:   Dict					   =		np.log(predict + 1     )
      lowercase			:   List[str]					   =		np.log(actual + 1     )

      lowercase			:   int					   =		log_predict - log_actual
      lowercase			:   Tuple					   =		np.square(_UpperCamelCase     )
      lowercase			:   List[Any]					   =		square_diff.mean()

      lowercase			:   int					   =		np.sqrt(_UpperCamelCase     )

      return score




def 			__lowercase	(						_UpperCamelCase,    _UpperCamelCase     )    ->List[str]:







      """simple docstring"""

      lowercase			:   List[Any]					   =		np.array(_UpperCamelCase     )
      lowercase			:   Optional[int]					   =		np.array(_UpperCamelCase     )

      lowercase			:   Optional[int]					   =		predict - actual
      lowercase			:   Optional[int]					   =		np.sum(_UpperCamelCase     ) / len(_UpperCamelCase     )
      lowercase			:   Dict					   =		np.sum(_UpperCamelCase     ) / len(_UpperCamelCase     )
      # print(numerator, denumerator)
      lowercase			:   int					   =		float(_UpperCamelCase     ) / denumerator * 100

      return score




def 			__lowercase	(						_UpperCamelCase,    _UpperCamelCase     )    ->List[Any]:







      """simple docstring"""

      return np.mean(np.array(_UpperCamelCase     ) == np.array(_UpperCamelCase     )     )

