quantum_kernel.py

"""
Быстрое создание квантового ядра для IBM Quantum
Оптимизировано для выполнения за ~8 минут
"""

# ===== ШАГ 1: УСТАНОВКА И ИМПОРТЫ =====
# Выполните в терминале:
# pip install qiskit qiskit-ibm-runtime qiskit-machine-learning scikit-learn

import numpy as np
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score

from qiskit import QuantumCircuit
from qiskit.circuit import ParameterVector
from qiskit.circuit.library import ZZFeatureMap, PauliFeatureMap
from qiskit_ibm_runtime import QiskitRuntimeService, Sampler
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

# ===== ШАГ 2: СОЗДАНИЕ ДАННЫХ =====
# Создаём простой датасет для бинарной классификации
print("Создание датасета...")

# Рассчитываем оптимальный размер на основе вашей скорости
# Ваша скорость: 108 схем за 44.3 секунды = 2.44 схемы/сек
# Доступно времени: ~7.5 минут = 450 секунд
# Максимум схем: 450 * 2.44 = ~1100 схем
# Оптимально: ~900 схем (запас 20%)

# Для 900 схем нужно: sqrt(900 * 0.75) ≈ 26 train образцов
# 26 train + 9 test = 35 образцов → 26^2 + 9*26 = 676 + 234 = 910 схем

X, y = make_classification(
    n_samples=35,      # Оптимально под вашу скорость!
    n_features=4,      # 4 признака -> 2 кубита
    n_informative=4,
    n_redundant=0,
    n_clusters_per_class=1,
    random_state=42
)

# Нормализация данных в диапазон [0, 2π]
X_min, X_max = X.min(), X.max()
X_normalized = 2 * np.pi * (X - X_min) / (X_max - X_min)

# Разделение на train/test (74/26)
X_train, X_test, y_train, y_test = train_test_split(
    X_normalized, y, test_size=0.26, random_state=42  # ~26 train, ~9 test
)

print(f"Train: {len(X_train)} образцов, Test: {len(X_test)} образцов")
total_circuits = len(X_train)**2 + len(X_test)*len(X_train)
expected_time = total_circuits / 2.44  # На основе вашей реальной скорости
print(f"ВАЖНО: Общее количество схем = {len(X_train)**2} + {len(X_test)*len(X_train)} = {total_circuits}")
print(f"📊 Ожидаемое время (на основе вашей скорости 2.44 схем/сек):")
print(f"   ~{expected_time:.0f} секунд ({expected_time/60:.1f} минут)")
print(f"   Запас до 8 минут: {8 - expected_time/60:.1f} минут")

# ===== ШАГ 3: СОЗДАНИЕ FEATURE MAP =====
num_qubits = 2  # Используем 2 кубита (4 признака / 2)

# ZZFeatureMap с минимальными reps для ibm_fez
feature_map = ZZFeatureMap(
    feature_dimension=num_qubits,
    reps=1,  # МИНИМУМ для экономии времени!
    entanglement='linear'
)

print(f"\nFeature map создана с {num_qubits} кубитами")
print(f"Количество параметров: {feature_map.num_parameters}")
print(f"Глубина схемы: {feature_map.depth()}")

# ===== ШАГ 4: ПОДКЛЮЧЕНИЕ К IBM QUANTUM =====
print("\nПодключение к IBM Quantum...")

# ibm_quantum_platform - это канал по умолчанию, можно не указывать
try:
    # Простейший вариант: token + instance (необязательно)
    service = QiskitRuntimeService(token='YDU7vuX8jQb4gFHEaxnLPkuyg05ueEzfB2baajl3dmP_')
    
    # Сохраняем для будущего использования
    QiskitRuntimeService.save_account(
        token='YDU7vuX8jQb4gFHEaxnLPkuyg05ueEzfB2baajl3dmP_',
        overwrite=True
    )
    print("✅ API токен успешно сохранён!")
    print("✅ Подключение установлено!")
    
except Exception as e:
    print(f"❌ Ошибка подключения: {e}")
    raise

# Подключаемся к ibm_fez (реальный квантовый компьютер!)
try:
    backend = service.backend('ibm_fez')
    print(f"\n{'='*50}")
    print(f"Используем РЕАЛЬНЫЙ квантовый компьютер: {backend.name}")
    print(f"Количество кубитов: {backend.num_qubits}")
    print(f"Статус: {'✅ Operational' if backend.status().operational else '❌ Not operational'}")
    print(f"{'='*50}\n")
except Exception as e:
    print(f"\n⚠️  Backend ibm_fez недоступен: {e}")
    print("\nДоступные backends:")
    backends = service.backends()
    for b in backends:
        status = "✅" if b.status().operational else "❌"
        print(f"  {status} {b.name} ({b.num_qubits} qubits)")
    
    print("\n💡 Используем наименее загруженный backend...")
    backend = service.least_busy(operational=True, simulator=False, min_num_qubits=2)
    print(f"Выбран: {backend.name}\n")

# ===== ШАГ 5: ФУНКЦИЯ ДЛЯ ВЫЧИСЛЕНИЯ ЯДРА =====
def compute_kernel_matrix(X1, X2, feature_map, backend, shots=1024):
    """
    Вычисляет матрицу квантового ядра между X1 и X2
    
    Параметры:
    - X1, X2: массивы данных
    - feature_map: квантовая карта признаков
    - backend: IBM Quantum backend
    - shots: количество измерений на схему
    """
    n1, n2 = len(X1), len(X2)
    kernel_matrix = np.zeros((n1, n2))
    
    circuits = []
    indices = []
    
    # Создаём схемы для всех пар (i, j)
    for i in range(n1):
        for j in range(n2):
            # Берём только первые num_qubits признаков
            x1_features = X1[i][:num_qubits]
            x2_features = X2[j][:num_qubits]
            
            # Создаём overlap circuit
            qc = QuantumCircuit(num_qubits)
            
            # Применяем feature map для x1
            qc.compose(feature_map.assign_parameters(x1_features), inplace=True)
            
            # Применяем inverse feature map для x2
            qc.compose(
                feature_map.assign_parameters(x2_features).inverse(),
                inplace=True
            )
            
            qc.measure_all()
            circuits.append(qc)
            indices.append((i, j))
    
    # Оптимизация схем для ibm_fez
    print(f"Транспиляция {len(circuits)} схем для ibm_fez...")
    pm = generate_preset_pass_manager(
        optimization_level=2,  # Хороший баланс для реального QPU
        backend=backend
    )
    transpiled_circuits = pm.run(circuits)
    
    # Выполнение на квантовом компьютере ibm_fez
    print(f"Отправка задачи на {backend.name} (shots={shots})...")
    print("⏳ Ожидание выполнения на реальном квантовом компьютере...")
    
    sampler = Sampler(mode=backend)
    job = sampler.run(transpiled_circuits, shots=shots)
    
    # Показываем ID задачи для отслеживания
    print(f"Job ID: {job.job_id()}")
    print(f"Статус: {job.status()}")
    
    result = job.result()
    print("✅ Выполнение завершено!")
    
    # Обработка результатов
    for idx, (i, j) in enumerate(indices):
        counts = result[idx].data.meas.get_counts()
        # Вероятность измерить |00...0>
        zero_state = '0' * num_qubits
        prob_zero = counts.get(zero_state, 0) / shots
        kernel_matrix[i, j] = prob_zero
    
    return kernel_matrix

# ===== ШАГ 6: ВЫЧИСЛЕНИЕ МАТРИЦ ЯДРА =====
print("\n" + "="*60)
print("ВЫЧИСЛЕНИЕ КВАНТОВОГО ЯДРА НА IBM_FEZ")
print("="*60)

# Для реального QPU используем меньше shots для экономии времени
shots = 1024  # Минимум для приемлемой точности

import time
start_time = time.time()

# Вычисляем матрицу ядра для обучающих данных
print(f"\n🔬 Вычисление K_train ({len(X_train)}x{len(X_train)} = {len(X_train)**2} схем)...")
K_train = compute_kernel_matrix(X_train, X_train, feature_map, backend, shots)
train_time = time.time() - start_time
print(f"⏱️  Время: {train_time:.1f} секунд")

# Вычисляем матрицу ядра для тестовых данных
print(f"\n🔬 Вычисление K_test ({len(X_test)}x{len(X_train)} = {len(X_test)*len(X_train)} схем)...")
K_test = compute_kernel_matrix(X_test, X_train, feature_map, backend, shots)
test_time = time.time() - start_time - train_time
print(f"⏱️  Время: {test_time:.1f} секунд")

total_time = time.time() - start_time
print(f"\n✅ Все матрицы ядра готовы!")
print(f"📊 Общее время выполнения: {total_time:.1f} секунд ({total_time/60:.2f} минут)")
print(f"K_train shape: {K_train.shape}")
print(f"K_test shape: {K_test.shape}")

# ===== ШАГ 7: ОБУЧЕНИЕ SVM =====
print("\n=== ОБУЧЕНИЕ SVM КЛАССИФИКАТОРА ===")

# Используем SVM с предвычисленным ядром
svm = SVC(kernel='precomputed')
svm.fit(K_train, y_train)

# Предсказание
y_pred = svm.predict(K_test)

# Оценка точности
accuracy = accuracy_score(y_test, y_pred)
print(f"\nТочность на тестовой выборке: {accuracy:.2%}")

# ===== ШАГ 8: ВИЗУАЛИЗАЦИЯ =====
print("\n=== ВИЗУАЛИЗАЦИЯ РЕЗУЛЬТАТОВ ===")

import matplotlib.pyplot as plt

fig, axes = plt.subplots(1, 2, figsize=(12, 5))

# Визуализация матрицы ядра
im1 = axes[0].imshow(K_train, cmap='hot', interpolation='nearest')
axes[0].set_title('Матрица квантового ядра (Train)')
axes[0].set_xlabel('Образец j')
axes[0].set_ylabel('Образец i')
plt.colorbar(im1, ax=axes[0])

# Визуализация предсказаний
axes[1].scatter(range(len(y_test)), y_test, c='blue', 
                marker='o', label='Истинные метки', s=100)
axes[1].scatter(range(len(y_pred)), y_pred, c='red', 
                marker='x', label='Предсказания', s=100)
axes[1].set_title('Предсказания vs Истинные метки')
axes[1].set_xlabel('Индекс образца')
axes[1].set_ylabel('Класс')
axes[1].legend()
axes[1].grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('quantum_kernel_results.png', dpi=150, bbox_inches='tight')
print("График сохранён в 'quantum_kernel_results.png'")
plt.show()

# ===== ДОПОЛНИТЕЛЬНАЯ ИНФОРМАЦИЯ =====
print("\n=== ИТОГИ ===")
print(f"Общее количество схем выполнено: {len(X_train)**2 + len(X_test)*len(X_train)}")
print(f"Shots на схему: {shots}")
print(f"Точность классификации: {accuracy:.2%}")
print(f"\nСредние значения в матрице ядра:")
print(f"  K_train: min={K_train.min():.3f}, max={K_train.max():.3f}, mean={K_train.mean():.3f}")
print(f"  K_test: min={K_test.min():.3f}, max={K_test.max():.3f}, mean={K_test.mean():.3f}")

# ===== СОХРАНЕНИЕ РЕЗУЛЬТАТОВ =====
print("\n=== СОХРАНЕНИЕ РЕЗУЛЬТАТОВ ===")

import pickle
import json
from datetime import datetime

# Создаём папку для результатов
import os
results_dir = "quantum_kernel_results"
os.makedirs(results_dir, exist_ok=True)

timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")

# 1. Сохраняем матрицы ядра (numpy arrays)
np.save(f'{results_dir}/K_train_{timestamp}.npy', K_train)
np.save(f'{results_dir}/K_test_{timestamp}.npy', K_test)
print(f"✅ Матрицы ядра сохранены:")
print(f"   - {results_dir}/K_train_{timestamp}.npy")
print(f"   - {results_dir}/K_test_{timestamp}.npy")

# 2. Сохраняем данные и метки
np.save(f'{results_dir}/X_train_{timestamp}.npy', X_train)
np.save(f'{results_dir}/X_test_{timestamp}.npy', X_test)
np.save(f'{results_dir}/y_train_{timestamp}.npy', y_train)
np.save(f'{results_dir}/y_test_{timestamp}.npy', y_test)
print(f"✅ Данные и метки сохранены")

# 3. Сохраняем обученную модель SVM
with open(f'{results_dir}/svm_model_{timestamp}.pkl', 'wb') as f:
    pickle.dump(svm, f)
print(f"✅ Модель SVM сохранена: {results_dir}/svm_model_{timestamp}.pkl")

# 4. Сохраняем метаданные эксперимента
metadata = {
    'timestamp': timestamp,
    'backend': backend.name,
    'num_qubits': num_qubits,
    'shots': shots,
    'num_train_samples': len(X_train),
    'num_test_samples': len(X_test),
    'total_circuits': len(X_train)**2 + len(X_test)*len(X_train),
    'execution_time_seconds': total_time,
    'accuracy': float(accuracy),
    'feature_map': {
        'type': 'ZZFeatureMap',
        'reps': 1,
        'entanglement': 'linear'
    },
    'kernel_stats': {
        'K_train_min': float(K_train.min()),
        'K_train_max': float(K_train.max()),
        'K_train_mean': float(K_train.mean()),
        'K_test_min': float(K_test.min()),
        'K_test_max': float(K_test.max()),
        'K_test_mean': float(K_test.mean()),
    }
}

with open(f'{results_dir}/metadata_{timestamp}.json', 'w') as f:
    json.dump(metadata, f, indent=2)
print(f"✅ Метаданные сохранены: {results_dir}/metadata_{timestamp}.json")

# 5. Сохраняем график
plt.savefig(f'{results_dir}/results_{timestamp}.png', dpi=150, bbox_inches='tight')
print(f"✅ График сохранён: {results_dir}/results_{timestamp}.png")

print(f"\n📁 Все результаты в папке: {results_dir}/")
print("\n" + "="*60)
print("КАК ИСПОЛЬЗОВАТЬ СОХРАНЁННЫЕ ДАННЫЕ:")
print("="*60)
print("""
# Загрузить матрицы ядра:
import numpy as np
K_train = np.load('quantum_kernel_results/K_train_TIMESTAMP.npy')
K_test = np.load('quantum_kernel_results/K_test_TIMESTAMP.npy')

# Загрузить обученную модель:
import pickle
with open('quantum_kernel_results/svm_model_TIMESTAMP.pkl', 'rb') as f:
    svm = pickle.load(f)

# Использовать для новых предсказаний:
# 1. Вычислите квантовое ядро для новых данных X_new
# 2. predictions = svm.predict(K_new)

# Загрузить метаданные:
import json
with open('quantum_kernel_results/metadata_TIMESTAMP.json', 'r') as f:
    metadata = json.load(f)
    print(f"Точность модели: {metadata['accuracy']}")
""")

# СОВЕТЫ ПО ОПТИМИЗАЦИИ ДЛЯ IBM_FEZ:
print("\n" + "="*60)
print("ИСПОЛЬЗОВАНО НА IBM_FEZ:")
print("="*60)
print(f"✅ Образцов данных: {len(X_train) + len(X_test)}")
print(f"✅ Всего схем выполнено: {len(X_train)**2 + len(X_test)*len(X_train)}")
print(f"✅ Shots на схему: {shots}")
print(f"✅ Общее время: {total_time/60:.2f} минут")
remaining = 8 - total_time/60
print(f"✅ Оставшееся время: ~{remaining:.2f} минут")
print(f"\n📈 Статистика:")
print(f"   Скорость: ~{(len(X_train)**2 + len(X_test)*len(X_train)) / total_time:.1f} схем/сек")
print(f"   Среднее время на схему: ~{total_time / (len(X_train)**2 + len(X_test)*len(X_train)):.2f} сек")
if remaining > 0:
    print(f"\n💡 Времени хватило! Можно было выполнить ещё ~{int(remaining * 60 / (total_time / (len(X_train)**2 + len(X_test)*len(X_train))))} схем")