This repository was archived by the owner on Apr 20, 2026. It is now read-only.
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathQ2_NeuralNetwork_Grover.py
More file actions
267 lines (218 loc) · 8.65 KB
/
Q2_NeuralNetwork_Grover.py
File metadata and controls
267 lines (218 loc) · 8.65 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
#!/usr/bin/env python3
"""
Q2 Neural Network — (čisto kvantno, bez klasičnog treniranja):
Kvantno „učenje težina“ = GROVER / amplitude amplification nad parametrizovanim stanjem.
Oracle označava TOP-M brojeva po istorijskoj frekvenciji iz CELOG CSV-a.
Broj iteracija: k = round((π/4) · √(N/M)) — optimalni Grover broj.
Statevector → Born verovatnoće → NEXT rastuća sedmorka ∈ {1..39}.
Seed = 39; isti start uvek daje isti rezultat.
Okruženje: Python 3.11.13, qiskit 1.4.4, qiskit-machine-learning 0.8.3, macOS M1 (vidi README.md).
"""
from __future__ import annotations
import csv
import random
import warnings
from pathlib import Path
from typing import List, Tuple
import numpy as np
warnings.filterwarnings("ignore", category=DeprecationWarning)
warnings.filterwarnings("ignore", category=FutureWarning)
from qiskit import QuantumCircuit
from qiskit.circuit.library import Diagonal
from qiskit.quantum_info import Statevector
# =========================
# Seed za reproduktivnost
# =========================
SEED = 39
np.random.seed(SEED)
random.seed(SEED)
try:
from qiskit_machine_learning.utils import algorithm_globals
algorithm_globals.random_seed = SEED
except ImportError:
pass
# =========================
# Konfiguracija
# =========================
CSV_PATH = Path("/data/loto7hh_4600_k31.csv")
N_QUBITS = 6 # 2^6 = 64 stanja; indeksi 0..38 -> brojevi 1..39 (default)
N_NUMBERS = 7
N_MAX = 39
K_MARKED = 7 # koliko top-frekventnih brojeva oracle obeležava (default)
# Deterministička grid-optimizacija (nq, M, broj iteracija) po meri cos(bias, freq_csv).
# Broj iteracija: ili optimalna Grover formula k* = round((π/4)·√(N/M)), ili k* ± 1.
GRID_NQ = (6, 7, 8)
GRID_K = (3, 5, 7, 10, 15)
GRID_ITER_DELTA = (-1, 0, 1)
# =========================
# CSV
# =========================
def load_rows(path: Path) -> np.ndarray:
rows: List[List[int]] = []
with open(path, newline="", encoding="utf-8") as f:
r = csv.reader(f)
header = next(r)
if not header or "Num1" not in header[0]:
f.seek(0)
r = csv.reader(f)
next(r, None)
for row in r:
if not row or row[0].strip() == "Num1":
continue
rows.append([int(row[i]) for i in range(N_NUMBERS)])
return np.array(rows, dtype=int)
def freq_vector(H: np.ndarray) -> np.ndarray:
"""Histogram pojavljivanja brojeva 1..39 u celom H."""
c = np.zeros(N_MAX, dtype=np.float64)
for v in H.ravel():
if 1 <= v <= N_MAX:
c[int(v) - 1] += 1.0
return c
def top_k_indices(freq: np.ndarray, k: int) -> List[int]:
"""Top-k indeksi (0..38) po frekvenciji — deterministički, stabilni sort."""
order = np.argsort(-freq, kind="stable")
return [int(i) for i in order[:k]]
# =========================
# Grover: oracle + diffusion
# =========================
def build_oracle(nq: int, marked_indices: List[int]) -> QuantumCircuit:
"""Fazni oracle: -1 na obeleženim stanjima u komp. bazi, +1 inače."""
diag = np.ones(2 ** nq, dtype=complex)
for m in marked_indices:
if 0 <= m < 2 ** nq:
diag[m] = -1.0 + 0j
return Diagonal(diag.tolist())
def build_diffusion(nq: int) -> QuantumCircuit:
"""Difuzor 2|s⟩⟨s| - I, gde je |s⟩ = H^⊗n |0⟩ (standardni Grover oblik)."""
qc = QuantumCircuit(nq, name="Diff")
qc.h(range(nq))
qc.x(range(nq))
qc.h(nq - 1)
if nq >= 2:
qc.mcx(list(range(nq - 1)), nq - 1)
else:
qc.z(0)
qc.h(nq - 1)
qc.x(range(nq))
qc.h(range(nq))
return qc
def optimal_iterations(n: int, m: int) -> int:
"""k = round((π/4) · √(N/M)), minimum 1 iteracija."""
if m <= 0 or n <= 0:
return 0
return max(1, int(round((np.pi / 4.0) * np.sqrt(n / m))))
# =========================
# Readout: NEXT sedmorka
# =========================
def bias_39(probs: np.ndarray, n_max: int = N_MAX) -> np.ndarray:
b = np.zeros(n_max, dtype=np.float64)
for idx, p in enumerate(probs):
b[idx % n_max] += float(p)
s = float(b.sum())
return b / s if s > 0 else b
def cosine(a: np.ndarray, b: np.ndarray) -> float:
na = float(np.linalg.norm(a))
nb = float(np.linalg.norm(b))
if na < 1e-18 or nb < 1e-18:
return 0.0
return float(np.dot(a, b) / (na * nb))
def pick_next_combination(probs: np.ndarray, k: int = N_NUMBERS, n_max: int = N_MAX) -> Tuple[int, ...]:
"""Za indeks < n_max koristi direktno bucket = idx; za idx >= n_max dodaje po modulu."""
b = bias_39(probs, n_max)
order = np.argsort(-b, kind="stable")
return tuple(sorted(int(o + 1) for o in order[:k]))
def grover_probs(nq: int, marked: List[int], k_iter: int) -> np.ndarray:
oracle = build_oracle(nq, marked)
diff = build_diffusion(nq)
qc = QuantumCircuit(nq)
qc.h(range(nq))
for _ in range(max(0, k_iter)):
qc.compose(oracle, range(nq), inplace=True)
qc.compose(diff, range(nq), inplace=True)
sv = Statevector(qc)
p = np.abs(sv.data) ** 2
s = float(p.sum())
return p / s if s > 0 else p
# =========================
# Determ. grid-optimizacija (nq, M, iter) po meri cos(bias, freq_csv)
# =========================
def optimize_hparams(H: np.ndarray):
f_csv = freq_vector(H)
f_csv_n = f_csv / float(f_csv.sum() or 1.0)
best = None
for nq in GRID_NQ:
N_space = 2 ** nq
for M in GRID_K:
marked = top_k_indices(f_csv, M)
k_star = optimal_iterations(N_space, M)
for d in GRID_ITER_DELTA:
k_iter = max(1, k_star + d)
try:
probs = grover_probs(nq, marked, k_iter)
b = bias_39(probs)
score = cosine(b, f_csv_n)
except Exception:
continue
key = (score, -nq, -M, -abs(d))
if best is None or key > best[0]:
best = (
key,
dict(nq=nq, M=M, k_iter=k_iter, delta=d, score=score, marked=marked),
)
return best[1] if best else None
def main() -> int:
H = load_rows(CSV_PATH)
if H.shape[0] < 1:
print("premalo redova")
return 1
print("Q2 NN (B): CSV:", CSV_PATH)
print("redova:", H.shape[0], "| seed:", SEED)
best = optimize_hparams(H)
if best is None:
print("grid optimizacija nije uspela")
return 2
print(
"BEST hparam:",
"nq=", best["nq"],
"| N:", 2 ** best["nq"],
"| M (marked):", best["M"],
"| iter:", best["k_iter"],
"(Δ vs k*: {})".format(best["delta"]),
"| cos(bias, freq_csv):", round(float(best["score"]), 6),
)
print("top-M brojevi (1..39):", sorted(int(m + 1) for m in best["marked"]))
probs = grover_probs(best["nq"], best["marked"], best["k_iter"])
pred = pick_next_combination(probs)
print("predikcija NEXT:", pred)
return 0
if __name__ == "__main__":
raise SystemExit(main())
"""
Q2 NN: CSV: /data/loto7hh_4600_k31.csv
redova: 4600 | seed: 39
BEST hparam: nq= 6 | N: 64 | M (marked): 15 | iter: 2 (Δ vs k*: 0) | cos(bias, freq_csv): 0.97047
top-M brojevi (1..39): [7, 8, 9, 10, 11, 22, 23, 26, 29, 32, 33, 34, 35, 37, 39]
predikcija NEXT: (7, 8, x, y, z, 22, 23)
"""
"""
Q2_NeuralNetwork_Grover.py — Grover / Amplitude Amplification
Učita CEO CSV, izračuna histogram brojeva 1..39.
Oracle obeleži top-M najčešćih brojeva (mapirano u nq-bitne komp. bazne indekse).
Krene iz uniformne superpozicije H^⊗nq, primeni Grover iteracije (oracle + difuzor) k* puta.
Statevector → Born → bias_39 → NEXT rastuća sedmorka.
Deterministička grid-optimizacija (nq, M, Δiter oko k*) po meri cos(bias, freq_csv).
Kanonski Grover: fazni oracle (Diagonal(-1/+1)) + standardni difuzor 2|s⟩⟨s|-I.
Optimalan broj iteracija: k* = round((π/4)·√(N/M)).
Egzaktni Statevector, bez šuma i uzorkovanja.
Prednosti:
Čisto kvantno, bez klasičnog treninga.
Jako jednostavno i literaturno čisto — standardni Grover.
Deterministički izbor broja iteracija (zatvorena formula), plus grid ±1 iteracije za fino biranje.
Brzo, malo parametara.
Nedostaci:
„Marked“ skup je samo top-M po globalnoj frekvenciji — efektivno amplifikuje ono što je i onako najčešće; ne koristi strukturu CSV-a (sekvenca, korelacije parova).
Mera optimizacije cos(bias, freq_csv) u suštini vodi ka reprodukciji same frekvencije — tautološki signal. Što je M veće (bliže 39), to je poklapanje bolje bez ičeg „naučenog“.
mod-39 mapiranje 2^nq → 39 kanti briše razlike unutar kante.
Nema temporalne zavisnosti (redosled izvlačenja se ignoriše).
Eksponencijalno po nq kroz Statevector.
"""