Delete quantum_kernel.py

quantum_kernel.py

@@ -1,376 +0,0 @@
-"""
-Быстрое создание квантового ядра для 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))))} схем")