def __init__(self):
super().__init__()
self.n_wires = 4
self.q_device = tq.QuantumDevice(n_wires=self.n_wires)
self.measure = tq.MeasureAll(tq.PauliZ)
self.encoder = tq.MultiPhaseEncoder([tqf.rx] * 4 + [tqf.ry] * 4 +
[tqf.rz] * 4 + [tqf.rx] * 4)
self.super_layers_all = tq.QuantumModuleList()
self.normal_layers_all = tq.QuantumModuleList()
for k in range(2):
self.normal_layers_all.append(
tq.Op1QAllLayer(op=tq.RX,
n_wires=self.n_wires,
has_params=True,
trainable=True))
self.normal_layers_all.append(
tq.Op1QAllLayer(op=tq.RY,
n_wires=self.n_wires,
has_params=True,
trainable=True))
self.normal_layers_all.append(
tq.Op1QAllLayer(op=tq.RZ,
n_wires=self.n_wires,
has_params=True,
trainable=True))
for k in range(2):
self.super_layers_all.append(
tq.Super1QAllButOneLayer(op=tq.RX,
n_wires=self.n_wires,
has_params=True,
trainable=True))
self.super_layers_all.append(
tq.Super1QAllButOneLayer(op=tq.RY,
n_wires=self.n_wires,
has_params=True,
trainable=True))
self.super_layers_all.append(
tq.Super1QAllButOneLayer(op=tq.RZ,
n_wires=self.n_wires,
has_params=True,
trainable=True))
self.super_layers_all.append(
tq.Super1QSingleWireLayer(op=tq.RX,
n_wires=self.n_wires,
has_params=True,
trainable=True))
self.super_layers_all.append(
tq.Super1QSingleWireLayer(op=tq.RY,
n_wires=self.n_wires,
has_params=True,
trainable=True))
self.super_layers_all.append(
tq.Super1QSingleWireLayer(op=tq.RZ,
n_wires=self.n_wires,
has_params=True,
trainable=True))
def __init__(self, n_wires):
super().__init__()
self.n_wires = n_wires
self.encoder = tq.MultiPhaseEncoder([tqf.rx] * 4 + [tqf.ry] * 4 +
[tqf.rz] * 4 + [tqf.rx] * 4)
self.super_layers_all = tq.QuantumModuleList()
for k in range(4):
self.super_layers_all.append(
tq.Super1QShareFrontLayer(op=tq.RX,
n_wires=self.n_wires,
n_front_share_wires=2,
has_params=True,
trainable=True))
self.super_layers_all.append(
tq.Super1QShareFrontLayer(op=tq.RY,
n_wires=self.n_wires,
n_front_share_wires=2,
has_params=True,
trainable=True))
self.super_layers_all.append(
tq.Super1QShareFrontLayer(op=tq.RZ,
n_wires=self.n_wires,
n_front_share_wires=2,
has_params=True,
trainable=True))
def build_super_layers(self):
super_layers_all = tq.QuantumModuleList()
super_layers_all.append(
Super1QLayer(op=tq.SHadamard, n_wires=self.n_wires))
for k in range(self.arch['n_blocks']):
super_layers_all.append(
Super1QLayer(op=tq.RX,
n_wires=self.n_wires,
has_params=True,
trainable=True))
super_layers_all.append(
Super1QLayer(op=tq.RY,
n_wires=self.n_wires,
has_params=True,
trainable=True))
super_layers_all.append(
Super1QLayer(op=tq.RZ,
n_wires=self.n_wires,
has_params=True,
trainable=True))
super_layers_all.append(
Super2QAlterLayer(op=tq.CZ, n_wires=self.n_wires, jump=1))
return super_layers_all
def build_layers(self):
layers_all = tq.QuantumModuleList()
layers_all.append(
Op1QAllLayer(op=tq.RZ,
n_wires=self.n_wires,
has_params=True,
trainable=True))
layers_all.append(
Op2QAllLayer(op=tq.CNOT,
n_wires=self.n_wires,
jump=1,
circular=False))
for k in range(self.arch['n_blocks']):
layers_all.append(
Op1QAllLayer(op=tq.RZ,
n_wires=self.n_wires,
has_params=True,
trainable=True))
layers_all.append(
Op1QAllLayer(op=tq.SX,
n_wires=self.n_wires,
has_params=True,
trainable=True))
layers_all.append(
Op1QAllLayer(op=tq.RZ,
n_wires=self.n_wires,
has_params=True,
trainable=True))
return layers_all
def __init__(self,
op,
n_wires: int,
n_front_share_ops: int,
has_params=False,
trainable=False,
wire_reverse=False,
jump=1):
super().__init__(n_wires=n_wires)
self.op = op
self.n_front_share_ops = n_front_share_ops
self.jump = jump
# reverse the wires, for example from [1, 2] to [2, 1]
self.wire_reverse = wire_reverse
self.ops_all = tq.QuantumModuleList()
self.n_ops = (n_wires - 1) // jump
for k in range(self.n_ops):
self.ops_all.append(op(has_params=has_params, trainable=trainable))
self.wires_choices = []
k = 0
while k < n_wires:
if k < n_wires and k + jump < n_wires:
self.wires_choices.append([k, k + jump])
k += jump * 2
k = jump
while k < n_wires:
if k < n_wires and k + jump < n_wires:
self.wires_choices.append([k, k + jump])
k += jump * 2
def __init__(self,
op,
n_wires: int,
n_front_share_ops: int,
has_params=False,
trainable=False,
wire_reverse=False,
jump=1,
circular=False):
super().__init__(n_wires=n_wires)
self.op = op
self.n_front_share_ops = n_front_share_ops
self.jump = jump
self.circular = circular
# reverse the wires, for example from [1, 2] to [2, 1]
self.wire_reverse = wire_reverse
self.ops_all = tq.QuantumModuleList()
if circular:
self.n_ops = n_wires
else:
self.n_ops = n_wires - jump
for k in range(self.n_ops):
self.ops_all.append(op(has_params=has_params, trainable=trainable))
def build_layers(self):
layers_all = tq.QuantumModuleList()
layers_all.append(Op1QAllLayer(
op=tq.SHadamard,
n_wires=self.n_wires,
))
for k in range(self.arch['n_blocks']):
layers_all.append(
Op1QAllLayer(op=tq.RX,
n_wires=self.n_wires,
has_params=True,
trainable=True))
layers_all.append(
Op1QAllLayer(op=tq.RY,
n_wires=self.n_wires,
has_params=True,
trainable=True))
layers_all.append(
Op1QAllLayer(op=tq.RZ,
n_wires=self.n_wires,
has_params=True,
trainable=True))
layers_all.append(
Op2QAllLayer(op=tq.CZ, n_wires=self.n_wires, jump=1))
return layers_all
def __init__(self, q_device: tq.QuantumDevice = None):
super().__init__()
self.q_device = q_device
self.n_gate = 10
self.gate0 = tq.CNOT()
# self.gate1 = tq.CNOT()
self.submodules = tq.QuantumModuleList()
self.q_layer0 = TQAll(self.n_gate, tq.CNOT)
for k in range(self.n_gate):
self.submodules.append(tq.RY())
# for k in range(self.n_gate):
# self.submodules.append(tq.CNOT())
# self.gate0 = tq.RY(has_params=False, trainable=False)
# self.gate1 = tq.RX(has_params=False, trainable=False)
# self.gate2 = tq.RZ(has_params=False, trainable=False)
self.gate1 = tq.RX(has_params=True, trainable=True)
self.gate2 = tq.RZ(has_params=True, trainable=True)
self.gate3 = tq.RY(has_params=True, trainable=True)
# self.gate3 = tq.CNOT()
self.gate4 = tq.RX(has_params=True, trainable=True)
self.gate5 = tq.RZ(has_params=True, trainable=True)
self.gate6 = tq.RY(has_params=True, trainable=True)
self.gate7 = tq.RX()
self.gate8 = tq.U2(has_params=True, trainable=True)
self.gate9 = tq.TrainableUnitary(has_params=True,
trainable=True,
n_wires=3)
self.gate10 = tq.MultiXCNOT(n_wires=5)
self.gate11 = tq.MultiCNOT(n_wires=3)
def __init__(self, n_gate: int, op: tq.Operator):
super().__init__()
self.submodules = tq.QuantumModuleList()
self.n_gate = n_gate
self.t00 = T00()
for k in range(self.n_gate):
self.submodules.append(op())
def __init__(self, n_gate: int, op: tq.Operator):
super().__init__()
self.submodules = tq.QuantumModuleList()
self.q_layer0 = TQAll(n_gate, tq.CNOT)
self.n_gate = n_gate
for k in range(self.n_gate):
self.submodules.append(op())
def __init__(self, op, n_wires: int, has_params=False, trainable=False):
super().__init__()
self.n_wires = n_wires
self.op = op
self.ops_all = tq.QuantumModuleList()
for k in range(n_wires):
self.ops_all.append(op(has_params=has_params, trainable=trainable))
def build_nodes(node_archs, act_norm=None):
nodes = tq.QuantumModuleList()
for k, node_arch in enumerate(node_archs):
nodes.append(QuantumNode(node_arch, act_norm=act_norm,
node_id=k))
return nodes
def __init__(self, arch=None):
super().__init__()
self.arch = arch
self.n_wires = arch['n_wires']
self.ry_layers = tq.QuantumModuleList()
self.cz_layers = tq.QuantumModuleList()
for k in range(arch['n_blocks']):
self.ry_layers.append(
tq.Op1QAllLayer(op=tq.RY,
n_wires=self.n_wires,
has_params=True,
trainable=True))
self.cz_layers.append(
tq.Op2QAllLayer(op=tq.CZ,
n_wires=self.n_wires,
circular=True))
def build_super_layers(self):
super_layers_all = tq.QuantumModuleList()
for k in range(self.arch['n_blocks']):
super_layers_all.append(
tq.Super1QLayer(op=tq.RX,
n_wires=self.n_wires,
has_params=True,
trainable=True))
super_layers_all.append(
tq.Super1QLayer(op=tq.S, n_wires=self.n_wires))
super_layers_all.append(
tq.Super2QAllLayer(op=tq.CNOT,
n_wires=self.n_wires,
jump=1,
circular=True))
super_layers_all.append(
tq.Super1QLayer(op=tq.RY,
n_wires=self.n_wires,
has_params=True,
trainable=True))
super_layers_all.append(
tq.Super1QLayer(op=tq.T, n_wires=self.n_wires))
super_layers_all.append(
tq.Super2QAllLayer(op=tq.SWAP,
n_wires=self.n_wires,
jump=1,
circular=True))
super_layers_all.append(
tq.Super1QLayer(op=tq.RZ,
n_wires=self.n_wires,
has_params=True,
trainable=True))
super_layers_all.append(
tq.Super1QLayer(op=tq.T, n_wires=self.n_wires))
super_layers_all.append(
tq.Super2QAllLayer(op=tq.SSWAP,
n_wires=self.n_wires,
jump=1,
circular=True))
super_layers_all.append(
tq.Super1QLayer(op=tq.U1,
n_wires=self.n_wires,
has_params=True,
trainable=True))
super_layers_all.append(
tq.Super2QAllLayer(op=tq.CU3,
n_wires=self.n_wires,
has_params=True,
trainable=True,
jump=1,
circular=True))
return super_layers_all
def __init__(self,
op,
n_wires: int,
has_params=False,
trainable=False,
wire_reverse=False):
super().__init__(n_wires=n_wires)
self.op = op
self.ops_all = tq.QuantumModuleList()
# reverse the wires, for example from [1, 2] to [2, 1]
self.wire_reverse = wire_reverse
for k in range(n_wires):
self.ops_all.append(op(has_params=has_params, trainable=trainable))
def rebuild_random_layer_from_op_list(self, n_ops_in, wires_in,
op_list_in):
"""Used for loading random layer from checkpoint"""
self.n_ops = n_ops_in
self.wires = wires_in
self.op_list = tq.QuantumModuleList()
for op_in in op_list_in:
op = tq.op_name_dict[op_in.name.lower()](
has_params=op_in.has_params,
trainable=op_in.trainable,
wires=op_in.wires,
n_wires=op_in.n_wires,
)
self.op_list.append(op)
def __init__(self, n_wires, arch):
super().__init__()
self.n_wires = n_wires
self.arch = arch
self.super_layers_all = tq.QuantumModuleList()
self.n_blocks = arch['n_blocks']
self.n_layers_per_block = arch['n_layers_per_block']
self.n_front_share_blocks = arch['n_front_share_blocks']
for k in range(self.n_blocks):
self.super_layers_all.append(
tq.Super1QLayer(op=tq.RX,
n_wires=self.n_wires,
has_params=True,
trainable=True))
self.super_layers_all.append(
tq.Super1QLayer(op=tq.RY,
n_wires=self.n_wires,
has_params=True,
trainable=True))
self.super_layers_all.append(
tq.Super1QLayer(op=tq.RZ,
n_wires=self.n_wires,
has_params=True,
trainable=True))
self.super_layers_all.append(
tq.Super2QAllLayer(op=tq.CRX,
n_wires=self.n_wires,
has_params=True,
trainable=True,
jump=1,
circular=True))
self.super_layers_all.append(
tq.Super2QAllLayer(op=tq.CRY,
n_wires=self.n_wires,
has_params=True,
trainable=True,
jump=1,
circular=True))
self.super_layers_all.append(
tq.Super2QAllLayer(op=tq.CRZ,
n_wires=self.n_wires,
has_params=True,
trainable=True,
jump=1,
circular=True))
self.sample_n_blocks = None
def __init__(
self,
wires,
n_ops=None,
n_params=None,
op_ratios=None,
op_types=(tq.RX, tq.RY, tq.RZ, tq.CNOT),
seed=None,
qiskit_compatible=False,
):
super().__init__()
self.n_ops = n_ops
self.n_params = n_params
assert n_params is not None or n_ops is not None
self.wires = wires if isinstance(wires, Iterable) else [wires]
self.n_wires = len(wires)
op_types = op_types if isinstance(op_types, Iterable) else [op_types]
if op_ratios is None:
op_ratios = [1] * len(op_types)
else:
op_ratios = op_ratios if isinstance(op_ratios,
Iterable) else [op_ratios]
op_types_valid = []
op_ratios_valid = []
if qiskit_compatible:
for op_type, op_ratio in zip(op_types, op_ratios):
if op_type().name.lower() in QISKIT_INCOMPATIBLE_FUNC_NAMES:
logger.warning(f"Remove {op_type} from op_types to make "
f"the layer qiskit-compatible.")
else:
op_types_valid.append(op_type)
op_ratios_valid.append(op_ratio)
else:
op_types_valid = op_types
op_ratios_valid = op_ratios
self.op_types = op_types_valid
self.op_ratios = np.array(op_ratios_valid) / sum(op_ratios_valid)
self.seed = seed
self.op_list = tq.QuantumModuleList()
if seed is not None:
np.random.seed(seed)
self.build_random_layer()
def build_super_layers(self):
super_layers_all = tq.QuantumModuleList()
for k in range(self.arch['n_blocks']):
super_layers_all.append(
Super2QAllShareFrontLayer(
op=tq.RZZ,
n_wires=self.n_wires,
n_front_share_ops=self.n_front_share_ops,
has_params=True,
trainable=True,
jump=1,
circular=True))
super_layers_all.append(
Super1QShareFrontLayer(
op=tq.RY,
n_wires=self.n_wires,
n_front_share_wires=self.n_front_share_wires,
has_params=True,
trainable=True))
return super_layers_all
def __init__(self):
super().__init__()
self.n_gate = 12
self.gate0 = tq.CNOT()
self.gate1 = tq.CNOT()
self.submodules = tq.QuantumModuleList()
self.q_layer0 = TQAll(self.n_gate, tq.CNOT)
for k in range(self.n_gate):
self.submodules.append(tq.RY())
# for k in range(self.n_gate):
# self.submodules.append(tq.CNOT())
# self.gate0 = tq.RY(has_params=False, trainable=False)
# self.gate1 = tq.RX(has_params=False, trainable=False)
# self.gate2 = tq.RZ(has_params=False, trainable=False)
self.gate1 = tq.RX(has_params=True, trainable=True)
self.gate2 = tq.RZ(has_params=True, trainable=True)
self.gate3 = tq.RY(has_params=True, trainable=True)
# self.gate3 = tq.CNOT()
self.gate4 = tq.RX(has_params=True, trainable=True)
self.gate5 = tq.RZ(has_params=True, trainable=True)
self.gate6 = tq.RY(has_params=True, trainable=True)
def __init__(self, n_wires):
super().__init__()
self.n_wires = n_wires
self.rx_gates = tq.QuantumModuleList(
[tq.RX() for _ in range(self.n_wires)])
def __init__(self, ops):
super().__init__()
self.ops = tq.QuantumModuleList(ops)
