Upload files to "/"

qsvm.py

@@ -215,32 +215,24 @@ def prepare_data(data_file):
     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'}:
@@ -254,9 +246,7 @@ def prepare_data(data_file):
         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)
@@ -264,43 +254,31 @@ def prepare_data(data_file):
     # 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,
@@ -312,20 +290,16 @@ def prepare_data(data_file):
         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)}")
+                pass
         
         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,
@@ -337,31 +311,24 @@ def prepare_data(data_file):
         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)}")
+                pass
         
         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(
@@ -371,12 +338,8 @@ def prepare_data(data_file):
     # 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,