


import argparse
import collections

import jax
import jax.numpy as jnp
import torch
import torch.nn as nn
from clip.model import CLIP
from flax.training import checkpoints
from huggingface_hub import Repository

from transformers import (
    CLIPTokenizer,
    OwlViTConfig,
    OwlViTForObjectDetection,
    OwlViTImageProcessor,
    OwlViTModel,
    OwlViTProcessor,
)


UpperCAmelCase     =       {
    'vit_b32': {
        'embed_dim': 512,
        'image_resolution': 768,
        'context_length': 16,
        'vocab_size': 4_9408,
        'vision_layers': 12,
        'vision_width': 768,
        'vision_patch_size': 32,
        'transformer_width': 512,
        'transformer_heads': 8,
        'transformer_layers': 12,
    },
    'vit_b16': {
        'embed_dim': 512,
        'image_resolution': 768,
        'context_length': 16,
        'vocab_size': 4_9408,
        'vision_layers': 12,
        'vision_width': 768,
        'vision_patch_size': 16,
        'transformer_width': 512,
        'transformer_heads': 8,
        'transformer_layers': 12,
    },
    'vit_l14': {
        'embed_dim': 768,
        'image_resolution': 840,
        'context_length': 16,
        'vocab_size': 4_9408,
        'vision_layers': 24,
        'vision_width': 1024,
        'vision_patch_size': 14,
        'transformer_width': 768,
        'transformer_heads': 12,
        'transformer_layers': 12,
    },
}






def 			__lowerCAmelCase       (SCREAMING_SNAKE_CASE   ,   SCREAMING_SNAKE_CASE=""   ,   SCREAMING_SNAKE_CASE="/"   )->    List[str]:




      """simple docstring"""

      snake_case_			= []

      for k, v in params.items():
            snake_case_			= parent_key + sep + k if parent_key else k

            if isinstance(lowercase_   ,   collections.MutableMapping   ):
                  items.extend(flatten_nested_dict(lowercase_   ,   lowercase_   ,   sep=lowercase_   ).items()   )
            else:
                  items.append((new_key, v)   )
      return dict(lowercase_   )






def 			__lowerCAmelCase       (SCREAMING_SNAKE_CASE   )->    Union[str, Any]:




      """simple docstring"""

      return jax.tree_util.tree_map(lambda SCREAMING_SNAKE_CASE   : x.astype(jnp.floataa   ) if x.dtype == jnp.bfloataa else x   ,   lowercase_   )






def 			__lowerCAmelCase       (SCREAMING_SNAKE_CASE   ,   SCREAMING_SNAKE_CASE   )->    Union[str, Any]:




      """simple docstring"""

      snake_case_			,       snake_case_			,       snake_case_			= pt_attn_layer.in_proj_weight.chunk(3   ,   dim=0   )
      snake_case_			,       snake_case_			,       snake_case_			= pt_attn_layer.in_proj_bias.chunk(3   ,   dim=0   )

      snake_case_			= pt_attn_layer.out_proj.weight
      snake_case_			= pt_attn_layer.out_proj.bias

      snake_case_			= q_proj
      snake_case_			= q_proj_bias

      snake_case_			= k_proj
      snake_case_			= k_proj_bias

      snake_case_			= v_proj
      snake_case_			= v_proj_bias

      snake_case_			= out_proj_weights
      snake_case_			= out_proj_bias






def 			__lowerCAmelCase       (SCREAMING_SNAKE_CASE   ,   SCREAMING_SNAKE_CASE   )->    List[Any]:




      """simple docstring"""

      copy_linear(hf_mlp.fca   ,   pt_mlp.c_fc   )
      copy_linear(hf_mlp.fca   ,   pt_mlp.c_proj   )






def 			__lowerCAmelCase       (SCREAMING_SNAKE_CASE   ,   SCREAMING_SNAKE_CASE   )->    Tuple:




      """simple docstring"""

      snake_case_			= pt_linear.weight
      snake_case_			= pt_linear.bias






def 			__lowerCAmelCase       (SCREAMING_SNAKE_CASE   ,   SCREAMING_SNAKE_CASE   )->    str:




      """simple docstring"""

      copy_linear(hf_layer.layer_norma   ,   pt_layer.ln_a   )
      copy_linear(hf_layer.layer_norma   ,   pt_layer.ln_a   )

      # copy MLP
      copy_mlp(hf_layer.mlp   ,   pt_layer.mlp   )

      # copy attn
      copy_attn_layer(hf_layer.self_attn   ,   pt_layer.attn   )






def 			__lowerCAmelCase       (SCREAMING_SNAKE_CASE   ,   SCREAMING_SNAKE_CASE   )->    Dict:




      """simple docstring"""

      for hf_layer, pt_layer in zip(lowercase_   ,   lowercase_   ):
            copy_layer(lowercase_   ,   lowercase_   )






def 			__lowerCAmelCase       (SCREAMING_SNAKE_CASE   ,   SCREAMING_SNAKE_CASE   )->    List[Any]:




      """simple docstring"""

      snake_case_			= pt_model.token_embedding.weight
      snake_case_			= pt_model.positional_embedding

      # copy layer norm
      copy_linear(hf_encoder.final_layer_norm   ,   pt_model.ln_final   )

      # copy hidden layers
      copy_layers(hf_encoder.encoder.layers   ,   pt_model.transformer.resblocks   )






def 			__lowerCAmelCase       (SCREAMING_SNAKE_CASE   ,   SCREAMING_SNAKE_CASE   )->    List[Any]:




      """simple docstring"""

      snake_case_			= pt_model.text_projection.data.T

      # copy text encoder
      copy_encoder(hf_model.text_model   ,   lowercase_   )






def 			__lowerCAmelCase       (SCREAMING_SNAKE_CASE   ,   SCREAMING_SNAKE_CASE   )->    Union[str, Any]:




      """simple docstring"""

      snake_case_			= pt_model.visual.proj.data.T

      # copy layer norms
      copy_linear(hf_model.vision_model.pre_layernorm   ,   pt_model.visual.ln_pre   )
      copy_linear(hf_model.vision_model.post_layernorm   ,   pt_model.visual.ln_post   )

      # copy embeds
      snake_case_			= pt_model.visual.conva.weight.data
      snake_case_			= pt_model.visual.class_embedding
      snake_case_			= pt_model.visual.positional_embedding.data

      # copy encoder
      copy_layers(hf_model.vision_model.encoder.layers   ,   pt_model.visual.transformer.resblocks   )






def 			__lowerCAmelCase       (SCREAMING_SNAKE_CASE   ,   SCREAMING_SNAKE_CASE   )->    int:




      """simple docstring"""

      snake_case_			= flatten_nested_dict(flax_params['''backbone''']['''merged_class_token''']   )

      snake_case_			= torch.from_numpy(flax_class_token_params['''scale''']   )
      snake_case_			= torch.from_numpy(flax_class_token_params['''bias''']   )
      snake_case_			= nn.Parameter(lowercase_   )
      snake_case_			= nn.Parameter(lowercase_   )






def 			__lowerCAmelCase       (SCREAMING_SNAKE_CASE   ,   SCREAMING_SNAKE_CASE   )->    int:




      """simple docstring"""

      snake_case_			= hf_model.state_dict()
      snake_case_			= {}

      # Rename class prediction head flax params to pytorch HF
      snake_case_			= flatten_nested_dict(flax_params['''class_head''']   )

      for flax_key, v in flax_class_params.items():
            snake_case_			= flax_key.replace('''/'''   ,   '''.'''   )
            snake_case_			= torch_key.replace('''.kernel'''   ,   '''.weight'''   )
            snake_case_			= torch_key.replace('''Dense_0'''   ,   '''dense0'''   )
            snake_case_			= '''class_head.''' + torch_key

            if "weight" in torch_key and v.ndim == 2:
                  snake_case_			= v.T

            snake_case_			= nn.Parameter(torch.from_numpy(lowercase_   )   )

      # Rename box prediction box flax params to pytorch HF
      snake_case_			= flatten_nested_dict(flax_params['''obj_box_head''']   )

      for flax_key, v in flax_box_params.items():
            snake_case_			= flax_key.replace('''/'''   ,   '''.'''   )
            snake_case_			= torch_key.replace('''.kernel'''   ,   '''.weight'''   )
            snake_case_			= torch_key.replace('''_'''   ,   ''''''   ).lower()
            snake_case_			= '''box_head.''' + torch_key

            if "weight" in torch_key and v.ndim == 2:
                  snake_case_			= v.T

            snake_case_			= nn.Parameter(torch.from_numpy(lowercase_   )   )

      # Copy flax params to PyTorch params
      for name, param in new_params.items():
            if name in pt_params.keys():
                  pt_params[name].copy_(lowercase_   )






def 			__lowerCAmelCase       (SCREAMING_SNAKE_CASE   ,   SCREAMING_SNAKE_CASE   )->    Optional[int]:




      """simple docstring"""

      for k, v in flax_attn_params.items():
            if k.startswith('''transformer'''   ):
                  snake_case_			= k.replace('''transformer.resblocks'''   ,   '''text_model.encoder.layers'''   )
            else:
                  snake_case_			= k.replace('''visual.transformer.resblocks'''   ,   '''vision_model.encoder.layers'''   )

            snake_case_			= torch_key.replace('''attn'''   ,   '''self_attn'''   )
            snake_case_			= torch_key.replace('''key'''   ,   '''k_proj'''   )
            snake_case_			= torch_key.replace('''value'''   ,   '''v_proj'''   )
            snake_case_			= torch_key.replace('''query'''   ,   '''q_proj'''   )
            snake_case_			= torch_key.replace('''out'''   ,   '''out_proj'''   )

            if "bias" in torch_key and v.ndim == 2:
                  snake_case_			= v.shape[0] * v.shape[1]
                  snake_case_			= v.reshape(lowercase_   )

            if "weight" in torch_key and "out" in torch_key:
                  snake_case_			= (v.shape[0] * v.shape[1], v.shape[2])
                  snake_case_			= v.reshape(lowercase_   ).T

            if "weight" in torch_key and "out" not in torch_key:
                  snake_case_			= (v.shape[0], v.shape[1] * v.shape[2])
                  snake_case_			= v.reshape(lowercase_   ).T

            # Copy flax CLIP attn params to HF PyTorch params
            snake_case_			= torch.from_numpy(lowercase_   )
            hf_backbone.state_dict()[torch_key].copy_(lowercase_   )






def 			__lowerCAmelCase       (SCREAMING_SNAKE_CASE   )->    List[Any]:




      """simple docstring"""

      snake_case_			= {}
      snake_case_			= []

      for k, v in params.items():
            if "attn." in k:
                  snake_case_			= k[: k.rindex('''attn.'''   ) + 5]
                  if base in processed_attn_layers:
                        continue

                  processed_attn_layers.append(lowercase_   )
                  snake_case_			= params[base + '''out.weight'''].shape[-1]
                  snake_case_			= params[base + '''out.weight'''].reshape(lowercase_   ,   lowercase_   ).T
                  snake_case_			= params[base + '''out.bias''']
            else:
                  snake_case_			= v
      return new_params






def 			__lowerCAmelCase       (SCREAMING_SNAKE_CASE   ,   SCREAMING_SNAKE_CASE   )->    List[str]:




      """simple docstring"""

      snake_case_			= CLIP(**lowercase_   )
      torch_model.eval()
      snake_case_			= torch_model.state_dict()

      snake_case_			= flatten_nested_dict(flax_params['''backbone''']['''clip''']   )
      snake_case_			= {}

      for flax_key, v in flax_clip_params.items():
            snake_case_			= flax_key.replace('''/'''   ,   '''.'''   )
            snake_case_			= torch_key.replace('''text.token_embedding.embedding'''   ,   '''token_embedding.kernel'''   )

            if (
                torch_key.startswith('''text.transformer'''   )
                or torch_key.startswith('''text.text_projection'''   )
                or torch_key.startswith('''text.ln_final'''   )
                or torch_key.startswith('''text.positional_embedding'''   )
            ):
                  snake_case_			= torch_key[5:]

            snake_case_			= torch_key.replace('''text_projection.kernel'''   ,   '''text_projection'''   )
            snake_case_			= torch_key.replace('''visual.proj.kernel'''   ,   '''visual.proj'''   )
            snake_case_			= torch_key.replace('''.scale'''   ,   '''.weight'''   )
            snake_case_			= torch_key.replace('''.kernel'''   ,   '''.weight'''   )

            if "conv" in torch_key or "downsample.0.weight" in torch_key:
                  snake_case_			= v.transpose(3   ,   2   ,   0   ,   1   )

            elif "weight" in torch_key and v.ndim == 2 and "embedding" not in torch_key:
                  # Fully connected layers are transposed, embeddings are not
                  snake_case_			= v.T

            snake_case_			= v

      snake_case_			= _convert_attn_layers(lowercase_   )
      new_torch_params.update(lowercase_   )
      snake_case_			= {}

      # Copy flax CLIP backbone params to PyTorch params
      for name, param in new_torch_params.items():
            if name in torch_clip_params.keys():
                  snake_case_			= torch.from_numpy(new_torch_params[name]   )
                  torch_clip_params[name].copy_(lowercase_   )
            else:
                  snake_case_			= param

      return torch_clip_params, torch_model, attn_params






@torch.no_grad()
def 			__lowerCAmelCase       (SCREAMING_SNAKE_CASE   ,   SCREAMING_SNAKE_CASE   ,   SCREAMING_SNAKE_CASE   ,   SCREAMING_SNAKE_CASE   ,   SCREAMING_SNAKE_CASE=None   )->    Dict:




      """simple docstring"""

      snake_case_			= Repository(lowercase_   ,   clone_from=f'''google/{pytorch_dump_folder_path}'''   )
      repo.git_pull()

      if config_path is not None:
            snake_case_			= OwlViTConfig.from_pretrained(lowercase_   )
      else:
            snake_case_			= OwlViTConfig()

      snake_case_			= OwlViTModel(lowercase_   ).eval()
      snake_case_			= OwlViTForObjectDetection(lowercase_   ).eval()

      copy_text_model_and_projection(lowercase_   ,   lowercase_   )
      copy_vision_model_and_projection(lowercase_   ,   lowercase_   )
      snake_case_			= pt_backbone.logit_scale
      copy_flax_attn_params(lowercase_   ,   lowercase_   )

      snake_case_			= hf_backbone
      copy_class_merge_token(lowercase_   ,   lowercase_   )
      copy_class_box_heads(lowercase_   ,   lowercase_   )

      # Save HF model
      hf_model.save_pretrained(repo.local_dir   )

      # Initialize image processor
      snake_case_			= OwlViTImageProcessor(
          size=config.vision_config.image_size   ,   crop_size=config.vision_config.image_size   )
      # Initialize tokenizer
      snake_case_			= CLIPTokenizer.from_pretrained('''openai/clip-vit-base-patch32'''   ,   pad_token='''!'''   ,   model_max_length=16   )

      # Initialize processor
      snake_case_			= OwlViTProcessor(image_processor=lowercase_   ,   tokenizer=lowercase_   )
      image_processor.save_pretrained(repo.local_dir   )
      processor.save_pretrained(repo.local_dir   )

      repo.git_add()
      repo.git_commit('''Upload model and processor'''   )
      repo.git_push()


if __name__ == "__main__":
   UpperCAmelCase     =       argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       """--owlvit_version""",
       default=None,
       type=str,
       required=True,
       help="""OWL-ViT model name [clip_b16, clip_b32, clip_l14].""",
   )
   parser.add_argument(
       """--owlvit_checkpoint""", default=None, type=str, required=True, help="""Path to flax model checkpoint."""
   )
   parser.add_argument("""--hf_config""", default=None, type=str, required=True, help="""Path to HF model config.""")
   parser.add_argument(
       """--pytorch_dump_folder_path""", default="""hf_model""", type=str, help="""Path to the output PyTorch model."""
   )
   UpperCAmelCase     =       parser.parse_args()

   # Initialize PyToch clip model
   UpperCAmelCase     =       args.owlvit_version
   if model_name == "clip_b16":
      UpperCAmelCase     =       CONFIGS['vit_b16']
   elif model_name == "clip_b32":
      UpperCAmelCase     =       CONFIGS['vit_b32']
   elif model_name == "clip_l14":
      UpperCAmelCase     =       CONFIGS['vit_l14']

   # Load from checkpoint and convert params to float-32
   UpperCAmelCase     =       checkpoints.restore_checkpoint(args.owlvit_checkpoint, target=None)['optimizer']['target']
   UpperCAmelCase     =       jax.tree_util.tree_map(lambda x: x.astype(jnp.floataa) if x.dtype == jnp.bfloataa else x, variables)
   del variables

   # Convert CLIP backbone
   UpperCAmelCase     =       convert_clip_backbone(flax_params, torch_config)

   convert_owlvit_checkpoint(clip_pt, flax_params, attn_params, args.pytorch_dump_folder_path, args.hf_config)





'''simple docstring'''







import enum
import inspect
from typing import Iterable, List, Optional, Tuple, Union





class 	lowerCamelCase_				(			enum.Enum				):




					'''simple docstring'''






					lowercase__       =					"""timm"""
					lowercase__       =					"""transformers"""






def 						_lowercase						(      lowercase_		,				lowercase_		,				lowercase_    ):



		'''simple docstring'''







		if stage_names is None:
				raise ValueError("Stage_names must be set for transformers backbones"    )

		if out_features is not None:
				if not isinstance(lowercase_		,				(list,)    ):
						raise ValueError(f'''out_features must be a list {type(lowercase_    )}'''    )
				if any(feat not in stage_names for feat in out_features    ):
						raise ValueError(f'''out_features must be a subset of stage_names: {stage_names} got {out_features}'''    )

		if out_indices is not None:
				if not isinstance(lowercase_		,				(list, tuple)    ):
						raise ValueError(f'''out_indices must be a list or tuple, got {type(lowercase_    )}'''    )
				if any(idx >= len(lowercase_    ) for idx in out_indices    ):
						raise ValueError("out_indices must be valid indices for stage_names {stage_names}, got {out_indices}"    )

		if out_features is not None and out_indices is not None:
				if len(lowercase_    ) != len(lowercase_    ):
						raise ValueError("out_features and out_indices should have the same length if both are set"    )
				if out_features != [stage_names[idx] for idx in out_indices]:
						raise ValueError("out_features and out_indices should correspond to the same stages if both are set"    )






def 						_lowercase						(      lowercase_		,				lowercase_		,				lowercase_		,				):



		'''simple docstring'''







		if out_indices is None and out_features is None:
				_snake_case      			=			[len(lowercase_    ) - 1]
				_snake_case      			=			[stage_names[-1]]
		elif out_indices is None and out_features is not None:
				_snake_case      			=			[stage_names.index(lowercase_    ) for layer in out_features]
		elif out_features is None and out_indices is not None:
				_snake_case      			=			[stage_names[idx] for idx in out_indices]
		return out_features, out_indices






def 						_lowercase						(      lowercase_		,				lowercase_		,				lowercase_		,				):



		'''simple docstring'''







		verify_out_features_out_indices(out_features=lowercase_		,				out_indices=lowercase_		,				stage_names=lowercase_    )
		_snake_case			,       _snake_case      			=			_align_output_features_output_indices(
		    out_features=lowercase_		,				out_indices=lowercase_		,				stage_names=lowercase_    )
		# Verify that the aligned out_features and out_indices are valid
		verify_out_features_out_indices(out_features=lowercase_		,				out_indices=lowercase_		,				stage_names=lowercase_    )
		return output_features, output_indices





class 	lowerCamelCase_				:




					'''simple docstring'''






					lowercase__       =					None






					def 							__SCREAMING_SNAKE_CASE      (       self,    __UpperCamelCase					):
							if getattr(self,    "_backbone",    __UpperCamelCase					) is None:
									raise ValueError("self._backbone must be set before calling _init_timm_backbone"					)

							# These will diagree with the defaults for the transformers models e.g. for resnet50
							# the transformer model has out_features = ['stem', 'stage1', 'stage2', 'stage3', 'stage4']
							# the timm model has out_features = ['act', 'layer1', 'layer2', 'layer3', 'layer4']
							_snake_case      			=			[stage["module"] for stage in self._backbone.feature_info.info]
							_snake_case      			=			[stage["num_chs"] for stage in self._backbone.feature_info.info]
							_snake_case      			=			self._backbone.feature_info.out_indices
							_snake_case      			=			self._backbone.feature_info.module_name()

							# We verify the out indices and out features are valid
							verify_out_features_out_indices(
							    out_features=__UpperCamelCase,    out_indices=__UpperCamelCase,    stage_names=self.stage_names					)
							_snake_case			,       _snake_case      			=			out_features, out_indices






					def 							__SCREAMING_SNAKE_CASE      (       self,    __UpperCamelCase					):
							_snake_case      			=			getattr(__UpperCamelCase,    "stage_names"					)
							_snake_case      			=			getattr(__UpperCamelCase,    "out_features",    __UpperCamelCase					)
							_snake_case      			=			getattr(__UpperCamelCase,    "out_indices",    __UpperCamelCase					)

							_snake_case      			=			stage_names
							_snake_case			,       _snake_case      			=			get_aligned_output_features_output_indices(
							    out_features=__UpperCamelCase,    out_indices=__UpperCamelCase,    stage_names=__UpperCamelCase					)
							# Number of channels for each stage. This is set in the transformer backbone model init
							_snake_case      			=			None






					def 							__SCREAMING_SNAKE_CASE      (       self,    __UpperCamelCase					):
							_snake_case      			=			config

							_snake_case      			=			getattr(__UpperCamelCase,    "use_timm_backbone",    __UpperCamelCase					)
							_snake_case      			=			BackboneType.TIMM if self.use_timm_backbone else BackboneType.TRANSFORMERS

							if self.backbone_type == BackboneType.TIMM:
									self._init_timm_backbone(__UpperCamelCase					)
							elif self.backbone_type == BackboneType.TRANSFORMERS:
									self._init_transformers_backbone(__UpperCamelCase					)
							else:
									raise ValueError(f'''backbone_type {self.backbone_type} not supported.'''					)






					@property
					def 							__SCREAMING_SNAKE_CASE      (       self					):
							return self._out_features






					@out_features.setter
					def 							__SCREAMING_SNAKE_CASE      (       self,    __UpperCamelCase					):
							_snake_case			,       _snake_case      			=			get_aligned_output_features_output_indices(
							    out_features=__UpperCamelCase,    out_indices=__UpperCamelCase,    stage_names=self.stage_names					)






					@property
					def 							__SCREAMING_SNAKE_CASE      (       self					):
							return self._out_indices






					@out_indices.setter
					def 							__SCREAMING_SNAKE_CASE      (       self,    __UpperCamelCase					):
							_snake_case			,       _snake_case      			=			get_aligned_output_features_output_indices(
							    out_features=__UpperCamelCase,    out_indices=__UpperCamelCase,    stage_names=self.stage_names					)






					@property
					def 							__SCREAMING_SNAKE_CASE      (       self					):
							# the current backbones will output the number of channels for each stage
							# even if that stage is not in the out_features list.
							return {stage: self.num_features[i] for i, stage in enumerate(self.stage_names					)}






					@property
					def 							__SCREAMING_SNAKE_CASE      (       self					):
							return [self.out_feature_channels[name] for name in self.out_features]






					def 							__SCREAMING_SNAKE_CASE      (       self,    *__UpperCamelCase,    **__UpperCamelCase					):
							_snake_case      			=			dict(inspect.signature(self.forward					).parameters					)
							_snake_case      			=			{k: v for k, v in kwargs.items() if k in signature}
							return self(*__UpperCamelCase,    **__UpperCamelCase					)






					def 							__SCREAMING_SNAKE_CASE      (       self,    __UpperCamelCase,    __UpperCamelCase = None,    __UpperCamelCase = None,    __UpperCamelCase = None,    ):
							raise NotImplementedError("This method should be implemented by the derived class."					)






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							_snake_case      			=			super().to_dict()
							_snake_case      			=			output.pop("_out_features"					)
							_snake_case      			=			output.pop("_out_indices"					)
							return output





class 	lowerCamelCase_				:




					'''simple docstring'''






					@property
					def 							__SCREAMING_SNAKE_CASE      (       self					):
							return self._out_features






					@out_features.setter
					def 							__SCREAMING_SNAKE_CASE      (       self,    __UpperCamelCase					):
							_snake_case			,       _snake_case      			=			get_aligned_output_features_output_indices(
							    out_features=__UpperCamelCase,    out_indices=__UpperCamelCase,    stage_names=self.stage_names					)






					@property
					def 							__SCREAMING_SNAKE_CASE      (       self					):
							return self._out_indices






					@out_indices.setter
					def 							__SCREAMING_SNAKE_CASE      (       self,    __UpperCamelCase					):
							_snake_case			,       _snake_case      			=			get_aligned_output_features_output_indices(
							    out_features=__UpperCamelCase,    out_indices=__UpperCamelCase,    stage_names=self.stage_names					)






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							_snake_case      			=			super().to_dict()
							_snake_case      			=			output.pop("_out_features"					)
							_snake_case      			=			output.pop("_out_indices"					)
							return output





