



'''simple docstring'''





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


__a          =		logging.get_logger(__name__)

__a          =		{
    "bigcode/gpt_bigcode-santacoder": "https://huggingface.co/bigcode/gpt_bigcode-santacoder/resolve/main/config.json",
}







class     UpperCAmelCase_       (       _a	):
    """simple docstring"""







    lowercase					=		"gpt_bigcode"
    lowercase					=		["past_key_values"]
    lowercase					=		{
        "hidden_size": "n_embd",
        "max_position_embeddings": "n_positions",
        "num_attention_heads": "n_head",
        "num_hidden_layers": "n_layer",
    }




    def __init__(    self					:     List[str] ,     snake_case_					:     str=50_257 ,     snake_case_					:     Tuple=1_024 ,     snake_case_					:     Union[str, Any]=768 ,     snake_case_					:     List[Any]=12 ,     snake_case_					:     Optional[int]=12 ,     snake_case_					:     Dict=None ,     snake_case_					:     Optional[Any]="gelu_pytorch_tanh" ,     snake_case_					:     Dict=0.1 ,     snake_case_					:     int=0.1 ,     snake_case_					:     Optional[Any]=0.1 ,     snake_case_					:     Dict=1E-5 ,     snake_case_					:     Optional[int]=0.02 ,     snake_case_					:     Dict=True ,     snake_case_					:     List[str]=True ,     snake_case_					:     Optional[Any]=50_256 ,     snake_case_					:     Any=50_256 ,     snake_case_					:     List[str]=True ,     snake_case_					:     Optional[Any]=True ,     snake_case_					:     Any=True ,     **snake_case_					:     int ,     ):
          snake_case__  :    Optional[Any]    						=      vocab_size
          snake_case__  :    Tuple    						=      n_positions
          snake_case__  :    Any    						=      n_embd
          snake_case__  :    List[str]    						=      n_layer
          snake_case__  :    Union[str, Any]    						=      n_head
          snake_case__  :    Optional[int]    						=      n_inner
          snake_case__  :    Any    						=      activation_function
          snake_case__  :    List[Any]    						=      resid_pdrop
          snake_case__  :    Tuple    						=      embd_pdrop
          snake_case__  :    Tuple    						=      attn_pdrop
          snake_case__  :    Optional[int]    						=      layer_norm_epsilon
          snake_case__  :    Dict    						=      initializer_range
          snake_case__  :    Dict    						=      scale_attn_weights
          snake_case__  :    Optional[Any]    						=      use_cache
          snake_case__  :    str    						=      attention_softmax_in_fpaa
          snake_case__  :    List[Any]    						=      scale_attention_softmax_in_fpaa
          snake_case__  :    Tuple    						=      multi_query

          snake_case__  :    Optional[int]    						=      bos_token_id
          snake_case__  :    int    						=      eos_token_id

          super().__init__(bos_token_id=snake_case_ ,     eos_token_id=snake_case_ ,     **snake_case_						)







"""simple docstring"""
import qiskit



def      __lowerCamelCase   (							a_     :		int ,   a_     :		int							)			->      qiskit.result.counts.Counts:
      __SCREAMING_SNAKE_CASE   :Tuple						=  qiskit.Aer.get_backend('''aer_simulator'''							)

      # Create a Quantum Circuit acting on the q register
      __SCREAMING_SNAKE_CASE   :Union[str, Any]						=  qiskit.QuantumCircuit(a_ ,   a_							)

      # Apply X (NOT) Gate to Qubits 0 & 1
      circuit.x(0							)
      circuit.x(1							)

      # Map the quantum measurement to the classical bits
      circuit.measure([0, 1] ,   [0, 1]							)

      # Execute the circuit on the qasm simulator
      __SCREAMING_SNAKE_CASE   :Tuple						=  qiskit.execute(a_ ,   a_ ,   shots=10_00							)

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


if __name__ == "__main__":
  lowerCamelCase_								=		single_qubit_measure(2, 2)
  print(f'Total count for various states are: {counts}')