class_docstr: Layers of randomly chosen single qubit rotations and 2-qubit entangling gates, acting
  on randomly chosen qubits.
  
  .. warning::
      This template uses random number generation inside qnodes. Find more
      details about how to invoke the desired random behaviour in the "Usage Details" section below.
  
  The argument ``weights`` contains the weights for each layer. The number of layers :math:`L` is therefore derived
  from the first dimension of ``weights``.
  
  The two-qubit gates of type ``imprimitive`` and the rotations are distributed randomly in the circuit.
  The number of random rotations is derived from the second dimension of ``weights``. The number of
  two-qubit gates is determined by ``ratio_imprim``. For example, a ratio of ``0.3`` with ``30`` rotations
  will lead to the use of ``10`` two-qubit gates.
  
  .. note::
      If applied to one qubit only, this template will use no imprimitive gates.
  
  This is an example of two 4-qubit random layers with four Pauli-Y/Pauli-Z rotations :math:`R_y, R_z`,
  controlled-Z gates as imprimitives, as well as ``ratio_imprim=0.3``:
  
  .. figure:: ../../_static/layer_rnd.png
      :align: center
      :width: 60%
      :target: javascript:void(0);
  
  Args:
      weights (tensor_like): weight tensor of shape ``(L, k)``,
      wires (Iterable): wires that the template acts on
      ratio_imprim (float): value between 0 and 1 that determines the ratio of imprimitive to rotation gates
      imprimitive (pennylane.ops.Operation): two-qubit gate to use, defaults to :class:`~pennylane.ops.CNOT`
      rotations (tuple[pennylane.ops.Operation]): List of Pauli-X, Pauli-Y and/or Pauli-Z gates. The frequency
          determines how often a particular rotation type is used. Defaults to the use of all three
          rotations with equal frequency.
      seed (int): seed to generate random architecture, defaults to 42
  
  .. details::
      :title: Usage Details
  
      **Default seed**
  
      ``RandomLayers`` always uses a seed to initialize the construction of a random circuit. This means
      that the template creates the same circuit every time it is called. If no seed is provided, the default
      seed of ``42`` is used.
  
      .. code-block:: python
  
          import pennylane as qml
          from pennylane import numpy as np
  
          dev = qml.device("default.qubit", wires=2)
          weights = np.array([[0.1, -2.1, 1.4]])
  
          @qml.qnode(dev)
          def circuit1(weights):
              qml.RandomLayers(weights=weights, wires=range(2))
              return qml.expval(qml.PauliZ(0))
  
          @qml.qnode(dev)
          def circuit2(weights):
              qml.RandomLayers(weights=weights, wires=range(2))
              return qml.expval(qml.PauliZ(0))
  
      >>> np.allclose(circuit1(weights), circuit2(weights))
      True
  
      You can verify this by drawing the circuits.
  
      >>> print(qml.draw(circuit1, expansion_strategy="device")(weights))
      0: ──────────────────────╭X─╭X──RZ(1.40)─┤  <Z>
      1: ──RX(0.10)──RX(-2.10)─╰●─╰●───────────┤
  
      >>> print(qml.draw(circuit2, expansion_strategy="device")(weights))
      0: ──────────────────────╭X─╭X──RZ(1.40)─┤  <Z>
      1: ──RX(0.10)──RX(-2.10)─╰●─╰●───────────┤
  
  
      **Changing the seed**
  
      To change the randomly generated circuit architecture, you have to change the seed passed to the template.
      For example, these two calls of ``RandomLayers`` *do not* create the same circuit:
  
      >>> @qml.qnode(dev)
      ... def circuit(weights, seed=None):
      ...     qml.RandomLayers(weights=weights, wires=range(2), seed=seed)
      ...     return qml.expval(qml.PauliZ(0))
      >>> np.allclose(circuit(weights, seed=9), circuit(weights, seed=12))
      False
      >>>  print(qml.draw(circuit, expansion_strategy="device")(weights, seed=9))
      0: ─╭X──RX(0.10)────────────┤  <Z>
      1: ─╰●──RY(-2.10)──RX(1.40)─┤
      >>> print(qml.draw(circuit, expansion_strategy="device")(weights, seed=12))
      0: ─╭X──RZ(0.10)──╭●─╭X───────────┤  <Z>
      1: ─╰●──RX(-2.10)─╰X─╰●──RZ(1.40)─┤
  
  
      **Automatic creation of random circuits**
  
      To automate the process of creating different circuits with ``RandomLayers``,
      you can set ``seed=None`` to avoid specifying a seed. However, in this case care needs
      to be taken. In the default setting, a quantum node is **mutable**, which means that the quantum function is
      re-evaluated every time it is called. This means that the circuit is re-constructed from scratch
      each time you call the qnode:
  
      .. code-block:: python
  
          @qml.qnode(dev)
          def circuit_rnd(weights):
              qml.RandomLayers(weights=weights, wires=range(2), seed=None)
              return qml.expval(qml.PauliZ(0))
  
          first_call = circuit_rnd(weights)
          second_call = circuit_rnd(weights)
  
      >>> np.allclose(first_call, second_call)
      False
  
      This can be rectified by making the quantum node **immutable**.
  
      .. code-block:: python
  
          @qml.qnode(dev, mutable=False)
          def circuit_rnd(weights):
              qml.RandomLayers(weights=weights, wires=range(2), seed=None)
              return qml.expval(qml.PauliZ(0))
  
          first_call = circuit_rnd(weights)
          second_call = circuit_rnd(weights)
  
      >>> np.allclose(first_call, second_call)
      True
  
      **Parameter shape**
  
      The expected shape for the weight tensor can be computed with the static method
      :meth:`~.RandomLayers.shape` and used when creating randomly
      initialised weight tensors:
  
      .. code-block:: python
  
          shape = qml.RandomLayers.shape(n_layers=2, n_rotations=3)
          weights = np.random.random(size=shape)
docstr: Returns the expected shape of the weights tensor.
  
  Args:
      n_layers (int): number of layers
      n_rotations (int): number of rotations
  
  Returns:
      tuple[int]: shape
code: def shape(n_layers, n_rotations):
      r"""Returns the expected shape of the weights tensor.
  
      Args:
          n_layers (int): number of layers
          n_rotations (int): number of rotations
  
      Returns:
          tuple[int]: shape
      """
  
      return n_layers, n_rotations
  
file_path: pennylane/pennylane/templates/layers/random.py
imports: import numpy
  import pennylane
  from pennylane.operation import Operation, AnyWires
label_desc: Use image node_id 4 for calling the RandomLayers obj's underlying member method code with example usage: obj.shape(n_layers, n_rotations) and returns: n_layers,  n_rotations