
"""simple docstring"""


import unittest

import numpy as np
import timeout_decorator  # noqa

from transformers import BlenderbotConfig, is_flax_available
from transformers.testing_utils import jax_device, require_flax, slow

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
      SCREAMING_SNAKE_CASE      =     """platform"""

      import jax
      import jax.numpy as jnp

      from transformers import BlenderbotTokenizer
      from transformers.models.blenderbot.modeling_flax_blenderbot import (
          FlaxBlenderbotForConditionalGeneration,
          FlaxBlenderbotModel,
          shift_tokens_right,
      )



def 	lowerCamelCase__			(							UpperCAmelCase_		,      UpperCAmelCase_		,      UpperCAmelCase_=None		,      UpperCAmelCase_=None		,      UpperCAmelCase_=None		,      UpperCAmelCase_=None		,      UpperCAmelCase_=None		,      UpperCAmelCase_=None		,      )->							Tuple:







       """simple docstring"""
       if attention_mask is None:
              UpperCamelCase					 =		np.where(input_ids != config.pad_token_id		,      1		,      0				)
       if decoder_attention_mask is None:
              UpperCamelCase					 =		np.where(decoder_input_ids != config.pad_token_id		,      1		,      0				)
       if head_mask is None:
              UpperCamelCase					 =		np.ones((config.encoder_layers, config.encoder_attention_heads)				)
       if decoder_head_mask is None:
              UpperCamelCase					 =		np.ones((config.decoder_layers, config.decoder_attention_heads)				)
       if cross_attn_head_mask is None:
              UpperCamelCase					 =		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": attention_mask,
       }



class   __a  :






       def __init__(  self :							Tuple       ,      UpperCAmelCase_ :							str       ,      UpperCAmelCase_ :							Union[str, Any]=13       ,      UpperCAmelCase_ :							Dict=7       ,      UpperCAmelCase_ :							Dict=True       ,      UpperCAmelCase_ :							int=False       ,      UpperCAmelCase_ :							Optional[int]=99       ,      UpperCAmelCase_ :							Dict=16       ,      UpperCAmelCase_ :							List[Any]=2       ,      UpperCAmelCase_ :							str=4       ,      UpperCAmelCase_ :							Optional[Any]=4       ,      UpperCAmelCase_ :							List[Any]="gelu"       ,      UpperCAmelCase_ :							Dict=0.1       ,      UpperCAmelCase_ :							Optional[Any]=0.1       ,      UpperCAmelCase_ :							Union[str, Any]=32       ,      UpperCAmelCase_ :							int=2       ,      UpperCAmelCase_ :							int=1       ,      UpperCAmelCase_ :							List[Any]=0       ,      UpperCAmelCase_ :							str=0.02       ,      )->  Optional[Any]:







              """simple docstring"""
              UpperCamelCase					 =		parent
              UpperCamelCase					 =		batch_size
              UpperCamelCase					 =		seq_length
              UpperCamelCase					 =		is_training
              UpperCamelCase					 =		use_labels
              UpperCamelCase					 =		vocab_size
              UpperCamelCase					 =		hidden_size
              UpperCamelCase					 =		num_hidden_layers
              UpperCamelCase					 =		num_attention_heads
              UpperCamelCase					 =		intermediate_size
              UpperCamelCase					 =		hidden_act
              UpperCamelCase					 =		hidden_dropout_prob
              UpperCamelCase					 =		attention_probs_dropout_prob
              UpperCamelCase					 =		max_position_embeddings
              UpperCamelCase					 =		eos_token_id
              UpperCamelCase					 =		pad_token_id
              UpperCamelCase					 =		bos_token_id
              UpperCamelCase					 =		initializer_range






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







              """simple docstring"""
              UpperCamelCase					 =		np.clip(ids_tensor([self.batch_size, self.seq_length - 1]       ,      self.vocab_size			)       ,      3       ,      self.vocab_size			)
              UpperCamelCase					 =		np.concatenate((input_ids, 2 * np.ones((self.batch_size, 1)       ,      dtype=np.intaa			))       ,      -1			)

              UpperCamelCase					 =		shift_tokens_right(UpperCAmelCase_       ,      1       ,      2			)

              UpperCamelCase					 =		BlenderbotConfig(
                  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       ,      initializer_range=self.initializer_range       ,      use_cache=UpperCAmelCase_       ,      )
              UpperCamelCase					 =		prepare_blenderbot_inputs_dict(UpperCAmelCase_       ,      UpperCAmelCase_       ,      UpperCAmelCase_			)
              return config, inputs_dict






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







              """simple docstring"""
              UpperCamelCase ,       UpperCamelCase					 =		self.prepare_config_and_inputs()
              return config, inputs_dict






       def 	_SCREAMING_SNAKE_CASE       (  self :							Dict       ,      UpperCAmelCase_ :							Optional[Any]       ,      UpperCAmelCase_ :							List[str]       ,      UpperCAmelCase_ :							List[str]			)->  Any:







              """simple docstring"""
              UpperCamelCase					 =		20
              UpperCamelCase					 =		model_class_name(UpperCAmelCase_			)

              UpperCamelCase					 =		model.encode(inputs_dict["input_ids"]			)

              UpperCamelCase ,       UpperCamelCase					 =		(
                  inputs_dict["decoder_input_ids"],
                  inputs_dict["decoder_attention_mask"],
              )

              UpperCamelCase					 =		model.init_cache(decoder_input_ids.shape[0]       ,      UpperCAmelCase_       ,      UpperCAmelCase_			)
              UpperCamelCase					 =		jnp.ones((decoder_input_ids.shape[0], max_decoder_length)       ,      dtype="i4"			)

              UpperCamelCase					 =		jnp.broadcast_to(
                  jnp.arange(decoder_input_ids.shape[-1] - 1			)[None, :]       ,      (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)       ,      )
              UpperCamelCase					 =		model.decode(
                  decoder_input_ids[:, :-1]       ,      UpperCAmelCase_       ,      decoder_attention_mask=UpperCAmelCase_       ,      past_key_values=UpperCAmelCase_       ,      decoder_position_ids=UpperCAmelCase_       ,      )

              UpperCamelCase					 =		jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]       ,      dtype="i4"			)
              UpperCamelCase					 =		model.decode(
                  decoder_input_ids[:, -1:]       ,      UpperCAmelCase_       ,      decoder_attention_mask=UpperCAmelCase_       ,      past_key_values=outputs_cache.past_key_values       ,      decoder_position_ids=UpperCAmelCase_       ,      )

              UpperCamelCase					 =		model.decode(UpperCAmelCase_       ,      UpperCAmelCase_			)

              UpperCamelCase					 =		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 	_SCREAMING_SNAKE_CASE       (  self :							Optional[Any]       ,      UpperCAmelCase_ :							Tuple       ,      UpperCAmelCase_ :							int       ,      UpperCAmelCase_ :							int			)->  int:







              """simple docstring"""
              UpperCamelCase					 =		20
              UpperCamelCase					 =		model_class_name(UpperCAmelCase_			)

              UpperCamelCase					 =		model.encode(inputs_dict["input_ids"]			)

              UpperCamelCase ,       UpperCamelCase					 =		(
                  inputs_dict["decoder_input_ids"],
                  inputs_dict["decoder_attention_mask"],
              )

              UpperCamelCase					 =		jnp.concatenate(
                  [
                      decoder_attention_mask,
                      jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1])			),
                  ]       ,      axis=-1       ,      )

              UpperCamelCase					 =		model.init_cache(decoder_input_ids.shape[0]       ,      UpperCAmelCase_       ,      UpperCAmelCase_			)
              UpperCamelCase					 =		jnp.broadcast_to(
                  jnp.arange(decoder_input_ids.shape[-1] - 1			)[None, :]       ,      (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)       ,      )

              UpperCamelCase					 =		model.decode(
                  decoder_input_ids[:, :-1]       ,      UpperCAmelCase_       ,      decoder_attention_mask=UpperCAmelCase_       ,      past_key_values=UpperCAmelCase_       ,      decoder_position_ids=UpperCAmelCase_       ,      )
              UpperCamelCase					 =		jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]       ,      dtype="i4"			)
              UpperCamelCase					 =		model.decode(
                  decoder_input_ids[:, -1:]       ,      UpperCAmelCase_       ,      past_key_values=outputs_cache.past_key_values       ,      decoder_attention_mask=UpperCAmelCase_       ,      decoder_position_ids=UpperCAmelCase_       ,      )

              UpperCamelCase					 =		model.decode(UpperCAmelCase_       ,      UpperCAmelCase_       ,      decoder_attention_mask=UpperCAmelCase_			)

              UpperCamelCase					 =		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   __a  (      unittest.TestCase	):
       UpperCamelCase_		:					int   =			99






       def 	_SCREAMING_SNAKE_CASE       (  self :							Tuple			)->  List[Any]:







              """simple docstring"""
              UpperCamelCase					 =		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       ,      )

              UpperCamelCase					 =		input_ids.shape[0]
              UpperCamelCase					 =		BlenderbotConfig(
                  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 	_SCREAMING_SNAKE_CASE       (  self :							Optional[int]			)->  Optional[int]:







              """simple docstring"""
              UpperCamelCase ,       UpperCamelCase ,       UpperCamelCase					 =		self._get_config_and_data()
              UpperCamelCase					 =		FlaxBlenderbotForConditionalGeneration(UpperCAmelCase_			)
              UpperCamelCase					 =		lm_model(input_ids=UpperCAmelCase_			)
              UpperCamelCase					 =		(batch_size, input_ids.shape[1], config.vocab_size)
              self.assertEqual(outputs["logits"].shape       ,      UpperCAmelCase_			)






       def 	_SCREAMING_SNAKE_CASE       (  self :							Dict			)->  Any:







              """simple docstring"""
              UpperCamelCase					 =		BlenderbotConfig(
                  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       ,      )
              UpperCamelCase					 =		FlaxBlenderbotForConditionalGeneration(UpperCAmelCase_			)
              UpperCamelCase					 =		np.array([[71, 82, 18, 33, 46, 91, 2], [68, 34, 26, 58, 30, 2, 1]]       ,      dtype=np.intaa			)
              UpperCamelCase					 =		np.array([[82, 71, 82, 18, 2], [58, 68, 2, 1, 1]]       ,      dtype=np.intaa			)
              UpperCamelCase					 =		lm_model(input_ids=UpperCAmelCase_       ,      decoder_input_ids=UpperCAmelCase_			)
              UpperCamelCase					 =		(*summary.shape, config.vocab_size)
              self.assertEqual(outputs["logits"].shape       ,      UpperCAmelCase_			)






       def 	_SCREAMING_SNAKE_CASE       (  self :							Tuple			)->  int:







              """simple docstring"""
              UpperCamelCase					 =		np.array([[71, 82, 18, 33, 2, 1, 1], [68, 34, 26, 58, 30, 82, 2]]       ,      dtype=np.intaa			)
              UpperCamelCase					 =		shift_tokens_right(UpperCAmelCase_       ,      1       ,      2			)
              UpperCamelCase					 =		np.equal(UpperCAmelCase_       ,      1			).astype(np.floataa			).sum()
              UpperCamelCase					 =		np.equal(UpperCAmelCase_       ,      1			).astype(np.floataa			).sum()
              self.assertEqual(shifted.shape       ,      input_ids.shape			)
              self.assertEqual(UpperCAmelCase_       ,      n_pad_before - 1			)
              self.assertTrue(np.equal(shifted[:, 0]       ,      2			).all()			)





@require_flax
class   __a  (      _lowerCAmelCase    ,     unittest.TestCase    ,     _lowerCAmelCase	):
       UpperCamelCase_		:					Tuple   =			True
       UpperCamelCase_		:					Dict   =			(
           (
               FlaxBlenderbotModel,
               FlaxBlenderbotForConditionalGeneration,
           )
           if is_flax_available()
           else ()
       )
       UpperCamelCase_		:					Tuple   =			(FlaxBlenderbotForConditionalGeneration,) if is_flax_available() else ()






       def 	_SCREAMING_SNAKE_CASE       (  self :							Tuple			)->  int:







              """simple docstring"""
              UpperCamelCase					 =		FlaxBlenderbotModelTester(self			)






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







              """simple docstring"""
              UpperCamelCase ,       UpperCamelCase					 =		self.model_tester.prepare_config_and_inputs()
              for model_class in self.all_model_classes:
                     self.model_tester.check_use_cache_forward(UpperCAmelCase_       ,      UpperCAmelCase_       ,      UpperCAmelCase_			)






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







              """simple docstring"""
              UpperCamelCase ,       UpperCamelCase					 =		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(UpperCAmelCase_       ,      UpperCAmelCase_       ,      UpperCAmelCase_			)






       def 	_SCREAMING_SNAKE_CASE       (  self :							int			)->  List[Any]:







              """simple docstring"""
              UpperCamelCase ,       UpperCamelCase					 =		self.model_tester.prepare_config_and_inputs_for_common()

              for model_class in self.all_model_classes:
                     with self.subTest(model_class.__name__			):
                            UpperCamelCase					 =		self._prepare_for_class(UpperCAmelCase_       ,      UpperCAmelCase_			)
                            UpperCamelCase					 =		model_class(UpperCAmelCase_			)

                            @jax.jit
                            def encode_jitted(UpperCAmelCase_ :							Optional[Any]       ,      UpperCAmelCase_ :							str=None       ,      **UpperCAmelCase_ :							List[str]			):
                                   return model.encode(input_ids=UpperCAmelCase_       ,      attention_mask=UpperCAmelCase_			)

                            with self.subTest("JIT Enabled"			):
                                   UpperCamelCase					 =		encode_jitted(**UpperCAmelCase_			).to_tuple()

                            with self.subTest("JIT Disabled"			):
                                   with jax.disable_jit():
                                          UpperCamelCase					 =		encode_jitted(**UpperCAmelCase_			).to_tuple()

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






       def 	_SCREAMING_SNAKE_CASE       (  self :							List[str]			)->  Optional[int]:







              """simple docstring"""
              UpperCamelCase ,       UpperCamelCase					 =		self.model_tester.prepare_config_and_inputs_for_common()

              for model_class in self.all_model_classes:
                     with self.subTest(model_class.__name__			):
                            UpperCamelCase					 =		model_class(UpperCAmelCase_			)
                            UpperCamelCase					 =		model.encode(inputs_dict["input_ids"]       ,      inputs_dict["attention_mask"]			)

                            UpperCamelCase					 =		{
                                "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(UpperCAmelCase_ :							List[Any]       ,      UpperCAmelCase_ :							Optional[int]       ,      UpperCAmelCase_ :							Optional[int]			):
                                   return model.decode(
                                       decoder_input_ids=UpperCAmelCase_       ,      decoder_attention_mask=UpperCAmelCase_       ,      encoder_outputs=UpperCAmelCase_       ,      )

                            with self.subTest("JIT Enabled"			):
                                   UpperCamelCase					 =		decode_jitted(**UpperCAmelCase_			).to_tuple()

                            with self.subTest("JIT Disabled"			):
                                   with jax.disable_jit():
                                          UpperCamelCase					 =		decode_jitted(**UpperCAmelCase_			).to_tuple()

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






       @slow
       def 	_SCREAMING_SNAKE_CASE       (  self :							int			)->  int:







              """simple docstring"""
              for model_class_name in self.all_model_classes:
                     UpperCamelCase					 =		model_class_name.from_pretrained("facebook/blenderbot-400M-distill"			)
                     # FlaxBlenderbotForSequenceClassification expects eos token in input_ids
                     UpperCamelCase					 =		np.ones((1, 1)			) * model.config.eos_token_id
                     UpperCamelCase					 =		model(UpperCAmelCase_			)
                     self.assertIsNotNone(UpperCAmelCase_			)






       @unittest.skipUnless(jax_device != "cpu"       ,      "3B test too slow on CPU."			)
       @slow
       def 	_SCREAMING_SNAKE_CASE       (  self :							Tuple			)->  List[str]:







              """simple docstring"""
              UpperCamelCase					 =		{"num_beams": 1, "early_stopping": True, "min_length": 15, "max_length": 25}
              UpperCamelCase					 =		{"skip_special_tokens": True, "clean_up_tokenization_spaces": True}

              UpperCamelCase					 =		FlaxBlenderbotForConditionalGeneration.from_pretrained("facebook/blenderbot-3B"       ,      from_pt=UpperCAmelCase_			)
              UpperCamelCase					 =		BlenderbotTokenizer.from_pretrained("facebook/blenderbot-3B"			)

              UpperCamelCase					 =		["Sam"]
              UpperCamelCase					 =		tokenizer(UpperCAmelCase_       ,      return_tensors="jax"			)

              UpperCamelCase					 =		model.generate(**UpperCAmelCase_       ,      **UpperCAmelCase_			)
              UpperCamelCase					 =		"Sam is a great name. It means \"sun\" in Gaelic."

              UpperCamelCase					 =		tokenizer.batch_decode(UpperCAmelCase_       ,      **UpperCAmelCase_			)
              assert generated_txt[0].strip() == tgt_text







"""simple docstring"""


import unittest

from transformers.utils.backbone_utils import (
    BackboneMixin,
    get_aligned_output_features_output_indices,
    verify_out_features_out_indices,
)



class   __a  (      unittest.TestCase	):






       def 	_SCREAMING_SNAKE_CASE       (  self :							Optional[Any]			)->  int:







              """simple docstring"""
              UpperCamelCase					 =		["a", "b", "c"]

              # Defaults to last layer if both are None
              UpperCamelCase ,       UpperCamelCase					 =		get_aligned_output_features_output_indices(UpperCAmelCase_       ,      UpperCAmelCase_       ,      UpperCAmelCase_			)
              self.assertEqual(UpperCAmelCase_       ,      ["c"]			)
              self.assertEqual(UpperCAmelCase_       ,      [2]			)

              # Out indices set to match out features
              UpperCamelCase ,       UpperCamelCase					 =		get_aligned_output_features_output_indices(["a", "c"]       ,      UpperCAmelCase_       ,      UpperCAmelCase_			)
              self.assertEqual(UpperCAmelCase_       ,      ["a", "c"]			)
              self.assertEqual(UpperCAmelCase_       ,      [0, 2]			)

              # Out features set to match out indices
              UpperCamelCase ,       UpperCamelCase					 =		get_aligned_output_features_output_indices(UpperCAmelCase_       ,      [0, 2]       ,      UpperCAmelCase_			)
              self.assertEqual(UpperCAmelCase_       ,      ["a", "c"]			)
              self.assertEqual(UpperCAmelCase_       ,      [0, 2]			)

              # Out features selected from negative indices
              UpperCamelCase ,       UpperCamelCase					 =		get_aligned_output_features_output_indices(UpperCAmelCase_       ,      [-3, -1]       ,      UpperCAmelCase_			)
              self.assertEqual(UpperCAmelCase_       ,      ["a", "c"]			)
              self.assertEqual(UpperCAmelCase_       ,      [-3, -1]			)






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







              """simple docstring"""
              # Stage names must be set
              with self.assertRaises(UpperCAmelCase_			):
                     verify_out_features_out_indices(["a", "b"]       ,      (0, 1)       ,      UpperCAmelCase_			)

              # Out features must be a list
              with self.assertRaises(UpperCAmelCase_			):
                     verify_out_features_out_indices(("a", "b")       ,      (0, 1)       ,      ["a", "b"]			)

              # Out features must be a subset of stage names
              with self.assertRaises(UpperCAmelCase_			):
                     verify_out_features_out_indices(["a", "b"]       ,      (0, 1)       ,      ["a"]			)

              # Out indices must be a list or tuple
              with self.assertRaises(UpperCAmelCase_			):
                     verify_out_features_out_indices(UpperCAmelCase_       ,      0       ,      ["a", "b"]			)

              # Out indices must be a subset of stage names
              with self.assertRaises(UpperCAmelCase_			):
                     verify_out_features_out_indices(UpperCAmelCase_       ,      (0, 1)       ,      ["a"]			)

              # Out features and out indices must be the same length
              with self.assertRaises(UpperCAmelCase_			):
                     verify_out_features_out_indices(["a", "b"]       ,      (0,)       ,      ["a", "b", "c"]			)

              # Out features should match out indices
              with self.assertRaises(UpperCAmelCase_			):
                     verify_out_features_out_indices(["a", "b"]       ,      (0, 2)       ,      ["a", "b", "c"]			)

              # Out features and out indices should be in order
              with self.assertRaises(UpperCAmelCase_			):
                     verify_out_features_out_indices(["b", "a"]       ,      (0, 1)       ,      ["a", "b"]			)

              # Check passes with valid inputs
              verify_out_features_out_indices(["a", "b", "d"]       ,      (0, 1, -1)       ,      ["a", "b", "c", "d"]			)






       def 	_SCREAMING_SNAKE_CASE       (  self :							Dict			)->  List[Any]:







              """simple docstring"""
              UpperCamelCase					 =		BackboneMixin()

              UpperCamelCase					 =		["a", "b", "c"]
              UpperCamelCase					 =		["a", "c"]
              UpperCamelCase					 =		[0, 2]

              # Check that the output features and indices are set correctly
              self.assertEqual(backbone.out_features       ,      ["a", "c"]			)
              self.assertEqual(backbone.out_indices       ,      [0, 2]			)

              # Check out features and indices are updated correctly
              UpperCamelCase					 =		["a", "b"]
              self.assertEqual(backbone.out_features       ,      ["a", "b"]			)
              self.assertEqual(backbone.out_indices       ,      [0, 1]			)

              UpperCamelCase					 =		[-3, -1]
              self.assertEqual(backbone.out_features       ,      ["a", "c"]			)
              self.assertEqual(backbone.out_indices       ,      [-3, -1]			)





