436 lines
15 KiB
Python
436 lines
15 KiB
Python
import numpy as np
|
|
import pandas as pd
|
|
import os
|
|
import sys
|
|
import time
|
|
from datetime import datetime
|
|
import json
|
|
import gc
|
|
import signal
|
|
import multiprocessing
|
|
from multiprocessing import Pool
|
|
|
|
# Import bibliotek kwantowych
|
|
from qiskit import Aer
|
|
from qiskit.circuit.library import ZZFeatureMap, PauliFeatureMap, EfficientSU2
|
|
from qiskit_machine_learning.kernels import QuantumKernel
|
|
from qiskit_machine_learning.algorithms import QSVC
|
|
import dimod
|
|
|
|
# Dodanie zalecanego zamiennika dla ZZFeatureMap
|
|
from qiskit.circuit import QuantumCircuit, Parameter
|
|
from qiskit.circuit.library.data_preparation import ZFeatureMap
|
|
|
|
# Dodanie bibliotek do kodowania amplitudowego
|
|
from qiskit.circuit import QuantumCircuit
|
|
from qiskit.extensions import Initialize
|
|
import scipy.linalg as la
|
|
|
|
# Dodanie biblioteki UMAP
|
|
import umap
|
|
|
|
# Maksymalny czas trwania eksperymentu
|
|
MAX_EXECUTION_TIME = 24 * 60 * 60 * 7 * 3
|
|
|
|
def timeout_handler(signum, frame):
|
|
print("\n\n======= PRZEKROCZONO MAKSYMALNY CZAS WYKONANIA =======")
|
|
print(f"Eksperyment został przerwany po {MAX_EXECUTION_TIME/3600:.1f} godzinach.")
|
|
sys.exit(1)
|
|
|
|
# Ustawienie obsługi sygnału
|
|
signal.signal(signal.SIGALRM, timeout_handler)
|
|
signal.alarm(MAX_EXECUTION_TIME)
|
|
|
|
# ----------------- CZĘŚĆ 0: PARAMETRY KONFIGURACYJNE -----------------
|
|
|
|
# Parametry danych
|
|
DATA_FILES = [
|
|
'dane/TCGA_GBM_LGG_Mutations_all.csv',
|
|
'dane/zaszumione_rozszerzone/TCGA_GBM_LGG_Mutations_noise_1percent_added.csv',
|
|
'dane/zaszumione_rozszerzone/TCGA_GBM_LGG_Mutations_noise_5percent_added.csv',
|
|
'dane/zaszumione_rozszerzone/TCGA_GBM_LGG_Mutations_noise_10percent_added.csv',
|
|
'dane/zaszumione_rozszerzone/TCGA_GBM_LGG_Mutations_noise_15percent_added.csv',
|
|
'dane/zaszumione_rozszerzone/TCGA_GBM_LGG_Mutations_noise_20percent_added.csv',
|
|
'dane/zaszumione/TCGA_GBM_LGG_Mutations_noise_1percent_substituted.csv',
|
|
'dane/zaszumione/TCGA_GBM_LGG_Mutations_noise_5percent_substituted.csv',
|
|
'dane/zaszumione/TCGA_GBM_LGG_Mutations_noise_10percent_substituted.csv',
|
|
'dane/zaszumione/TCGA_GBM_LGG_Mutations_noise_15percent_substituted.csv',
|
|
'dane/zaszumione/TCGA_GBM_LGG_Mutations_noise_20percent_substituted.csv'
|
|
]
|
|
TEST_SIZE = 0.3
|
|
RANDOM_STATE = 42
|
|
|
|
# Parametry redukcji wymiarowości
|
|
USE_PCA = True
|
|
USE_TSNE = False
|
|
USE_UMAP = False
|
|
PCA_COMPONENTS = 14
|
|
TSNE_COMPONENTS = 3
|
|
TSNE_PERPLEXITY = 100
|
|
TSNE_LEARNING_RATE = 50
|
|
TSNE_MAX_ITER = 1000
|
|
UMAP_COMPONENTS = 14
|
|
UMAP_NEIGHBORS = 15
|
|
UMAP_MIN_DIST = 0.8
|
|
UMAP_METRIC = 'euclidean'
|
|
EVALUATE_SILHOUETTE = False
|
|
OPTIMAL_SILHOUETTE_SCORE = 0.1964
|
|
|
|
# Wybór eksperymentów do przeprowadzenia
|
|
RUN_CLASSIC_SVM = True
|
|
RUN_QUANTUM_SVM = True
|
|
RUN_HYBRID_APPROACH = True
|
|
|
|
# Parametry klasycznego SVM
|
|
SVM_PARAM_GRID = {
|
|
'C': [0.1, 1, 10, 100],
|
|
'gamma': ['scale', 'auto', 0.1, 0.01],
|
|
'kernel': ['linear', 'rbf', 'poly']
|
|
}
|
|
SVM_CV = 5
|
|
|
|
# Parametry kwantowego SVM
|
|
BACKEND_NAME = 'qasm_simulator'
|
|
C_VALUES = [0.1, 1.0, 10.0]
|
|
QSVM_CV = 10
|
|
|
|
# Parametry wyżarzania kwantowego
|
|
NUM_READS = 100
|
|
QUBO_PENALTY = 10.0
|
|
|
|
# Parametry analizy cech
|
|
IMPORTANCE_THRESHOLD = 0.01
|
|
|
|
# Parametry wyjściowe
|
|
OUTPUT_DIR = f'wyniki/2025-08-04-dim_reduction-{QSVM_CV}-fold'
|
|
|
|
# Parametry IBM Quantum Cloud
|
|
USE_IBM_QUANTUM = False
|
|
IBM_BACKEND = 'qasm_simulator'
|
|
IBM_REAL_BACKEND = 'qasm_simulator'
|
|
IBM_TOKEN = None
|
|
IBM_INSTANCE = None
|
|
IBM_MAX_SHOTS = 1024
|
|
IBM_OPTIMIZATION_LEVEL = 1
|
|
IBM_RESILIENCE_LEVEL = 1
|
|
|
|
# Upewnij się, że katalog wyjściowy istnieje
|
|
if not os.path.exists(OUTPUT_DIR):
|
|
os.makedirs(OUTPUT_DIR)
|
|
|
|
# Przekierowanie wyjścia do pliku i konsoli
|
|
class Logger:
|
|
def __init__(self, filename):
|
|
self.terminal = sys.stdout
|
|
self.log = open(filename, 'w', encoding='utf-8')
|
|
|
|
def write(self, message):
|
|
self.terminal.write(message)
|
|
self.log.write(message)
|
|
self.log.flush()
|
|
|
|
def flush(self):
|
|
self.terminal.flush()
|
|
self.log.flush()
|
|
|
|
def close(self):
|
|
self.log.close()
|
|
|
|
# Funkcja do zapisywania szczegółowych metryk
|
|
def save_metrics(y_true, y_pred, model_name):
|
|
from sklearn.metrics import classification_report, confusion_matrix, roc_auc_score, accuracy_score, precision_score, recall_score, f1_score
|
|
|
|
accuracy = accuracy_score(y_true, y_pred)
|
|
precision = precision_score(y_true, y_pred, average='weighted', zero_division=0)
|
|
recall = recall_score(y_true, y_pred, average='weighted', zero_division=0)
|
|
f1 = f1_score(y_true, y_pred, average='weighted', zero_division=0)
|
|
|
|
try:
|
|
roc_auc = roc_auc_score(y_true, y_pred)
|
|
except:
|
|
roc_auc = "N/A"
|
|
|
|
print(f"\nSzczegółowe metryki dla modelu {model_name}:")
|
|
print(f"Accuracy: {accuracy:.4f}")
|
|
print(f"Precision: {precision:.4f}")
|
|
print(f"Recall: {recall:.4f}")
|
|
print(f"F1 Score: {f1:.4f}")
|
|
print(f"ROC AUC: {roc_auc}")
|
|
|
|
cm = confusion_matrix(y_true, y_pred)
|
|
print("\nMacierz pomyłek:")
|
|
print(cm)
|
|
|
|
return {
|
|
'accuracy': accuracy,
|
|
'precision': precision,
|
|
'recall': recall,
|
|
'f1': f1,
|
|
'roc_auc': roc_auc,
|
|
'confusion_matrix': cm.tolist()
|
|
}
|
|
|
|
# Funkcja do zapisywania wyników pośrednich
|
|
def save_results_cache(results_dict, cache_file):
|
|
with open(cache_file, 'w') as f:
|
|
json.dump(results_dict, f)
|
|
|
|
# Funkcja do wczytywania wyników pośrednich
|
|
def load_results_cache(cache_file):
|
|
if os.path.exists(cache_file):
|
|
try:
|
|
with open(cache_file, 'r') as f:
|
|
return json.load(f)
|
|
except:
|
|
print("Nie udało się wczytać pliku cache. Tworzenie nowego.")
|
|
return {
|
|
'quantum_results': [],
|
|
'quantum_times': {},
|
|
'completed_feature_maps': [],
|
|
'hybrid_scores': {},
|
|
'hybrid_eval_times': {}
|
|
}
|
|
|
|
# Funkcja do inicjalizacji lokalnego symulatora
|
|
def initialize_ibm_quantum():
|
|
print("\n======= INICJALIZACJA LOKALNEGO SYMULATORA =======")
|
|
print("IBM Quantum Cloud wyłączone - używanie lokalnego symulatora")
|
|
|
|
try:
|
|
backend = Aer.get_backend('qasm_simulator')
|
|
print("✓ Zainicjalizowano lokalny symulator Qiskit Aer")
|
|
print(f"✓ Backend: {backend.name}")
|
|
|
|
return None, backend, True
|
|
|
|
except Exception as e:
|
|
print(f"BŁĄD podczas inicjalizacji lokalnego symulatora: {str(e)}")
|
|
return None, None, False
|
|
|
|
# Funkcja do przygotowania danych
|
|
def prepare_data(data_file):
|
|
from sklearn.model_selection import train_test_split
|
|
from sklearn.preprocessing import StandardScaler
|
|
from sklearn.decomposition import PCA
|
|
from sklearn.manifold import TSNE
|
|
from sklearn.metrics import silhouette_score
|
|
|
|
print(f"\n======= PRZYGOTOWANIE DANYCH =======")
|
|
start_time_data = time.time()
|
|
|
|
# Wczytanie danych
|
|
data = pd.read_csv(data_file)
|
|
print(f"Wymiary oryginalnych danych: {data.shape}")
|
|
|
|
# Wydzielenie zmiennej docelowej
|
|
y = data['Primary_Diagnosis']
|
|
print(f"Unikalne wartości zmiennej docelowej: {y.unique()}")
|
|
print(f"Rozkład klas: {y.value_counts().to_dict()}")
|
|
|
|
# Usunięcie kolumn identyfikacyjnych
|
|
id_columns = ['Project', 'Case_ID']
|
|
data_processed = data.drop(id_columns + ['Grade'], axis=1)
|
|
print(f"Wymiary danych po usunięciu kolumn identyfikacyjnych: {data_processed.shape}")
|
|
|
|
# Przekształcenie kolumn kategorycznych na binarne
|
|
print("Przekształcanie kolumn kategorycznych na binarne...")
|
|
categorical_columns = data_processed.select_dtypes(include=['object']).columns.tolist()
|
|
print(f"Kolumny kategoryczne do przekształcenia: {categorical_columns}")
|
|
|
|
# Przekształcenie każdej kolumny kategorycznej
|
|
for col in categorical_columns:
|
|
unique_values = data_processed[col].unique()
|
|
print(f"Kolumna {col} zawiera wartości: {unique_values}")
|
|
|
|
if len(unique_values) == 2:
|
|
if set(unique_values) == {'Yes', 'No'}:
|
|
data_processed[col] = data_processed[col].map({'Yes': 1, 'No': 0})
|
|
elif set(unique_values) == {'Male', 'Female'}:
|
|
data_processed[col] = data_processed[col].map({'Male': 1, 'Female': 0})
|
|
elif set(unique_values) == {'GBM', 'LGG'}:
|
|
data_processed[col] = data_processed[col].map({'GBM': 1, 'LGG': 0})
|
|
else:
|
|
data_processed[col] = pd.factorize(data_processed[col])[0]
|
|
else:
|
|
try:
|
|
data_processed[col] = pd.to_numeric(data_processed[col], errors='raise')
|
|
print(f"Kolumna {col} została przekształcona na liczbową.")
|
|
except:
|
|
print(f"Kolumna {col} zostanie zakodowana jako one-hot.")
|
|
dummies = pd.get_dummies(data_processed[col], prefix=col, drop_first=True)
|
|
data_processed = pd.concat([data_processed, dummies], axis=1)
|
|
data_processed.drop(col, axis=1, inplace=True)
|
|
|
|
# Sprawdzenie, czy wszystkie dane są numeryczne
|
|
non_numeric = data_processed.select_dtypes(include=['object']).columns.tolist()
|
|
if non_numeric:
|
|
print(f"UWAGA: Pozostały kolumny nieliczbowe: {non_numeric}")
|
|
print("Usuwanie pozostałych kolumn nieliczbowych...")
|
|
data_processed = data_processed.drop(non_numeric, axis=1)
|
|
|
|
print(f"Wymiary danych po przekształceniu: {data_processed.shape}")
|
|
|
|
# Wypełnienie brakujących wartości
|
|
if data_processed.isnull().sum().sum() > 0:
|
|
print("Wypełnianie brakujących wartości...")
|
|
data_processed.fillna(data_processed.mean(), inplace=True)
|
|
|
|
# Przygotowanie danych do modelowania
|
|
X = data_processed.values
|
|
print(f"Wymiary danych wejściowych: {X.shape}")
|
|
|
|
# Przetwarzanie cech
|
|
scaler = StandardScaler()
|
|
X_scaled = scaler.fit_transform(X)
|
|
print(f"Wymiary danych po skalowaniu: {X_scaled.shape}")
|
|
|
|
# Redukcja wymiarowości
|
|
print("\n======= REDUKCJA WYMIAROWOŚCI =======")
|
|
|
|
# Przygotowanie różnych wersji zredukowanych danych
|
|
X_reduced_versions = {}
|
|
|
|
if USE_PCA:
|
|
pca_components = min(PCA_COMPONENTS, X_scaled.shape[1])
|
|
print(f"Liczba komponentów PCA: {pca_components}")
|
|
pca = PCA(n_components=pca_components)
|
|
X_reduced_pca = pca.fit_transform(X_scaled)
|
|
print(f"Wymiary danych po redukcji PCA: {X_reduced_pca.shape}")
|
|
print(f"Wyjaśniona wariancja: {sum(pca.explained_variance_ratio_):.4f}")
|
|
X_reduced_versions['pca'] = X_reduced_pca
|
|
|
|
if USE_TSNE:
|
|
print(f"\nStosowanie t-SNE na danych skalowanych...")
|
|
tsne = TSNE(
|
|
n_components=TSNE_COMPONENTS,
|
|
perplexity=TSNE_PERPLEXITY,
|
|
learning_rate=TSNE_LEARNING_RATE,
|
|
n_iter=TSNE_MAX_ITER,
|
|
random_state=RANDOM_STATE
|
|
)
|
|
tsne_start_time = time.time()
|
|
X_reduced_tsne = tsne.fit_transform(X_scaled)
|
|
tsne_end_time = time.time()
|
|
tsne_time = tsne_end_time - tsne_start_time
|
|
print(f"Wymiary danych po redukcji t-SNE: {X_reduced_tsne.shape}")
|
|
print(f"Czas wykonania t-SNE: {tsne_time:.2f} sekund")
|
|
|
|
if EVALUATE_SILHOUETTE:
|
|
try:
|
|
silhouette_avg = silhouette_score(X_reduced_tsne, y)
|
|
print(f"Silhouette Score dla t-SNE: {silhouette_avg:.4f}")
|
|
except Exception as e:
|
|
print(f"Nie udało się obliczyć Silhouette Score: {str(e)}")
|
|
|
|
X_reduced_versions['tsne'] = X_reduced_tsne
|
|
|
|
if USE_UMAP:
|
|
print(f"\nStosowanie UMAP na danych skalowanych...")
|
|
umap_reducer = umap.UMAP(
|
|
n_components=UMAP_COMPONENTS,
|
|
n_neighbors=UMAP_NEIGHBORS,
|
|
min_dist=UMAP_MIN_DIST,
|
|
metric=UMAP_METRIC,
|
|
random_state=RANDOM_STATE
|
|
)
|
|
umap_start_time = time.time()
|
|
X_reduced_umap = umap_reducer.fit_transform(X_scaled)
|
|
umap_end_time = time.time()
|
|
umap_time = umap_end_time - umap_start_time
|
|
print(f"Wymiary danych po redukcji UMAP: {X_reduced_umap.shape}")
|
|
print(f"Czas wykonania UMAP: {umap_time:.2f} sekund")
|
|
|
|
if EVALUATE_SILHOUETTE:
|
|
try:
|
|
silhouette_avg_umap = silhouette_score(X_reduced_umap, y)
|
|
print(f"Silhouette Score dla UMAP: {silhouette_avg_umap:.4f}")
|
|
except Exception as e:
|
|
print(f"Nie udało się obliczyć Silhouette Score dla UMAP: {str(e)}")
|
|
|
|
X_reduced_versions['umap'] = X_reduced_umap
|
|
|
|
# Wybór domyślnej wersji zredukowanych danych
|
|
if 'pca' in X_reduced_versions:
|
|
X_reduced = X_reduced_versions['pca']
|
|
print("Używanie danych zredukowanych przez PCA jako domyślnych.")
|
|
elif 'umap' in X_reduced_versions:
|
|
X_reduced = X_reduced_versions['umap']
|
|
print("Używanie danych zredukowanych przez UMAP jako domyślnych.")
|
|
elif 'tsne' in X_reduced_versions:
|
|
X_reduced = X_reduced_versions['tsne']
|
|
print("Używanie danych zredukowanych przez t-SNE jako domyślnych.")
|
|
else:
|
|
X_reduced = X_scaled
|
|
print("Nie wybrano żadnej metody redukcji wymiarowości. Używanie oryginalnych danych skalowanych.")
|
|
|
|
# Podział na zbiory treningowy i testowy
|
|
X_train_reduced, X_test_reduced, y_train, y_test = train_test_split(
|
|
X_reduced, y, test_size=TEST_SIZE, random_state=RANDOM_STATE
|
|
)
|
|
|
|
# Podział dla oryginalnych danych
|
|
X_train, X_test, _, _ = train_test_split(X, y, test_size=TEST_SIZE, random_state=RANDOM_STATE)
|
|
|
|
print(f"Wymiary zbioru treningowego: {X_train_reduced.shape}")
|
|
print(f"Wymiary zbioru testowego: {X_test_reduced.shape}")
|
|
|
|
end_time_data = time.time()
|
|
data_preparation_time = end_time_data - start_time_data
|
|
print(f"\nCzas przygotowania danych: {data_preparation_time:.2f} sekund")
|
|
|
|
return {
|
|
'X_train': X_train,
|
|
'X_test': X_test,
|
|
'X_train_reduced': X_train_reduced,
|
|
'X_test_reduced': X_test_reduced,
|
|
'y_train': y_train,
|
|
'y_test': y_test,
|
|
'data_processed': data_processed,
|
|
'preparation_time': data_preparation_time
|
|
}
|
|
|
|
def run_experiment_parallel(exp_file):
|
|
"""Uruchom pojedynczy eksperyment"""
|
|
if exp_file == 'qsvm1_zz.py':
|
|
import qsvm1_zz
|
|
return qsvm1_zz.run_experiment()
|
|
elif exp_file == 'qsvm2_pauli.py':
|
|
import qsvm2_pauli
|
|
return qsvm2_pauli.run_experiment()
|
|
elif exp_file == 'qsvm3_z.py':
|
|
import qsvm3_z
|
|
return qsvm3_z.run_experiment()
|
|
elif exp_file == 'qsvm4_amplitude.py':
|
|
import qsvm4_amplitude
|
|
return qsvm4_amplitude.run_experiment()
|
|
elif exp_file == 'qsvm5_hybrid.py':
|
|
import qsvm5_hybrid
|
|
return qsvm5_hybrid.run_experiment()
|
|
else:
|
|
print(f"Nieznany eksperyment: {exp_file}")
|
|
return None
|
|
|
|
def run_all_experiments_parallel():
|
|
"""Uruchom wszystkie eksperymenty równolegle"""
|
|
experiment_files = [
|
|
'qsvm1_zz.py',
|
|
'qsvm2_pauli.py',
|
|
'qsvm3_z.py',
|
|
'qsvm4_amplitude.py',
|
|
'qsvm5_hybrid.py'
|
|
]
|
|
|
|
# Użyj 5 procesów (jeden na eksperyment)
|
|
with Pool(5) as p:
|
|
results = p.map(run_experiment_parallel, experiment_files)
|
|
|
|
return results
|
|
|
|
if __name__ == "__main__":
|
|
print("======= KONTROLER EKSPERYMENTÓW QSVM =======")
|
|
print(f"CPU cores: {multiprocessing.cpu_count()}")
|
|
print(f"Uruchamianie 5 eksperymentów równolegle...")
|
|
|
|
results = run_all_experiments_parallel()
|
|
|
|
print("======= WSZYSTKIE EKSPERYMENTY ZAKOŃCZONE =======") |