






"""simple docstring"""





import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCamelCase					=     logging.get_logger(__name__)

UpperCamelCase					=     {
    """facebook/sam-vit-huge""": """https://huggingface.co/facebook/sam-vit-huge/resolve/main/config.json""",
    """facebook/sam-vit-large""": """https://huggingface.co/facebook/sam-vit-large/resolve/main/config.json""",
    """facebook/sam-vit-base""": """https://huggingface.co/facebook/sam-vit-base/resolve/main/config.json""",
}







class 						_a  (		lowercase_       ):





   '''simple docstring'''






   def __init__(       self					, UpperCAmelCase_=256					, UpperCAmelCase_=1_024					, UpperCAmelCase_=16					, UpperCAmelCase_=16					, UpperCAmelCase_=4					, UpperCAmelCase_="gelu"					, UpperCAmelCase_=1E-6					, **UpperCAmelCase_					, )			->   Any:




          '''simple docstring'''




          super().__init__(**UpperCAmelCase_)
          lowercase__:							Dict         =     hidden_size
          lowercase__:							List[Any]         =     image_size
          lowercase__:							int         =     patch_size
          lowercase__:							Optional[Any]         =     image_size // patch_size
          lowercase__:							str         =     mask_input_channels
          lowercase__:							Any         =     num_point_embeddings
          lowercase__:							Optional[Any]         =     hidden_act
          lowercase__:							List[str]         =     layer_norm_eps







class 						_a  (		lowercase_       ):





   '''simple docstring'''






   def __init__(       self					, UpperCAmelCase_=256					, UpperCAmelCase_="relu"					, UpperCAmelCase_=2_048					, UpperCAmelCase_=2					, UpperCAmelCase_=8					, UpperCAmelCase_=2					, UpperCAmelCase_=3					, UpperCAmelCase_=3					, UpperCAmelCase_=256					, UpperCAmelCase_=1E-6					, **UpperCAmelCase_					, )			->   Optional[Any]:




          '''simple docstring'''




          super().__init__(**UpperCAmelCase_)
          lowercase__:							Dict         =     hidden_size
          lowercase__:							Dict         =     hidden_act
          lowercase__:							List[str]         =     mlp_dim
          lowercase__:							List[str]         =     num_hidden_layers
          lowercase__:							List[str]         =     num_attention_heads
          lowercase__:							int         =     attention_downsample_rate
          lowercase__:							Optional[int]         =     num_multimask_outputs
          lowercase__:							str         =     iou_head_depth
          lowercase__:							List[Any]         =     iou_head_hidden_dim
          lowercase__:							List[str]         =     layer_norm_eps







class 						_a  (		lowercase_       ):





   '''simple docstring'''






   def __init__(       self					, UpperCAmelCase_=768					, UpperCAmelCase_=256					, UpperCAmelCase_=12					, UpperCAmelCase_=12					, UpperCAmelCase_=3					, UpperCAmelCase_=1_024					, UpperCAmelCase_=16					, UpperCAmelCase_="gelu"					, UpperCAmelCase_=1E-0_6					, UpperCAmelCase_=0.0					, UpperCAmelCase_=1E-1_0					, UpperCAmelCase_=True					, UpperCAmelCase_=4.0					, UpperCAmelCase_=True					, UpperCAmelCase_=True					, UpperCAmelCase_=14					, UpperCAmelCase_=[2, 5, 8, 11]					, UpperCAmelCase_=128					, UpperCAmelCase_=None					, **UpperCAmelCase_					, )			->   Any:




          '''simple docstring'''




          super().__init__(**UpperCAmelCase_)

          lowercase__:							Tuple         =     hidden_size
          lowercase__:							Union[str, Any]         =     output_channels
          lowercase__:							List[str]         =     num_hidden_layers
          lowercase__:							Any         =     num_attention_heads
          lowercase__:							Optional[int]         =     num_channels
          lowercase__:							List[Any]         =     image_size
          lowercase__:							Dict         =     patch_size
          lowercase__:							Tuple         =     hidden_act
          lowercase__:							Union[str, Any]         =     layer_norm_eps
          lowercase__:							Dict         =     attention_dropout
          lowercase__:							List[str]         =     initializer_range
          lowercase__:							List[str]         =     qkv_bias
          lowercase__:							Tuple         =     mlp_ratio
          lowercase__:							Optional[int]         =     use_abs_pos
          lowercase__:							Dict         =     use_rel_pos
          lowercase__:							List[str]         =     window_size
          lowercase__:							Optional[int]         =     global_attn_indexes
          lowercase__:							List[Any]         =     num_pos_feats
          lowercase__:							List[Any]         =     int(hidden_size * mlp_ratio) if mlp_dim is None else mlp_dim







class 						_a  (		lowercase_       ):





   '''simple docstring'''






   UpperCamelCase__     	=							"""sam"""
   UpperCamelCase__     	=							True





   def __init__(       self					, UpperCAmelCase_=None					, UpperCAmelCase_=None					, UpperCAmelCase_=None					, UpperCAmelCase_=0.02					, **UpperCAmelCase_					, )			->   Optional[int]:




          '''simple docstring'''




          super().__init__(**UpperCAmelCase_)
          lowercase__:							Tuple         =     vision_config if vision_config is not None else {}
          lowercase__:							Optional[int]         =     prompt_encoder_config if prompt_encoder_config is not None else {}
          lowercase__:							Dict         =     mask_decoder_config if mask_decoder_config is not None else {}

          if isinstance(UpperCAmelCase_					, UpperCAmelCase_):
                 lowercase__:							str         =     vision_config.to_dict()
          if isinstance(UpperCAmelCase_					, UpperCAmelCase_):
                 lowercase__:							List[str]         =     prompt_encoder_config.to_dict()
          if isinstance(UpperCAmelCase_					, UpperCAmelCase_):
                 lowercase__:							List[str]         =     mask_decoder_config.to_dict()

          lowercase__:							int         =     SamVisionConfig(**UpperCAmelCase_)
          lowercase__:							Optional[int]         =     SamPromptEncoderConfig(**UpperCAmelCase_)
          lowercase__:							Optional[Any]         =     SamMaskDecoderConfig(**UpperCAmelCase_)
          lowercase__:							Optional[int]         =     initializer_range





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




          '''simple docstring'''




          lowercase__:							List[Any]         =     copy.deepcopy(self.__dict__)
          lowercase__:							Any         =     self.vision_config.to_dict()
          lowercase__:							int         =     self.prompt_encoder_config.to_dict()
          lowercase__:							List[Any]         =     self.mask_decoder_config.to_dict()
          lowercase__:							Any         =     self.__class__.model_type
          return output












"""simple docstring"""



import numpy as np
import qiskit







def     _SCREAMING_SNAKE_CASE  (				lowercase_     ,					lowercase_		)		->						qiskit.QuantumCircuit:
 A__			=							qiskit.QuantumCircuit(num_qubits + 1		)

 # First, let's deal with the case in which oracle is balanced
 if case == "balanced":
  # First generate a random number that tells us which CNOTs to
  # wrap in X-gates:
  A__			=							np.random.randint(1     ,					2**num_qubits		)
  # Next, format 'b' as a binary string of length 'n', padded with zeros:
  A__			=							format(lowercase_     ,					f"""0{num_qubits}b"""		)
  # Next, we place the first X-gates. Each digit in our binary string
  # corresponds to a qubit, if the digit is 0, we do nothing, if it's 1
  # we apply an X-gate to that qubit:
  for index, bit in enumerate(lowercase_		):
   if bit == "1":
    oracle_qc.x(lowercase_		)
        # Do the controlled-NOT gates for each qubit, using the output qubit
        # as the target:
  for index in range(lowercase_		):
   oracle_qc.cx(lowercase_     ,					lowercase_		)
  # Next, place the final X-gates
  for index, bit in enumerate(lowercase_		):
   if bit == "1":
    oracle_qc.x(lowercase_		)

    # Case in which oracle is constant
 if case == "constant":
  # First decide what the fixed output of the oracle will be
  # (either always 0 or always 1)
  A__			=							np.random.randint(2		)
  if output == 1:
   oracle_qc.x(lowercase_		)

 A__			=							oracle_qc.to_gate()
 A__			=							"Oracle"  # To show when we display the circuit
 return oracle_gate







def     _SCREAMING_SNAKE_CASE  (				lowercase_     ,					lowercase_		)		->						qiskit.QuantumCircuit:
 A__			=							qiskit.QuantumCircuit(num_qubits + 1     ,					lowercase_		)
 # Set up the output qubit:
 dj_circuit.x(lowercase_		)
 dj_circuit.h(lowercase_		)
 # And set up the input register:
 for qubit in range(lowercase_		):
  dj_circuit.h(lowercase_		)
 # Let's append the oracle gate to our circuit:
 dj_circuit.append(lowercase_     ,					range(num_qubits + 1		)		)
 # Finally, perform the H-gates again and measure:
 for qubit in range(lowercase_		):
  dj_circuit.h(lowercase_		)

 for i in range(lowercase_		):
  dj_circuit.measure(lowercase_     ,					lowercase_		)

 return dj_circuit







def     _SCREAMING_SNAKE_CASE  (				lowercase_     ,					lowercase_		)		->						qiskit.result.counts.Counts:
 A__			=							qiskit.Aer.get_backend("aer_simulator"		)

 A__			=							dj_oracle(lowercase_     ,					lowercase_		)
 A__			=							dj_algorithm(lowercase_     ,					lowercase_		)

 # Execute the circuit on the simulator
 A__			=							qiskit.execute(lowercase_     ,					lowercase_     ,					shots=10_00		)

 # Return the histogram data of the results of the experiment.
 return job.result().get_counts(lowercase_		)


if __name__ == "__main__":
      print(f'Deutsch Jozsa - Constant Oracle: {deutsch_jozsa("constant", 3)}')
      print(f'Deutsch Jozsa - Balanced Oracle: {deutsch_jozsa("balanced", 3)}')





