
"""simple docstring"""







import tempfile
import unittest

from transformers import TaConfig, is_torch_available
from transformers.testing_utils import (
    require_sentencepiece,
    require_tokenizers,
    require_torch,
    slow,
    torch_device,
)

from ...generation.test_utils import GenerationTesterMixin
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
       import torch

       from transformers import AutoTokenizer, UMTaForConditionalGeneration, UMTaForQuestionAnswering, UMTaModel




class 				A__ :

  def __init__(   self ,	_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE=99 ,	_SCREAMING_SNAKE_CASE=13 ,	_SCREAMING_SNAKE_CASE=7 ,	_SCREAMING_SNAKE_CASE=9 ,	_SCREAMING_SNAKE_CASE=True ,	_SCREAMING_SNAKE_CASE=True ,	_SCREAMING_SNAKE_CASE=False ,	_SCREAMING_SNAKE_CASE=32 ,	_SCREAMING_SNAKE_CASE=5 ,	_SCREAMING_SNAKE_CASE=4 ,	_SCREAMING_SNAKE_CASE=37 ,	_SCREAMING_SNAKE_CASE=8 ,	_SCREAMING_SNAKE_CASE=0.1 ,	_SCREAMING_SNAKE_CASE=0.002 ,	_SCREAMING_SNAKE_CASE=1 ,	_SCREAMING_SNAKE_CASE=0 ,	_SCREAMING_SNAKE_CASE=0 ,	_SCREAMING_SNAKE_CASE=None ,	_SCREAMING_SNAKE_CASE=None ,	):
   __lowerCAmelCase    :		Union[str, Any]		    =   parent
   __lowerCAmelCase    :		Any		    =   batch_size
   __lowerCAmelCase    :		int		    =   encoder_seq_length
   __lowerCAmelCase    :		Tuple		    =   decoder_seq_length
   # For common tests
   __lowerCAmelCase    :		List[Any]		    =   self.decoder_seq_length
   __lowerCAmelCase    :		Tuple		    =   is_training
   __lowerCAmelCase    :		Optional[int]		    =   use_attention_mask
   __lowerCAmelCase    :		Dict		    =   use_labels
   __lowerCAmelCase    :		int		    =   vocab_size
   __lowerCAmelCase    :		str		    =   hidden_size
   __lowerCAmelCase    :		Optional[int]		    =   num_hidden_layers
   __lowerCAmelCase    :		Tuple		    =   num_attention_heads
   __lowerCAmelCase    :		Optional[Any]		    =   d_ff
   __lowerCAmelCase    :		Optional[int]		    =   relative_attention_num_buckets
   __lowerCAmelCase    :		List[Any]		    =   dropout_rate
   __lowerCAmelCase    :		Dict		    =   initializer_factor
   __lowerCAmelCase    :		Dict		    =   eos_token_id
   __lowerCAmelCase    :		Dict		    =   pad_token_id
   __lowerCAmelCase    :		Dict		    =   decoder_start_token_id
   __lowerCAmelCase    :		List[Any]		    =   None
   __lowerCAmelCase    :		Any		    =   decoder_layers

  def 							__lowerCamelCase							(   self				):
   return TaConfig.from_pretrained('google/umt5-base'				)

  def 							__lowerCamelCase							(   self ,	_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE=None ,	_SCREAMING_SNAKE_CASE=None ,	_SCREAMING_SNAKE_CASE=None ,	_SCREAMING_SNAKE_CASE=None ,	_SCREAMING_SNAKE_CASE=None ,	):
   if attention_mask is None:
    __lowerCAmelCase    :		Any		    =   input_ids.ne(config.pad_token_id				)
   if decoder_attention_mask is None:
    __lowerCAmelCase    :		Any		    =   decoder_input_ids.ne(config.pad_token_id				)
   if head_mask is None:
    __lowerCAmelCase    :		List[str]		    =   torch.ones(config.num_hidden_layers ,	config.num_attention_heads ,	device=_SCREAMING_SNAKE_CASE				)
   if decoder_head_mask is None:
    __lowerCAmelCase    :		List[str]		    =   torch.ones(config.num_decoder_layers ,	config.num_attention_heads ,	device=_SCREAMING_SNAKE_CASE				)
   if cross_attn_head_mask is None:
    __lowerCAmelCase    :		Any		    =   torch.ones(
        config.num_decoder_layers ,	config.num_attention_heads ,	device=_SCREAMING_SNAKE_CASE				)
   return {
       "input_ids": input_ids,
       "decoder_input_ids": decoder_input_ids,
       "attention_mask": attention_mask,
       "decoder_attention_mask": decoder_attention_mask,
       "head_mask": head_mask,
       "decoder_head_mask": decoder_head_mask,
       "cross_attn_head_mask": cross_attn_head_mask,
   }

  def 							__lowerCamelCase							(   self				):
   __lowerCAmelCase    :		List[Any]		    =   ids_tensor([self.batch_size, self.encoder_seq_length] ,	self.vocab_size				)
   __lowerCAmelCase    :		List[str]		    =   ids_tensor([self.batch_size, self.decoder_seq_length] ,	self.vocab_size				)

   # we need to clamp the input ids here to avoid having pad token in between
   # this is because for NllbMoe the position_ids are prepared such that
   # all pad tokens have pos id = 2 and rest are between 2..seq_length
   # and the seq_length here is seq_length - num_pad_tokens
   # but when using past, there is no way of knowing if the past input ids had
   # pad tokens in them, which results in incorrect seq_lenth and which in turn results in
   # position_ids being off by num_pad_tokens in past input
   __lowerCAmelCase    :		int		    =   input_ids.clamp(self.pad_token_id + 1				)
   __lowerCAmelCase    :		Optional[int]		    =   decoder_input_ids.clamp(self.pad_token_id + 1				)

   __lowerCAmelCase    :		Dict		    =   self.get_config()
   __lowerCAmelCase    :		List[Any]		    =   config.num_attention_heads
   __lowerCAmelCase    :		Dict		    =   self.prepare_inputs_dict(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)
   return config, input_dict

  def 							__lowerCamelCase							(   self				):
   __lowerCAmelCase    :		List[Any]		    =   self.prepare_config_and_inputs()
   return config, inputs_dict

  def 							__lowerCamelCase							(   self				):
   return TaConfig(
       vocab_size=1_66 ,	d_model=self.hidden_size ,	d_ff=self.d_ff ,	d_kv=self.hidden_size // self.num_attention_heads ,	num_layers=self.num_hidden_layers ,	num_decoder_layers=self.decoder_layers ,	num_heads=self.num_attention_heads ,	relative_attention_num_buckets=self.relative_attention_num_buckets ,	dropout_rate=self.dropout_rate ,	initializer_factor=self.initializer_factor ,	eos_token_id=self.eos_token_id ,	bos_token_id=self.pad_token_id ,	pad_token_id=self.pad_token_id ,	decoder_start_token_id=self.decoder_start_token_id ,	)

  def 							__lowerCamelCase							(   self				):
   return TaConfig(
       vocab_size=self.vocab_size ,	d_model=self.hidden_size ,	d_ff=self.d_ff ,	d_kv=self.hidden_size // self.num_attention_heads ,	num_layers=self.num_hidden_layers ,	num_decoder_layers=self.decoder_layers ,	num_heads=self.num_attention_heads ,	relative_attention_num_buckets=self.relative_attention_num_buckets ,	dropout_rate=self.dropout_rate ,	initializer_factor=self.initializer_factor ,	eos_token_id=self.eos_token_id ,	bos_token_id=self.pad_token_id ,	pad_token_id=self.pad_token_id ,	decoder_start_token_id=self.decoder_start_token_id ,	)

  def 							__lowerCamelCase							(   self ,	_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE ,	):
   __lowerCAmelCase    :		str		    =   UMTaModel(config=_SCREAMING_SNAKE_CASE				)
   model.to(_SCREAMING_SNAKE_CASE				)
   model.eval()
   __lowerCAmelCase    :		Optional[int]		    =   model(
       input_ids=_SCREAMING_SNAKE_CASE ,	decoder_input_ids=_SCREAMING_SNAKE_CASE ,	attention_mask=_SCREAMING_SNAKE_CASE ,	decoder_attention_mask=_SCREAMING_SNAKE_CASE ,	)
   __lowerCAmelCase    :		Tuple		    =   model(input_ids=_SCREAMING_SNAKE_CASE ,	decoder_input_ids=_SCREAMING_SNAKE_CASE				)
   __lowerCAmelCase    :		List[str]		    =   result.last_hidden_state
   __lowerCAmelCase    :		Optional[int]		    =   result.past_key_values
   __lowerCAmelCase    :		List[str]		    =   result.encoder_last_hidden_state

   self.parent.assertEqual(encoder_output.size() ,	(self.batch_size, self.encoder_seq_length, self.hidden_size)				)
   self.parent.assertEqual(decoder_output.size() ,	(self.batch_size, self.decoder_seq_length, self.hidden_size)				)
   # There should be `num_layers` key value embeddings stored in decoder_past
   self.parent.assertEqual(len(_SCREAMING_SNAKE_CASE				) ,	config.num_layers				)
   # There should be a self attn key, a self attn value, a cross attn key and a cross attn value stored in each decoder_past tuple
   self.parent.assertEqual(len(decoder_past[0]				) ,	4				)

  def 							__lowerCamelCase							(   self ,	_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE ,	):
   __lowerCAmelCase    :		Optional[int]		    =   UMTaModel(config=_SCREAMING_SNAKE_CASE				).get_decoder().to(_SCREAMING_SNAKE_CASE				).eval()
   # first forward pass
   __lowerCAmelCase    :		Any		    =   model(_SCREAMING_SNAKE_CASE ,	use_cache=_SCREAMING_SNAKE_CASE				)
   __lowerCAmelCase    :		int		    =   model(_SCREAMING_SNAKE_CASE				)
   __lowerCAmelCase    :		Optional[int]		    =   model(_SCREAMING_SNAKE_CASE ,	use_cache=_SCREAMING_SNAKE_CASE				)

   self.parent.assertTrue(len(_SCREAMING_SNAKE_CASE				) == len(_SCREAMING_SNAKE_CASE				)				)
   self.parent.assertTrue(len(_SCREAMING_SNAKE_CASE				) == len(_SCREAMING_SNAKE_CASE				) + 1				)

   __lowerCAmelCase    :		Union[str, Any]		    =   outputs.to_tuple()

   # create hypothetical next token and extent to next_input_ids
   __lowerCAmelCase    :		Tuple		    =   ids_tensor((self.batch_size, 1) ,	config.vocab_size				)

   # append to next input_ids and
   __lowerCAmelCase    :		str		    =   torch.cat([input_ids, next_tokens] ,	dim=-1				)

   __lowerCAmelCase    :		List[str]		    =   model(_SCREAMING_SNAKE_CASE				)['last_hidden_state']
   __lowerCAmelCase    :		Any		    =   model(_SCREAMING_SNAKE_CASE ,	past_key_values=_SCREAMING_SNAKE_CASE				)['last_hidden_state']

   # select random slice
   __lowerCAmelCase    :		Any		    =   ids_tensor((1,) ,	output_from_past.shape[-1]				).item()
   __lowerCAmelCase    :		str		    =   output_from_no_past[:, -1, random_slice_idx].detach()
   __lowerCAmelCase    :		int		    =   output_from_past[:, 0, random_slice_idx].detach()

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







  def 							__lowerCamelCase							(   self ,	_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE ,	):
   __lowerCAmelCase    :		List[Any]		    =   UMTaModel(config=_SCREAMING_SNAKE_CASE				).to(_SCREAMING_SNAKE_CASE				).half().eval()
   __lowerCAmelCase    :		List[str]		    =   model(**_SCREAMING_SNAKE_CASE				)['last_hidden_state']
   self.parent.assertFalse(torch.isnan(_SCREAMING_SNAKE_CASE				).any().item()				)




@require_torch
class 				A__ (			_lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase ,  unittest.TestCase):
  A_		: Optional[int]            =			(
      (UMTaModel, UMTaForConditionalGeneration, UMTaForQuestionAnswering) if is_torch_available() else ()
  )
  A_		: List[str]            =			(UMTaForConditionalGeneration,) if is_torch_available() else ()
  A_		: List[str]            =			(
      {
          'conversational': UMTaForConditionalGeneration,
          'feature-extraction': UMTaModel,
          'summarization': UMTaForConditionalGeneration,
          'text2text-generation': UMTaForConditionalGeneration,
          'translation': UMTaForConditionalGeneration,
          'question-answering': UMTaForQuestionAnswering,
      }
      if is_torch_available()
      else {}
  )
  A_		: int            =			True
  A_		: Optional[Any]            =			False
  A_		: int            =			False
  A_		: str            =			True
  A_		: Any            =			True
  # The small UMT5 model needs higher percentages for CPU/MP tests
  A_		: Dict            =			[0.8, 0.9]

  def 							__lowerCamelCase							(   self				):
   __lowerCAmelCase    :		Tuple		    =   UMTaModelTester(self				)

  @unittest.skip('Test has a segmentation fault on torch 1.8.0'				)
  def 							__lowerCamelCase							(   self				):
   __lowerCAmelCase    :		Any		    =   self.model_tester.prepare_config_and_inputs()
   __lowerCAmelCase    :		int		    =   UMTaModel(config_and_inputs[0]				).to(_SCREAMING_SNAKE_CASE				)
   with tempfile.TemporaryDirectory() as tmpdirname:
    torch.onnx.export(
        _SCREAMING_SNAKE_CASE ,	(config_and_inputs[1], config_and_inputs[3], config_and_inputs[2]) ,	f"{tmpdirname}/t5_test.onnx" ,	export_params=_SCREAMING_SNAKE_CASE ,	opset_version=9 ,	input_names=['input_ids', 'decoder_input_ids'] ,	)

  @unittest.skipIf(torch_device == 'cpu' ,	'Cant do half precision'				)
  def 							__lowerCamelCase							(   self				):
   __lowerCAmelCase    :		Optional[int]		    =   self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_model_fpaa_forward(*_SCREAMING_SNAKE_CASE				)

  def 							__lowerCamelCase							(   self				):
   __lowerCAmelCase    :		Optional[Any]		    =   ['encoder_attentions', 'decoder_attentions', 'cross_attentions']
   __lowerCAmelCase    :		Dict		    =   self.model_tester.prepare_config_and_inputs()
   __lowerCAmelCase    :		Tuple		    =   config_and_inputs[0]
   __lowerCAmelCase    :		Tuple		    =   UMTaForConditionalGeneration(_SCREAMING_SNAKE_CASE				).eval()
   model.to(_SCREAMING_SNAKE_CASE				)

   __lowerCAmelCase    :		str		    =   {
       'head_mask': torch.zeros(config.num_layers ,	config.num_heads ,	device=_SCREAMING_SNAKE_CASE				),
       'decoder_head_mask': torch.zeros(config.num_decoder_layers ,	config.num_heads ,	device=_SCREAMING_SNAKE_CASE				),
       'cross_attn_head_mask': torch.zeros(config.num_decoder_layers ,	config.num_heads ,	device=_SCREAMING_SNAKE_CASE				),
   }

   for attn_name, (name, mask) in zip(_SCREAMING_SNAKE_CASE ,	head_masking.items()				):
    __lowerCAmelCase    :		List[str]		    =   {name: mask}
    # Explicitly pass decoder_head_mask as it is required from T5 model when head_mask specified
    if name == "head_mask":
     __lowerCAmelCase    :		str		    =   torch.ones(
         config.num_decoder_layers ,	config.num_heads ,	device=_SCREAMING_SNAKE_CASE				)

    __lowerCAmelCase    :		Optional[Any]		    =   model.generate(
        config_and_inputs[1]['input_ids'] ,	num_beams=1 ,	max_length=3 ,	output_attentions=_SCREAMING_SNAKE_CASE ,	return_dict_in_generate=_SCREAMING_SNAKE_CASE ,	**_SCREAMING_SNAKE_CASE ,	)
    # We check the state of decoder_attentions and cross_attentions just from the last step
    __lowerCAmelCase    :		Union[str, Any]		    =   out[attn_name] if attn_name == attention_names[0] else out[attn_name][-1]
    self.assertEqual(sum([w.sum().item() for w in attn_weights]				) ,	0.0				)







  @unittest.skip('Does not work on the tiny model as we keep hitting edge cases.'				)
  def 							__lowerCamelCase							(   self				):
   pass




@require_torch
@require_sentencepiece
@require_tokenizers
class 				A__ (			unittest.TestCase):

  @slow
  @unittest.skip(
      'Unless we stop stripping left and right by default for all special tokens, the expected ids obtained here will not match the original ones. Wait for https://github.com/huggingface/transformers/pull/23909 to be merged'				)
  def 							__lowerCamelCase							(   self				):
   __lowerCAmelCase    :		List[str]		    =   UMTaForConditionalGeneration.from_pretrained('google/umt5-small' ,	return_dict=_SCREAMING_SNAKE_CASE				).to(_SCREAMING_SNAKE_CASE				)
   __lowerCAmelCase    :		Any		    =   AutoTokenizer.from_pretrained('google/umt5-small' ,	use_fast=_SCREAMING_SNAKE_CASE ,	legacy=_SCREAMING_SNAKE_CASE				)
   __lowerCAmelCase    :		Union[str, Any]		    =   [
       'Bonjour monsieur <extra_id_0> bien <extra_id_1>.',
       'No se como puedo <extra_id_0>.',
       'This is the reason why we <extra_id_0> them.',
       'The <extra_id_0> walks in <extra_id_1>, seats',
       'A <extra_id_0> walks into a bar and orders a <extra_id_1> with <extra_id_2> pinch of <extra_id_3>.',
   ]
   __lowerCAmelCase    :		Union[str, Any]		    =   tokenizer(_SCREAMING_SNAKE_CASE ,	return_tensors='pt' ,	padding=_SCREAMING_SNAKE_CASE				).input_ids
   # fmt: off
   __lowerCAmelCase    :		Optional[Any]		    =   torch.tensor(
       [
           [ 3_85_30, 21_07_03, 25_62_99, 14_10, 25_62_98, 2_74, 1, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0],
           [   8_26, 3_21, 6_71, 2_59_22, 25_62_99, 2_74, 1, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0],
           [  14_60, 3_39, 3_12, 1_90_14, 1_06_20, 7_58, 25_62_99, 23_55,2_74, 1, 0, 0, 0, 0, 0, 0,0, 0],
           [   5_17, 25_62_99, 1_48_69, 2_81, 3_01, 25_62_98, 2_75, 11_99_83,1, 0, 0, 0, 0, 0, 0, 0,0, 0],
           [   3_20, 25_62_99, 1_48_69, 2_81, 22_34, 2_89, 22_75, 3_33,6_13_91, 2_89, 25_62_98, 5_43, 25_62_97, 16_87_14, 3_29, 25_62_96,2_74, 1],
       ]				)
   # fmt: on
   torch.testing.assert_allclose(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)

   __lowerCAmelCase    :		int		    =   model.generate(input_ids.to(_SCREAMING_SNAKE_CASE				)				)
   __lowerCAmelCase    :		Optional[Any]		    =   [
       '<pad><extra_id_0> et<extra_id_1> [eod] <extra_id_2><extra_id_55>.. [eod] 💐 💐 💐 💐 💐 💐 💐 💐 💐 💐 💐 <extra_id_56>ajšietosto<extra_id_56>lleux<extra_id_19><extra_id_6>ajšie</s>',
       '<pad><extra_id_0>.<extra_id_1>.,<0x0A>...spech <0x0A><extra_id_20> <extra_id_21></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>',
       '<pad><extra_id_0> are not going to be a part of the world. We are not going to be a part of<extra_id_1> and<extra_id_2><0x0A><extra_id_48>.<extra_id_48></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>',
       '<pad><extra_id_0> door<extra_id_1>, the door<extra_id_2> 피해[/</s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>',
       '<pad><extra_id_0>nyone who<extra_id_1> drink<extra_id_2> a<extra_id_3> alcohol<extra_id_4> A<extra_id_5> A. This<extra_id_6> I<extra_id_7><extra_id_52><extra_id_53></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>',
   ]
   __lowerCAmelCase    :		Tuple		    =   tokenizer.batch_decode(_SCREAMING_SNAKE_CASE				)
   self.assertEqual(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)

"""simple docstring"""







# Imports
import numpy as np




class 				A__ :

		def __init__(   self ,	_SCREAMING_SNAKE_CASE=None ,	_SCREAMING_SNAKE_CASE=None ,	_SCREAMING_SNAKE_CASE=None ,	_SCREAMING_SNAKE_CASE=None ,	_SCREAMING_SNAKE_CASE=None				):
			self.set_matricies(red=_SCREAMING_SNAKE_CASE ,	green=_SCREAMING_SNAKE_CASE ,	blue=_SCREAMING_SNAKE_CASE ,	red_edge=_SCREAMING_SNAKE_CASE ,	nir=_SCREAMING_SNAKE_CASE				)

		def 							__lowerCamelCase							(   self ,	_SCREAMING_SNAKE_CASE=None ,	_SCREAMING_SNAKE_CASE=None ,	_SCREAMING_SNAKE_CASE=None ,	_SCREAMING_SNAKE_CASE=None ,	_SCREAMING_SNAKE_CASE=None				):
			if red is not None:
				__lowerCAmelCase    :		Optional[int]		    =   red
			if green is not None:
				__lowerCAmelCase    :		Any		    =   green
			if blue is not None:
				__lowerCAmelCase    :		str		    =   blue
			if red_edge is not None:
				__lowerCAmelCase    :		Dict		    =   red_edge
			if nir is not None:
				__lowerCAmelCase    :		Dict		    =   nir
			return True

		def 							__lowerCamelCase							(   self ,	_SCREAMING_SNAKE_CASE="" ,	_SCREAMING_SNAKE_CASE=None ,	_SCREAMING_SNAKE_CASE=None ,	_SCREAMING_SNAKE_CASE=None ,	_SCREAMING_SNAKE_CASE=None ,	_SCREAMING_SNAKE_CASE=None				):
			self.set_matricies(red=_SCREAMING_SNAKE_CASE ,	green=_SCREAMING_SNAKE_CASE ,	blue=_SCREAMING_SNAKE_CASE ,	red_edge=_SCREAMING_SNAKE_CASE ,	nir=_SCREAMING_SNAKE_CASE				)
			__lowerCAmelCase    :		Optional[int]		    =   {
			    'ARVI2': self.arvaa,
			    'CCCI': self.ccci,
			    'CVI': self.cvi,
			    'GLI': self.gli,
			    'NDVI': self.ndvi,
			    'BNDVI': self.bndvi,
			    'redEdgeNDVI': self.red_edge_ndvi,
			    'GNDVI': self.gndvi,
			    'GBNDVI': self.gbndvi,
			    'GRNDVI': self.grndvi,
			    'RBNDVI': self.rbndvi,
			    'PNDVI': self.pndvi,
			    'ATSAVI': self.atsavi,
			    'BWDRVI': self.bwdrvi,
			    'CIgreen': self.ci_green,
			    'CIrededge': self.ci_rededge,
			    'CI': self.ci,
			    'CTVI': self.ctvi,
			    'GDVI': self.gdvi,
			    'EVI': self.evi,
			    'GEMI': self.gemi,
			    'GOSAVI': self.gosavi,
			    'GSAVI': self.gsavi,
			    'Hue': self.hue,
			    'IVI': self.ivi,
			    'IPVI': self.ipvi,
			    'I': self.i,
			    'RVI': self.rvi,
			    'MRVI': self.mrvi,
			    'MSAVI': self.m_savi,
			    'NormG': self.norm_g,
			    'NormNIR': self.norm_nir,
			    'NormR': self.norm_r,
			    'NGRDI': self.ngrdi,
			    'RI': self.ri,
			    'S': self.s,
			    'IF': self._if,
			    'DVI': self.dvi,
			    'TVI': self.tvi,
			    'NDRE': self.ndre,
			}

			try:
				return funcs[index]()
			except KeyError:
				print('Index not in the list!'				)
				return False

		def 							__lowerCamelCase							(   self				):
			return -0.18 + (1.17 * ((self.nir - self.red) / (self.nir + self.red)))

		def 							__lowerCamelCase							(   self				):
			return ((self.nir - self.redEdge) / (self.nir + self.redEdge)) / (
			    (self.nir - self.red) / (self.nir + self.red)
			)

		def 							__lowerCamelCase							(   self				):
			return self.nir * (self.red / (self.green**2))

		def 							__lowerCamelCase							(   self				):
			return (2 * self.green - self.red - self.blue) / (
			    2 * self.green + self.red + self.blue
			)

		def 							__lowerCamelCase							(   self				):
			return (self.nir - self.red) / (self.nir + self.red)

		def 							__lowerCamelCase							(   self				):
			return (self.nir - self.blue) / (self.nir + self.blue)

		def 							__lowerCamelCase							(   self				):
			return (self.redEdge - self.red) / (self.redEdge + self.red)

		def 							__lowerCamelCase							(   self				):
			return (self.nir - self.green) / (self.nir + self.green)

		def 							__lowerCamelCase							(   self				):
			return (self.nir - (self.green + self.blue)) / (
			    self.nir + (self.green + self.blue)
			)

		def 							__lowerCamelCase							(   self				):
			return (self.nir - (self.green + self.red)) / (
			    self.nir + (self.green + self.red)
			)

		def 							__lowerCamelCase							(   self				):
			return (self.nir - (self.blue + self.red)) / (self.nir + (self.blue + self.red))

		def 							__lowerCamelCase							(   self				):
			return (self.nir - (self.green + self.red + self.blue)) / (
			    self.nir + (self.green + self.red + self.blue)
			)

		def 							__lowerCamelCase							(   self ,	_SCREAMING_SNAKE_CASE=0.08 ,	_SCREAMING_SNAKE_CASE=1.22 ,	_SCREAMING_SNAKE_CASE=0.03				):
			return a * (
			    (self.nir - a * self.red - b)
			    / (a * self.nir + self.red - a * b + x * (1 + a**2))
			)

		def 							__lowerCamelCase							(   self				):
			return (0.1 * self.nir - self.blue) / (0.1 * self.nir + self.blue)

		def 							__lowerCamelCase							(   self				):
			return (self.nir / self.green) - 1

		def 							__lowerCamelCase							(   self				):
			return (self.nir / self.redEdge) - 1

		def 							__lowerCamelCase							(   self				):
			return (self.red - self.blue) / self.red

		def 							__lowerCamelCase							(   self				):
			__lowerCAmelCase    :		Dict		    =   self.ndvi()
			return ((ndvi + 0.5) / (abs(ndvi + 0.5				))) * (abs(ndvi + 0.5				) ** (1 / 2))

		def 							__lowerCamelCase							(   self				):
			return self.nir - self.green

		def 							__lowerCamelCase							(   self				):
			return 2.5 * (
			    (self.nir - self.red) / (self.nir + 6 * self.red - 7.5 * self.blue + 1)
			)

		def 							__lowerCamelCase							(   self				):
			__lowerCAmelCase    :		Optional[Any]		    =   (2 * (self.nir**2 - self.red**2) + 1.5 * self.nir + 0.5 * self.red) / (
			    self.nir + self.red + 0.5
			)
			return n * (1 - 0.25 * n) - (self.red - 0.125) / (1 - self.red)

		def 							__lowerCamelCase							(   self ,	_SCREAMING_SNAKE_CASE=0.16				):
			return (self.nir - self.green) / (self.nir + self.green + y)

		def 							__lowerCamelCase							(   self ,	_SCREAMING_SNAKE_CASE=0.5				):
			return ((self.nir - self.green) / (self.nir + self.green + n)) * (1 + n)

		def 							__lowerCamelCase							(   self				):
			return np.arctan(
			    ((2 * self.red - self.green - self.blue) / 30.5) * (self.green - self.blue)				)

		def 							__lowerCamelCase							(   self ,	_SCREAMING_SNAKE_CASE=None ,	_SCREAMING_SNAKE_CASE=None				):
			return (self.nir - b) / (a * self.red)

		def 							__lowerCamelCase							(   self				):
			return (self.nir / ((self.nir + self.red) / 2)) * (self.ndvi() + 1)

		def 							__lowerCamelCase							(   self				):
			return (self.red + self.green + self.blue) / 30.5

		def 							__lowerCamelCase							(   self				):
			return self.nir / self.red

		def 							__lowerCamelCase							(   self				):
			return (self.rvi() - 1) / (self.rvi() + 1)

		def 							__lowerCamelCase							(   self				):
			return (
			    (2 * self.nir + 1)
			    - ((2 * self.nir + 1) ** 2 - 8 * (self.nir - self.red)) ** (1 / 2)
			) / 2

		def 							__lowerCamelCase							(   self				):
			return self.green / (self.nir + self.red + self.green)

		def 							__lowerCamelCase							(   self				):
			return self.nir / (self.nir + self.red + self.green)

		def 							__lowerCamelCase							(   self				):
			return self.red / (self.nir + self.red + self.green)

		def 							__lowerCamelCase							(   self				):
			return (self.green - self.red) / (self.green + self.red)

		def 							__lowerCamelCase							(   self				):
			return (self.red - self.green) / (self.red + self.green)

		def 							__lowerCamelCase							(   self				):
			__lowerCAmelCase    :		List[Any]		    =   np.max([np.max(self.red				), np.max(self.green				), np.max(self.blue				)]				)
			__lowerCAmelCase    :		Dict		    =   np.min([np.min(self.red				), np.min(self.green				), np.min(self.blue				)]				)
			return (max_value - min_value) / max_value

		def 							__lowerCamelCase							(   self				):
			return (2 * self.red - self.green - self.blue) / (self.green - self.blue)

		def 							__lowerCamelCase							(   self				):
			return self.nir / self.red

		def 							__lowerCamelCase							(   self				):
			return (self.ndvi() + 0.5) ** (1 / 2)







		def 							__lowerCamelCase							(   self				):
			return (self.nir - self.redEdge) / (self.nir + self.redEdge)