Pytorch 2.7.1+cu126 で量子アルゴリズムを使ったパーセプトロンの実験をしてみました。
ChatGPT o3を使いました。
結構面白い結果を出します。（確率論的）
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Quantum‑style perceptron with path visualisation (CUDA 12.4 compatible)
Layers:
0. |0000⟩ (implicit)
1. H on every qubit
2. Ry(θᵢ) on each qubit — random “weights”
3‑… random CNOT “synapses” — three by default
For each shot we *measure* after every layer, collapse the state,
and feed the resulting basis state to the next layer.
This yields an integer path, e.g. 0 → 6 → 3 → 7 → 15.
The script shows:
• Top‑10 most frequent paths
• Final measurement histogram (same as before)
Author : Tsubasa Kato - Inspire Search Corp.
Date : 2025‑07‑16
"""
import math
import random
from collections import Counter, defaultdict
import torch
# -----------------------------------------------------------
# 0. Hyper‑parameters
# -----------------------------------------------------------
NUM_QUBITS = 4
NUM_SYNAPSES = 3 # number of random CNOTs
SHOTS = 1024 # how many trajectories to sample
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
DTYPE = torch.complex64
# -----------------------------------------------------------
# 1. Primitive gates
# -----------------------------------------------------------
I2 = torch.eye(2, dtype=DTYPE, device=device)
H = (1 / math.sqrt(2)) * torch.tensor(
[[1, 1],
[1, -1]], dtype=DTYPE, device=device
)
def Ry(theta: float) -> torch.Tensor:
"""Single‑qubit rotation around Y."""
return torch.tensor(
[[ math.cos(theta / 2), -math.sin(theta / 2)],
[ math.sin(theta / 2), math.cos(theta / 2)]],
dtype=DTYPE,
device=device,
)
def embed_single(gate: torch.Tensor, target: int, n: int) -> torch.Tensor:
mats = [gate if q == target else I2 for q in range(n)]
return torch.kron(torch.kron(torch.kron(mats[3], mats[2]), mats[1]), mats[0]) \
if n == 4 else torch.kron(torch.kron(mats[2], mats[1]), mats[0]) # generic kron_all is slower for n<=4
def embed_cnot(ctrl: int, tgt: int, n: int) -> torch.Tensor:
dim = 2 ** n
op = torch.zeros((dim, dim), dtype=DTYPE, device=device)
for basis in range(dim):
bits = [(basis >> q) & 1 for q in range(n)]
flip = basis ^ (1 << tgt) if bits[ctrl] else basis
op[basis, flip] = 1.0
return op
# -----------------------------------------------------------
# 2. Build each *layer* operator and keep them separately
# -----------------------------------------------------------
layers = []
# (Layer 1) H on every qubit
U_H = torch.eye(2 ** NUM_QUBITS, dtype=DTYPE, device=device)
for q in range(NUM_QUBITS):
U_H = embed_single(H, q, NUM_QUBITS) @ U_H
layers.append(U_H)
# (Layer 2) random Ry on every qubit
U_RY = torch.eye(2 ** NUM_QUBITS, dtype=DTYPE, device=device)
for q in range(NUM_QUBITS):
θ = random.uniform(0, 2 * math.pi)
U_RY = embed_single(Ry(θ), q, NUM_QUBITS) @ U_RY
layers.append(U_RY)
# (Layers 3…) random CNOTs
connected = set()
while len(connected) < NUM_SYNAPSES:
a, b = random.sample(range(NUM_QUBITS), 2)
if (a, b) not in connected and (b, a) not in connected:
layers.append(embed_cnot(a, b, NUM_QUBITS))
connected.add((a, b))
# -----------------------------------------------------------
# 3. Function to propagate ONE shot through all layers
# -----------------------------------------------------------
def single_trajectory() -> tuple:
"""Return a tuple of decimal basis states after each layer."""
state = torch.zeros(2 ** NUM_QUBITS, dtype=DTYPE, device=device)
state[0] = 1.0 # |0000⟩
path = []
for U in layers:
state = U @ state
probs = (state.abs() ** 2).to(torch.float32)
idx = torch.multinomial(probs, 1, replacement=True).item()
path.append(idx)
# collapse: new one‑hot basis vector
state.zero_()
state[idx] = 1.0
return tuple(path) # e.g. (6, 3, 7, 15)
# -----------------------------------------------------------
# 4. Sample many trajectories
# -----------------------------------------------------------
path_counter = Counter()
final_counts = Counter()
for _ in range(SHOTS):
traj = single_trajectory()
path_counter[traj] += 1
final_counts[traj[-1]] += 1
# -----------------------------------------------------------
# 5. Pretty‑print results
# -----------------------------------------------------------
def fmt_bits(idx: int) -> str:
"""Little‑endian binary string (matches Qiskit ordering)."""
return format(idx, f"0{NUM_QUBITS}b")[::-1]
print(f"\nDevice : {device} | PyTorch {torch.__version__}")
print(f"Layers : 1 (H) → 2 (Ry) → 3…{2+NUM_SYNAPSES} (CNOTs)")
print(f"Shots : {SHOTS}\n")
print("Top‑10 activation *paths* (decimal indices):")
for path, cnt in path_counter.most_common(10):
decimal_path = " -> ".join(map(str, path))
binary_path = " -> ".join(fmt_bits(i) for i in path)
print(f"{decimal_path:<20} ({cnt:>4} shots) [{binary_path}]")
print("\nFinal measurement histogram:")
for idx, cnt in final_counts.most_common():
print(f"{fmt_bits(idx)} ({idx:>2}) : {cnt}")
実行例
Device : cuda | PyTorch 2.7.1+cu126
Layers : 1 (H) → 2 (Ry) → 3…5 (CNOTs)
Shots : 1024
Top‑10 activation *paths* (decimal indices):
2 -> 3 -> 3 -> 3 -> 2 ( 50 shots) [0100 -> 1100 -> 1100 -> 1100 -> 0100]
5 -> 4 -> 12 -> 13 -> 13 ( 49 shots) [1010 -> 0010 -> 0011 -> 1011 -> 1011]
15 -> 14 -> 6 -> 7 -> 6 ( 48 shots) [1111 -> 0111 -> 0110 -> 1110 -> 0110]
7 -> 6 -> 14 -> 15 -> 14 ( 47 shots) [1110 -> 0110 -> 0111 -> 1111 -> 0111]
6 -> 7 -> 15 -> 14 -> 15 ( 43 shots) [0110 -> 1110 -> 1111 -> 0111 -> 1111]
11 -> 10 -> 10 -> 10 -> 11 ( 42 shots) [1101 -> 0101 -> 0101 -> 0101 -> 1101]
9 -> 8 -> 8 -> 8 -> 8 ( 41 shots) [1001 -> 0001 -> 0001 -> 0001 -> 0001]
4 -> 5 -> 13 -> 12 -> 12 ( 41 shots) [0010 -> 1010 -> 1011 -> 0011 -> 0011]
14 -> 15 -> 7 -> 6 -> 7 ( 40 shots) [0111 -> 1111 -> 1110 -> 0110 -> 1110]
3 -> 2 -> 2 -> 2 -> 3 ( 39 shots) [1100 -> 0100 -> 0100 -> 0100 -> 1100]
Final measurement histogram:
0100 ( 2) : 78
0111 (14) : 78
0110 ( 6) : 77
0011 (12) : 68
1110 ( 7) : 68
1011 (13) : 68
1000 ( 1) : 63
1001 ( 9) : 62
1101 (11) : 61
1100 ( 3) : 60
1010 ( 5) : 60
1111 (15) : 59
0101 (10) : 57
0001 ( 8) : 57
0000 ( 0) : 55
0010 ( 4) : 53
*bit_stringは逆に書いてありますが、Chat GPT o3に相談した所、ただ反転してあるだけで、どっちでも良いそうです。例えば「2」が「0100」になっている点。