quantum_kernel_training.py

"""
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)