Upload quantum_kernel_training.py: Quantum kernel training script

quantum_kernel_training.py

@@ -0,0 +1,414 @@
+"""
+Quantum-VibeThinker Hybrid Model - Proof of Concept
+====================================================
+Гибридная квантово-классическая модель для анализа текста
+
+Архитектура:
+1. VibeThinker-1.5B → извлечение embeddings
+2. PCA сжатие → 4D для квантового слоя
+3. Квантовое ядро → вычисление похожести
+4. SVM классификатор → финальное решение
+
+Требования:
+- MacBook Pro M4 (16GB RAM)
+- transformers, torch, qiskit, sklearn
+"""
+
+import numpy as np
+import torch
+import time
+import json
+from pathlib import Path
+
+print("="*70)
+print("🧠 QUANTUM-VIBTHINKER HYBRID MODEL")
+print("="*70)
+print("\n💻 Платформа: MacBook Pro M4")
+print("🔬 Режим: Proof of Concept\n")
+
+# ===== ШАГ 1: ПРОВЕРКА ОКРУЖЕНИЯ =====
+print("="*70)
+print("ШАГ 1/8: ПРОВЕРКА ОКРУЖЕНИЯ")
+print("="*70)
+
+# Проверка устройства
+if torch.backends.mps.is_available():
+    device = torch.device("mps")  # M4 GPU
+    print("✅ Metal Performance Shaders доступен (M4 GPU)")
+elif torch.cuda.is_available():
+    device = torch.device("cuda")
+    print("✅ CUDA доступен")
+else:
+    device = torch.device("cpu")
+    print("⚠️  Используем CPU")
+
+print(f"🎯 Устройство: {device}")
+
+# ===== ШАГ 2: ЗАГРУЗКА VIBTHINKER =====
+print("\n" + "="*70)
+print("ШАГ 2/8: ЗАГРУЗКА VIBTHINKER-1.5B")
+print("="*70)
+
+try:
+    from transformers import AutoModel, AutoTokenizer
+    
+    print("📥 Загрузка модели (может занять 1-2 минуты)...")
+    start = time.time()
+    
+    model_name = "WeiboAI/VibeThinker-1.5B"
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    model = AutoModel.from_pretrained(
+        model_name,
+        torch_dtype=torch.float16  # FP16 для экономии памяти на M4
+    )
+    model.to(device)
+    model.eval()
+    
+    load_time = time.time() - start
+    print(f"✅ VibeThinker загружен за {load_time:.1f} сек")
+    print(f"📊 Параметры: ~1.5B")
+    print(f"💾 Память: ~3GB на M4")
+    
+except Exception as e:
+    print(f"❌ Ошибка загрузки VibeThinker: {e}")
+    print("\n💡 Установите: pip install transformers torch")
+    exit(1)
+
+# ===== ШАГ 3: ПОДГОТОВКА ДАННЫХ =====
+print("\n" + "="*70)
+print("ШАГ 3/8: ПОДГОТОВКА ТЕСТОВЫХ ДАННЫХ")
+print("="*70)
+
+# Датасет для sentiment analysis
+texts_train = [
+    "I absolutely love quantum computing! It's amazing!",
+    "This is the worst experience ever, terrible.",
+    "Quantum neural networks are fascinating and powerful.",
+    "I hate bugs in my code, so frustrating!",
+    "The future of AI is quantum, incredible potential!",
+    "This product is garbage, waste of money.",
+    "Machine learning combined with quantum is brilliant!",
+    "Awful customer service, never coming back."
+]
+
+labels_train = [1, 0, 1, 0, 1, 0, 1, 0]  # 1=positive, 0=negative
+
+texts_test = [
+    "Quantum algorithms are revolutionary!",
+    "This is horrible, I'm disappointed.",
+    "Amazing breakthrough in quantum ML!",
+    "Terrible quality, very bad."
+]
+
+labels_test = [1, 0, 1, 0]
+
+print(f"✅ Обучающая выборка: {len(texts_train)} образцов")
+print(f"✅ Тестовая выборка: {len(texts_test)} образцов")
+print(f"\nПримеры:")
+for i in range(2):
+    label = "😊 Positive" if labels_train[i] == 1 else "😞 Negative"
+    print(f"  {label}: '{texts_train[i][:50]}...'")
+
+# ===== ШАГ 4: ИЗВЛЕЧЕНИЕ EMBEDDINGS =====
+print("\n" + "="*70)
+print("ШАГ 4/8: ИЗВЛЕЧЕНИЕ EMBEDDINGS ЧЕРЕЗ VIBTHINKER")
+print("="*70)
+
+def get_embeddings(texts, model, tokenizer, device):
+    """Извлекает embeddings из VibeThinker"""
+    embeddings = []
+    
+    print(f"🔄 Обработка {len(texts)} текстов...")
+    start = time.time()
+    
+    with torch.no_grad():
+        for i, text in enumerate(texts):
+            # Токенизация
+            inputs = tokenizer(
+                text, 
+                return_tensors="pt", 
+                padding=True, 
+                truncation=True,
+                max_length=128
+            ).to(device)
+            
+            # Прогон через модель
+            outputs = model(**inputs)
+            
+            # Усреднение по токенам
+            embedding = outputs.last_hidden_state.mean(dim=1).cpu().numpy()[0]
+            embeddings.append(embedding)
+            
+            if (i + 1) % 4 == 0:
+                print(f"  Обработано: {i + 1}/{len(texts)}")
+    
+    elapsed = time.time() - start
+    print(f"✅ Готово за {elapsed:.1f} сек ({elapsed/len(texts):.2f} сек/текст)")
+    
+    return np.array(embeddings)
+
+# Извлечение embeddings
+X_train_emb = get_embeddings(texts_train, model, tokenizer, device)
+X_test_emb = get_embeddings(texts_test, model, tokenizer, device)
+
+print(f"\n📊 Размерность embeddings: {X_train_emb.shape[1]}D")
+print(f"   Train: {X_train_emb.shape}")
+print(f"   Test: {X_test_emb.shape}")
+
+# ===== ШАГ 5: СЖАТИЕ ДО 4D ДЛЯ КВАНТОВОГО СЛОЯ =====
+print("\n" + "="*70)
+print("ШАГ 5/8: СЖАТИЕ РАЗМЕРНОСТИ (PCA)")
+print("="*70)
+
+from sklearn.decomposition import PCA
+
+# Сжимаем до 4D для 2-кубитной QNN
+pca = PCA(n_components=4)
+X_train_4d = pca.fit_transform(X_train_emb)
+X_test_4d = pca.transform(X_test_emb)
+
+print(f"✅ Сжатие: {X_train_emb.shape[1]}D → 4D")
+print(f"📊 Объяснённая дисперсия: {pca.explained_variance_ratio_.sum():.1%}")
+print(f"   Компоненты: {pca.explained_variance_ratio_}")
+
+# Нормализация для квантовых гейтов [0, 2π]
+X_train_norm = (X_train_4d - X_train_4d.min()) / (X_train_4d.max() - X_train_4d.min()) * 2 * np.pi
+X_test_norm = (X_test_4d - X_train_4d.min()) / (X_train_4d.max() - X_train_4d.min()) * 2 * np.pi
+
+print(f"✅ Нормализация: [0, 2π] для квантовых углов")
+
+# ===== ШАГ 6: КВАНТОВОЕ ЯДРО =====
+print("\n" + "="*70)
+print("ШАГ 6/8: ВЫЧИСЛЕНИЕ КВАНТОВОГО ЯДРА")
+print("="*70)
+
+from qiskit import QuantumCircuit
+from qiskit.circuit import ParameterVector
+from qiskit.primitives import StatevectorSampler
+
+def quantum_kernel(X1, X2):
+    """
+    Вычисляет квантовую матрицу ядра
+    Использует 2-кубитную схему с запутыванием
+    """
+    n1, n2 = len(X1), len(X2)
+    kernel_matrix = np.zeros((n1, n2))
+    
+    # Создаём схему
+    input_params = ParameterVector('x', 4)
+    qc = QuantumCircuit(2)
+    
+    # Кодирование данных
+    qc.ry(input_params[0], 0)
+    qc.ry(input_params[1], 1)
+    
+    # Запутывание
+    qc.cx(0, 1)
+    
+    # Вариационный слой
+    qc.ry(input_params[2], 0)
+    qc.ry(input_params[3], 1)
+    
+    # Ещё запутывание
+    qc.cx(1, 0)
+    
+    qc.measure_all()
+    
+    sampler = StatevectorSampler()
+    
+    print(f"🔄 Вычисление {n1}×{n2} = {n1*n2} элементов матрицы...")
+    start = time.time()
+    
+    for i in range(n1):
+        for j in range(n2):
+            # Создаём overlap circuit
+            qc1 = qc.assign_parameters({
+                input_params[0]: X1[i][0],
+                input_params[1]: X1[i][1],
+                input_params[2]: X1[i][2],
+                input_params[3]: X1[i][3]
+            })
+            
+            qc2 = qc.assign_parameters({
+                input_params[0]: X2[j][0],
+                input_params[1]: X2[j][1],
+                input_params[2]: X2[j][2],
+                input_params[3]: X2[j][3]
+            })
+            
+            # Overlap = вероятность измерить |00>
+            result1 = sampler.run([qc1], shots=500).result()
+            counts1 = result1[0].data.meas.get_counts()
+            
+            result2 = sampler.run([qc2], shots=500).result()
+            counts2 = result2[0].data.meas.get_counts()
+            
+            # Фиделити через dot product распределений
+            fidelity = sum(np.sqrt(counts1.get(k, 0) * counts2.get(k, 0)) 
+                          for k in set(counts1) | set(counts2)) / 500
+            
+            kernel_matrix[i, j] = fidelity
+    
+    elapsed = time.time() - start
+    print(f"✅ Квантовое ядро вычислено за {elapsed:.1f} сек")
+    
+    return kernel_matrix
+
+# Вычисление матриц ядра
+print("\n📊 Вычисление K_train...")
+K_train = quantum_kernel(X_train_norm, X_train_norm)
+
+print("\n📊 Вычисление K_test...")
+K_test = quantum_kernel(X_test_norm, X_train_norm)
+
+print(f"\n✅ Матрицы квантового ядра готовы!")
+print(f"   K_train: {K_train.shape}")
+print(f"   K_test: {K_test.shape}")
+print(f"   Среднее значение: {K_train.mean():.3f}")
+
+# ===== ШАГ 7: ОБУЧЕНИЕ И ТЕСТИРОВАНИЕ =====
+print("\n" + "="*70)
+print("ШАГ 7/8: ОБУЧЕНИЕ ГИБРИДНОЙ МОДЕЛИ")
+print("="*70)
+
+from sklearn.svm import SVC
+from sklearn.metrics import accuracy_score, classification_report
+
+# Baseline: Классический SVM на embeddings
+print("\n1️⃣ BASELINE: VibeThinker + Linear SVM")
+svm_baseline = SVC(kernel='linear')
+svm_baseline.fit(X_train_emb, labels_train)
+pred_baseline = svm_baseline.predict(X_test_emb)
+acc_baseline = accuracy_score(labels_test, pred_baseline)
+print(f"   Точность: {acc_baseline:.1%}")
+
+# Hybrid: Квантовое ядро
+print("\n2️⃣ HYBRID: VibeThinker + Quantum Kernel + SVM")
+svm_quantum = SVC(kernel='precomputed')
+svm_quantum.fit(K_train, labels_train)
+pred_quantum = svm_quantum.predict(K_test)
+acc_quantum = accuracy_score(labels_test, pred_quantum)
+print(f"   Точность: {acc_quantum:.1%}")
+
+# Сравнение
+print("\n" + "="*70)
+print("📊 СРАВНЕНИЕ МОДЕЛЕЙ")
+print("="*70)
+print(f"Baseline (Classical):  {acc_baseline:.1%}")
+print(f"Hybrid (Quantum):      {acc_quantum:.1%}")
+improvement = (acc_quantum - acc_baseline) * 100
+if improvement > 0:
+    print(f"🎉 Квантовая модель лучше на {improvement:+.1f}%!")
+elif improvement < 0:
+    print(f"⚖️  Классическая модель лучше на {-improvement:.1f}%")
+else:
+    print(f"⚖️  Одинаковая точность")
+
+# Детальный отчёт
+print("\n📋 Детальный отчёт (Quantum Hybrid):")
+print(classification_report(labels_test, pred_quantum, 
+                            target_names=['Negative', 'Positive']))
+
+# ===== ШАГ 8: ВИЗУАЛИЗАЦИЯ И СОХРАНЕНИЕ =====
+print("\n" + "="*70)
+print("ШАГ 8/8: ВИЗУАЛИЗАЦИЯ И СОХРАНЕНИЕ")
+print("="*70)
+
+import matplotlib.pyplot as plt
+
+# График 1: Сравнение точности
+fig, axes = plt.subplots(1, 3, figsize=(15, 4))
+
+# 1. Точность моделей
+models = ['Classical\n(Baseline)', 'Quantum\n(Hybrid)']
+accuracies = [acc_baseline, acc_quantum]
+colors = ['blue', 'red']
+
+axes[0].bar(models, accuracies, color=colors, alpha=0.7)
+axes[0].set_ylabel('Accuracy')
+axes[0].set_ylim([0, 1])
+axes[0].set_title('Model Comparison')
+axes[0].grid(True, alpha=0.3)
+
+# 2. Квантовая матрица ядра
+im = axes[1].imshow(K_train, cmap='hot', aspect='auto')
+axes[1].set_title('Quantum Kernel Matrix')
+axes[1].set_xlabel('Sample j')
+axes[1].set_ylabel('Sample i')
+plt.colorbar(im, ax=axes[1])
+
+# 3. Предсказания
+x_pos = np.arange(len(labels_test))
+axes[2].scatter(x_pos, labels_test, c='blue', s=200, alpha=0.5, 
+                marker='o', label='True')
+axes[2].scatter(x_pos, pred_quantum, c='red', s=100, 
+                marker='x', label='Predicted')
+axes[2].set_title('Predictions (Quantum Hybrid)')
+axes[2].set_xlabel('Test Sample')
+axes[2].set_ylabel('Class')
+axes[2].set_yticks([0, 1])
+axes[2].set_yticklabels(['Negative', 'Positive'])
+axes[2].legend()
+axes[2].grid(True, alpha=0.3)
+
+plt.tight_layout()
+plt.savefig('quantum_vibthinker_results.png', dpi=150, bbox_inches='tight')
+print("✅ График сохранён: quantum_vibthinker_results.png")
+
+# Сохранение результатов
+results = {
+    'model': 'Quantum-VibeThinker Hybrid',
+    'platform': 'MacBook Pro M4',
+    'vibthinker_model': model_name,
+    'quantum_qubits': 2,
+    'embedding_dim': X_train_emb.shape[1],
+    'compressed_dim': 4,
+    'accuracy_baseline': float(acc_baseline),
+    'accuracy_quantum': float(acc_quantum),
+    'improvement': float(improvement),
+    'train_samples': len(texts_train),
+    'test_samples': len(texts_test),
+    'predictions': {
+        'true_labels': labels_test,
+        'quantum_predictions': pred_quantum.tolist(),
+        'baseline_predictions': pred_baseline.tolist()
+    }
+}
+
+with open('quantum_vibthinker_results.json', 'w') as f:
+    json.dump(results, f, indent=2)
+print("✅ Результаты сохранены: quantum_vibthinker_results.json")
+
+# Сохранение матриц ядра
+np.save('K_train_quantum.npy', K_train)
+np.save('K_test_quantum.npy', K_test)
+print("✅ Квантовые ядра сохранены: K_*.npy")
+
+# ===== ФИНАЛЬНЫЙ ОТЧЁТ =====
+print("\n" + "="*70)
+print("🎉 PROOF OF CONCEPT ЗАВЕРШЁН!")
+print("="*70)
+
+print("\n📊 ИТОГИ:")
+print(f"   ✅ VibeThinker-1.5B загружен на M4")
+print(f"   ✅ Embeddings извлечены ({X_train_emb.shape[1]}D)")
+print(f"   ✅ Квантовое ядро вычислено (2 кубита)")
+print(f"   ✅ Гибридная модель обучена")
+print(f"   ✅ Точность: {acc_quantum:.1%}")
+
+print(f"\n💾 СОХРАНЕНО:")
+print(f"   - quantum_vibthinker_results.png (визуализация)")
+print(f"   - quantum_vibthinker_results.json (метрики)")
+print(f"   - K_train_quantum.npy (матрица ядра)")
+print(f"   - K_test_quantum.npy (матрица ядра)")
+
+print(f"\n🚀 СЛЕДУЮЩИЕ ШАГИ:")
+print(f"   1. Увеличить количество данных")
+print(f"   2. Попробовать разные квантовые схемы")
+print(f"   3. Добавить больше кубитов (3-4)")
+print(f"   4. Оптимизировать параметры квантового слоя")
+print(f"   5. Сравнить с другими базовыми моделями")
+
+print("\n" + "="*70)
+print("✨ Ваша первая Quantum-Classical Hybrid модел�� готова!")
+print("="*70)