Upload New File

bachelorarbeit_1.py

+import pandas as pd
+from sklearn.metrics import mean_absolute_error, mean_squared_error
+from io import BytesIO
+import requests
+from zipfile import ZipFile
+import time
+import tracemalloc
+import numpy as np
+import seaborn as sns
+import matplotlib.pyplot as plt
+from sklearn.metrics import confusion_matrix
+
+# --------------------------------------------------
+# 1) DATEN LADEN UND AUFBEREITEN
+# --------------------------------------------------
+url = "https://files.grouplens.org/datasets/movielens/ml-1m.zip"
+print("Lade den Datensatz...")
+response = requests.get(url)
+if response.status_code == 200:
+    print("Datensatz erfolgreich heruntergeladen.")
+else:
+    print("Fehler beim Herunterladen des Datensatzes.")
+    exit()
+
+# MovieLens-1M entpacken
+zipfile = ZipFile(BytesIO(response.content))
+with zipfile.open("ml-1m/ratings.dat") as file:
+    columns = ['UserID', 'MovieID', 'Rating', 'Timestamp']
+    data = pd.read_csv(file, sep='::', names=columns, engine='python')
+
+# Fehlende Zeilen entfernen (falls vorhanden)
+data.dropna(inplace=True)
+
+# Mapping von UserIDs und MovieIDs zu kontinuierlichen Indizes
+user_mapping = {old: new for new, old in enumerate(data['UserID'].unique())}
+movie_mapping = {old: new for new, old in enumerate(data['MovieID'].unique())}
+data['UserID'] = data['UserID'].map(user_mapping)
+data['MovieID'] = data['MovieID'].map(movie_mapping)
+
+num_users = data['UserID'].nunique()
+num_movies = data['MovieID'].nunique()
+
+# Bewertungsmatrix erstellen (Zeilen = User, Spalten = Filme)
+rating_matrix = np.full((num_users, num_movies), np.nan)
+for _, row in data.iterrows():
+    rating_matrix[int(row['UserID']), int(row['MovieID'])] = row['Rating']
+
+
+# --------------------------------------------------
+# 2) HILFSFUNKTIONEN
+# --------------------------------------------------
+def remove_sparse_rows_columns(matrix, threshold=0.9):
+    """
+    Entfernt Zeilen und Spalten, bei denen der Anteil
+    der NaN-Werte den Schwellenwert überschreitet.
+    """
+    row_nan_ratio = np.isnan(matrix).mean(axis=1)
+    col_nan_ratio = np.isnan(matrix).mean(axis=0)
+
+    valid_rows = row_nan_ratio < threshold
+    valid_cols = col_nan_ratio < threshold
+
+    return matrix[valid_rows][:, valid_cols]
+
+
+def stabilize_matrix(matrix, epsilon=1e-6):
+    """
+    Fügt kleine zufällige Werte hinzu, um die Matrix
+    für SVD zu stabilisieren.
+    """
+    return matrix + epsilon * np.random.rand(*matrix.shape)
+
+
+def replace_nan_with_column_mean(matrix):
+    """
+    Ersetzt NaN-Werte durch den Spaltenmittelwert.
+    """
+    for i in range(matrix.shape[1]):
+        col = matrix[:, i]
+        nan_mask = np.isnan(col)
+        mean_val = np.nanmean(col)
+        col[nan_mask] = mean_val
+    return matrix
+
+
+def classical_svd(matrix):
+    """
+    Berechnet SVD durch Eigenzerlegung von A^T A und A A^T.
+    Gibt U, Sigma und V^T zurück.
+    """
+    ATA = np.dot(matrix.T, matrix)
+    AAT = np.dot(matrix, matrix.T)
+
+    eigvals_V, eigvecs_V = np.linalg.eigh(ATA)
+    sorted_indices_V = np.argsort(eigvals_V)[::-1]
+    eigvals_V = eigvals_V[sorted_indices_V]
+    eigvecs_V = eigvecs_V[:, sorted_indices_V]
+
+    eigvals_U, eigvecs_U = np.linalg.eigh(AAT)
+    sorted_indices_U = np.argsort(eigvals_U)[::-1]
+    eigvals_U = eigvals_U[sorted_indices_U]
+    eigvecs_U = eigvecs_U[:, sorted_indices_U]
+
+    singular_values = np.sqrt(eigvals_V)
+
+    Sigma = np.zeros_like(matrix, dtype=float)
+    n_min = min(matrix.shape)
+    np.fill_diagonal(Sigma, singular_values[:n_min])
+
+    U = eigvecs_U
+    Vt = eigvecs_V.T
+
+    return U, Sigma, Vt
+
+
+def apply_classical_svd(matrix, k=15):
+    """
+    Führt die klassische SVD auf 'matrix' durch und gibt (U_k, Sigma_k, V_k, reconstructed) zurück.
+    """
+    U, Sigma, Vt = classical_svd(matrix)
+
+    U_k = U[:, :k]                 # (num_users x k)
+    Sigma_k = Sigma[:k, :k]        # (k x k)
+    V_k = Vt[:k, :]                # (k x num_items)
+
+    reconstructed = np.dot(U_k, np.dot(Sigma_k, V_k))  # (num_users x num_items)
+
+    return U_k, Sigma_k, V_k, reconstructed
+
+
+def apply_als(matrix, latent_features=15, iterations=20, lambda_=0.1):
+    """
+    Einfacher ALS-Algorithmus:
+    - matrix: Rating-Matrix (User x Items) [enthält NaN]
+    - latent_features: Anzahl latenter Dimensionen
+    - iterations: Anzahl Iterationsschritte
+    - lambda_: Regularisierung
+    """
+    num_users, num_items = matrix.shape
+    user_features = np.random.rand(num_users, latent_features)
+    item_features = np.random.rand(num_items, latent_features)
+
+    tracemalloc.start()
+    start_time = time.time()
+
+    for _ in range(iterations):
+        # Benutzer-Vektoren updaten
+        for i in range(num_users):
+            valid_items = ~np.isnan(matrix[i])
+            if np.any(valid_items):
+                item_mat = item_features[valid_items]
+                ratings = matrix[i, valid_items]
+                A = np.dot(item_mat.T, item_mat) + lambda_ * np.eye(latent_features)
+                b = np.dot(item_mat.T, ratings)
+                user_features[i] = np.linalg.solve(A, b)
+
+        # Item-Vektoren updaten
+        for j in range(num_items):
+            valid_users = ~np.isnan(matrix[:, j])
+            if np.any(valid_users):
+                user_mat = user_features[valid_users]
+                ratings = matrix[valid_users, j]
+                A = np.dot(user_mat.T, user_mat) + lambda_ * np.eye(latent_features)
+                b = np.dot(user_mat.T, ratings)
+                item_features[j] = np.linalg.solve(A, b)
+
+    end_time = time.time()
+    current, peak = tracemalloc.get_traced_memory()
+    tracemalloc.stop()
+
+    runtime = end_time - start_time
+    memory_usage = peak / 1024 / 1024  # in MB
+
+    # Rekonstruierte Matrix
+    reconstructed = np.dot(user_features, item_features.T)
+
+    return reconstructed, runtime, memory_usage
+
+
+# --------------------------------------------------
+# 3) MATRIX-AUFBEREITUNG
+# --------------------------------------------------
+# Filtere stark spärliche Zeilen/Spalten
+rating_matrix = remove_sparse_rows_columns(rating_matrix, threshold=0.9)
+
+# Kopie fürs Training (noch mit NaN) - wird NUR für ALS genutzt
+training_matrix_als = rating_matrix.copy()
+
+# 20% als Testmaske
+np.random.seed(42)
+mask = np.random.rand(*rating_matrix.shape) < 0.7
+
+# Im ALS-Trainingsset Testwerte entfernen (setzen NaN)
+training_matrix_als[mask] = np.nan
+
+# ----> HIER KEIN replace_nan_with_column_mean für ALS!
+#      ALS soll mit NaN arbeiten.
+
+# Kopie NUR für SVD
+training_matrix_svd = rating_matrix.copy()
+training_matrix_svd[mask] = np.nan
+
+# Fülle NaN mit Spaltenmittelwert NUR für SVD
+training_matrix_svd = replace_nan_with_column_mean(training_matrix_svd)
+# Stabilisierung optional
+training_matrix_svd = stabilize_matrix(training_matrix_svd)
+
+
+# --------------------------------------------------
+# 4) AUSFÜHRUNG: ALS (mit NaN) UND SVD (ohne NaN)
+# --------------------------------------------------
+print("Wende ALS an...")
+als_reconstructed, als_runtime, als_memory = apply_als(
+    training_matrix_als, latent_features=15, iterations=20, lambda_=0.1
+)
+
+print("Wende klassische SVD an...")
+start_time_svd = time.time()
+tracemalloc.start()
+U_k, Sigma_k, V_k, svd_reconstructed = apply_classical_svd(training_matrix_svd, k=15)
+current_svd, peak_svd = tracemalloc.get_traced_memory()
+tracemalloc.stop()
+end_time_svd = time.time()
+
+svd_runtime = end_time_svd - start_time_svd
+svd_memory = peak_svd / 1024 / 1024  # in MB
+
+# Vorhersagen auf Bereich [1, 5] beschränken
+als_reconstructed = np.clip(als_reconstructed, 1, 5)
+svd_reconstructed = np.clip(svd_reconstructed, 1, 5)
+
+# --------------------------------------------------
+# 5) GÜTE MESSEN (MAE, RMSE) auf den Test-Stellen
+# --------------------------------------------------
+original_values = rating_matrix[mask]   # Tatsächliche Werte (Test)
+als_values = als_reconstructed[mask]    # Vorhersage ALS
+svd_values = svd_reconstructed[mask]    # Vorhersage SVD
+
+valid_mask = ~np.isnan(original_values)
+original_values = original_values[valid_mask]
+als_values = als_values[valid_mask]
+svd_values = svd_values[valid_mask]
+
+mae_als = mean_absolute_error(original_values, als_values)
+rmse_als = np.sqrt(mean_squared_error(original_values, als_values))
+mae_svd = mean_absolute_error(original_values, svd_values)
+rmse_svd = np.sqrt(mean_squared_error(original_values, svd_values))
+
+print("\n=== Ergebnisse ===")
+print(f"ALS - MAE:  {mae_als:.4f}, RMSE:  {rmse_als:.4f}")
+print(f"Laufzeit ALS: {als_runtime:.2f} s, Speicher: {als_memory:.2f} MB")
+print("--------------------------------------")
+print(f"SVD - MAE:  {mae_svd:.4f}, RMSE:  {rmse_svd:.4f}")
+print(f"Laufzeit SVD: {svd_runtime:.2f} s, Speicher: {svd_memory:.2f} MB")
+
+
+# --------------------------------------------------
+# 6) VISUALISIERUNGEN
+# --------------------------------------------------
+sns.set_style("whitegrid")
+plt.rcParams.update({'figure.figsize': (12, 7)})
+
+# 6.1) Vergleich MAE, RMSE in Balkendiagrammen
+metrics_df = pd.DataFrame({
+    "MAE": [mae_als, mae_svd],
+    "RMSE": [rmse_als, rmse_svd],
+    "Laufzeit (s)": [als_runtime, svd_runtime],
+    "Speicher (MB)": [als_memory, svd_memory]
+}, index=["ALS", "SVD"])
+
+fig, ax = plt.subplots(1, 2, figsize=(12, 5))
+sns.barplot(x=metrics_df.index, y="MAE", data=metrics_df, ax=ax[0])
+ax[0].set_title("Vergleich MAE (ALS vs. SVD)")
+ax[0].set_ylabel("MAE")
+
+sns.barplot(x=metrics_df.index, y="RMSE", data=metrics_df, ax=ax[1])
+ax[1].set_title("Vergleich RMSE (ALS vs. SVD)")
+ax[1].set_ylabel("RMSE")
+
+plt.tight_layout()
+plt.show()
+
+# 6.2) Balkendiagramm Laufzeit und Speicherverbrauch
+fig, ax = plt.subplots(1, 2, figsize=(12, 5))
+sns.barplot(x=metrics_df.index, y="Laufzeit (s)", data=metrics_df, ax=ax[0])
+ax[0].set_title("Laufzeit (Sek.)")
+ax[0].set_ylabel("Sekunden")
+
+sns.barplot(x=metrics_df.index, y="Speicher (MB)", data=metrics_df, ax=ax[1])
+ax[1].set_title("Max. Speicherverbrauch (MB)")
+ax[1].set_ylabel("MB")
+
+plt.tight_layout()
+plt.show()
+
+# 6.3) Scatterplots: Tatsächliche vs. Vorhergesagte Werte
+fig, ax = plt.subplots(1, 2, figsize=(12, 5))
+ax[0].scatter(original_values, als_values, alpha=0.3, color='blue')
+ax[0].plot([1,5],[1,5], 'r--')
+ax[0].set_title("ALS: Tatsächlich vs. Vorhergesagt")
+ax[0].set_xlabel("Tatsächliche Bewertung")
+ax[0].set_ylabel("Vorhergesagte Bewertung")
+
+ax[1].scatter(original_values, svd_values, alpha=0.3, color='green')
+ax[1].plot([1,5],[1,5], 'r--')
+ax[1].set_title("SVD: Tatsächlich vs. Vorhergesagt")
+ax[1].set_xlabel("Tatsächliche Bewertung")
+ax[1].set_ylabel("Vorhergesagte Bewertung")
+
+plt.tight_layout()
+plt.show()
+
+# 6.4) Verteilung (Histogramm) der vorhergesagten Bewertungen
+fig, ax = plt.subplots(1, 2, figsize=(12, 5))
+sns.histplot(als_values, kde=True, color='blue', ax=ax[0])
+ax[0].set_title("Verteilung ALS-Vorhersagen")
+ax[0].set_xlabel("Bewertung")
+
+sns.histplot(svd_values, kde=True, color='green', ax=ax[1])
+ax[1].set_title("Verteilung SVD-Vorhersagen")
+ax[1].set_xlabel("Bewertung")
+
+plt.tight_layout()
+plt.show()
+
+# 6.5) Residuenanalyse (Histogramm)
+errors_als = als_values - original_values
+errors_svd = svd_values - original_values
+
+fig, ax = plt.subplots(1, 2, figsize=(12, 5))
+sns.histplot(errors_als, kde=True, color='blue', ax=ax[0])
+ax[0].set_title("Residuen ALS")
+ax[0].set_xlabel("Fehler (Vorhergesagt - Tatsächlich)")
+
+sns.histplot(errors_svd, kde=True, color='green', ax=ax[1])
+ax[1].set_title("Residuen SVD")
+ax[1].set_xlabel("Fehler (Vorhergesagt - Tatsächlich)")
+
+plt.tight_layout()
+plt.show()
+
+# --------------------------------------------------
+# 7) ZUSÄTZLICHE ANALYSE:
+#    3D-VISUALISIERUNG FÜR ALS
+# --------------------------------------------------
+latent_values = [5, 10, 15, 20]      # verschiedene latente Dimensionen
+iteration_values = [5, 10, 15, 20]   # verschiedene Iterationszahlen
+
+rmse_surface = np.zeros((len(latent_values), len(iteration_values)))
+
+# Durchlauf mehrerer ALS-Läufe und Speicherung RMSE
+for i, lf in enumerate(latent_values):
+    for j, iters in enumerate(iteration_values):
+        # Kopie der Trainingsmatrix
+        train_copy = rating_matrix.copy()
+        train_copy[mask] = np.nan
+        train_copy = replace_nan_with_column_mean(train_copy)
+        train_copy = stabilize_matrix(train_copy)
+
+        # ALS mit lf latenten Dimensionen und iters Iterationen
+        rec_mat, _, _ = apply_als(train_copy, latent_features=lf, iterations=iters, lambda_=0.1)
+        rec_mat = np.clip(rec_mat, 1, 5)
+
+        # RMSE messen
+        orig_vals = rating_matrix[mask]
+        pred_vals = rec_mat[mask]
+        valid_m = ~np.isnan(orig_vals)
+        true_vals = orig_vals[valid_m]
+        pred_vals = pred_vals[valid_m]
+
+        current_rmse = np.sqrt(mean_squared_error(true_vals, pred_vals))
+        rmse_surface[i, j] = current_rmse
+
+# 3D-Plot erstellen
+X, Y = np.meshgrid(iteration_values, latent_values)
+Z = rmse_surface
+
+fig = plt.figure(figsize=(10, 7))
+ax = fig.add_subplot(111, projection='3d')
+surf = ax.plot_surface(X, Y, Z, cmap='viridis', edgecolor='none')
+ax.set_title("3D-Plot: RMSE über (latente Dimensionen, Iterationen)")
+ax.set_xlabel("Iterationen")
+ax.set_ylabel("Latente Dimensionen")
+ax.set_zlabel("RMSE")
+fig.colorbar(surf, shrink=0.5, aspect=5)
+plt.show()
+
+
+# --------------------------------------------------
+#   rating_matrix       -> Originale Ratings (teils NaN)
+#   als_reconstructed   -> Rekonstruierte Matrix durch ALS
+#   svd_reconstructed   -> Rekonstruierte Matrix durch SVD
+# --------------------------------------------------
+
+# Kopie der Originalmatrix erstellen, damit die NaN-Werte durch 0 (oder einen anderen Wert) ersetzt werden können.
+rating_matrix_filled = np.nan_to_num(rating_matrix, nan=0.0)
+
+# Differenzmatrizen berechnen (Original - Vorhersage).
+difference_matrix_als = rating_matrix_filled - als_reconstructed
+difference_matrix_svd = rating_matrix_filled - svd_reconstructed
+
+# Begrenzung der Nutzer:innen und Filme (z. B. Top 50)
+N = 50
+M = 50
+difference_matrix_als_limited = difference_matrix_als[:N, :M]
+difference_matrix_svd_limited = difference_matrix_svd[:N, :M]
+
+# --------------------------------------------------
+# 1) Heatmap für ALS-Differenzen
+# --------------------------------------------------
+plt.figure(figsize=(10, 6))
+sns.heatmap(
+    difference_matrix_als_limited,
+    cmap="coolwarm",
+    center=0,
+    cbar_kws={'label': 'Differenz (Original - ALS)'}
+)
+plt.title("Heatmap der Differenzen: Original vs ALS-Rekonstruktion")
+plt.xlabel("Nutzer:in")
+plt.ylabel("Filme")
+plt.show()
+
+# --------------------------------------------------
+# 2) Heatmap für SVD-Differenzen
+# --------------------------------------------------
+plt.figure(figsize=(10, 6))
+sns.heatmap(
+    difference_matrix_svd_limited,
+    cmap="coolwarm",
+    center=0,
+    cbar_kws={'label': 'Differenz (Original - SVD)'}
+)
+plt.title("Heatmap der Differenzen: Original vs SVD-Rekonstruktion")
+plt.xlabel("Nutzer:in")
+plt.ylabel("Filme")
+plt.show()
+
+
+# --------------------------------------------------
+#   rating_matrix        -> Originale Ratings (teils NaN)
+#   als_reconstructed    -> Vorhersage-Matrix (ALS)
+#   svd_reconstructed    -> Vorhersage-Matrix (SVD)
+# --------------------------------------------------
+
+# 1) Vorhersagen runden (auf 1–5 skaliert, aber hier nur das Runden auf die nächsten Ganzzahlen)
+rounded_als = np.rint(als_reconstructed)
+rounded_svd = np.rint(svd_reconstructed)
+
+# 2) Originalmatrix ebenfalls ganzzahlig, ggf. NaN erhalten (MovieLens hat integer-Bewertungen 1–5)
+#    -> Prüfen, wo überhaupt (keine) NaN haben
+rating_matrix_rounded = rating_matrix.copy()
+
+# 3) Matrix der korrekten Treffer (1 für korrekt, 0 für falsch).
+#    Bei NaN im Original soll einfach 0 eingetragen werden (da wir dort keinen "Vergleich" haben).
+correct_als = (rating_matrix_rounded == rounded_als).astype(float)
+correct_svd = (rating_matrix_rounded == rounded_svd).astype(float)
+
+# NaN in den Originaldaten => an diesen Stellen kein Vergleich möglich => 0 für Visualisierung
+correct_als = np.nan_to_num(correct_als, nan=0.0)
+correct_svd = np.nan_to_num(correct_svd, nan=0.0)
+
+# --------------------------------------------------
+# 4) Heatmaps erstellen
+# --------------------------------------------------
+num_users_show = 50
+num_items_show = 50
+
+correct_als_small = correct_als[:num_users_show, :num_items_show]
+correct_svd_small = correct_svd[:num_users_show, :num_items_show]
+
+fig, axs = plt.subplots(1, 2, figsize=(12, 6))
+
+# Heatmap für ALS (mit kleiner Teilmatrix)
+sns.heatmap(
+    correct_als_small,
+    cmap="binary",
+    vmin=0, vmax=1,
+    cbar=False,
+    ax=axs[0]
+)
+axs[0].set_title("Heatmap der korrekten Schätzungen für ALS")
+axs[0].set_xlabel("Filme")
+axs[0].set_ylabel("Nutzer:in")
+
+# Heatmap für SVD
+sns.heatmap(
+    correct_svd_small,
+    cmap="binary",
+    vmin=0, vmax=1,
+    cbar=False,
+    ax=axs[1]
+)
+axs[1].set_title("Heatmap der korrekten Schätzungen für SVD")
+axs[1].set_xlabel("Filme")
+axs[1].set_ylabel("Nutzer:in")
+
+plt.tight_layout()
+plt.show()
+
+# --------------------------------------------------
+#   rating_matrix, als_reconstructed, svd_reconstructed
+#   -> rating_matrix:  Shape (num_users, num_movies)
+#   -> als_reconstructed, svd_reconstructed ebenso
+# --------------------------------------------------
+
+# -------------------------
+# 1) Top & Bottom 50 Filme
+# -------------------------
+
+# Berechnet die mittlere Bewertung je Film (Spalte), NaN ignorieren
+mean_ratings_per_movie = np.nanmean(rating_matrix, axis=0)  # Ergebnis: array der Länge num_movies
+
+# Sortiert die Indizes (Film-IDs in der Matrix) nach durchschn. Bewertung
+sorted_movie_indices = np.argsort(mean_ratings_per_movie)
+
+top_50_movies = sorted_movie_indices[-50:]
+bottom_50_movies = sorted_movie_indices[:50]
+
+
+# --------------------------------------------------
+# 2) Visualisierung: Original vs Vorhersage für
+#    Top 50 am besten bewerteten und Bottom 50 ...
+# --------------------------------------------------
+
+def plot_movie_comparison(rating_matrix, reconstructed, movie_indices, title_prefix=""):
+
+    # Mittelwerte über die Nutzer (Zeilen) bilden:
+    original_means = np.nanmean(rating_matrix[:, movie_indices], axis=0)
+    predicted_means = np.nanmean(reconstructed[:, movie_indices], axis=0)
+
+    x_pos = np.arange(len(movie_indices))
+
+    plt.figure(figsize=(10, 5))
+
+    # Balken für Original-Bewertung
+    plt.bar(x_pos - 0.2, original_means, width=0.4, label="Original (Durchschnitt)")
+    # Balken für Vorhersage
+    plt.bar(x_pos + 0.2, predicted_means, width=0.4, label="Vorhersage (Durchschnitt)")
+
+    plt.xlabel("Filme (Index im Datensatz)")
+    plt.ylabel("Durchschn. Bewertung")
+    plt.title(f"{title_prefix}: Original vs. Vorhersage (Durchschnitt)")
+    plt.legend()
+    plt.tight_layout()
+    plt.show()
+
+
+# --- 2.1) Top 50 bestbewertete Filme (ALS)
+plot_movie_comparison(rating_matrix, als_reconstructed, top_50_movies,
+                      title_prefix="Top 50 (beste) - ALS")
+
+# --- 2.2) Top 50 bestbewertete Filme (SVD)
+plot_movie_comparison(rating_matrix, svd_reconstructed, top_50_movies,
+                      title_prefix="Top 50 (beste) - SVD")
+
+# --- 2.3) Bottom 50 am schlechtesten bewertete Filme (ALS)
+plot_movie_comparison(rating_matrix, als_reconstructed, bottom_50_movies,
+                      title_prefix="Bottom 50 (schlechteste) - ALS")
+
+# --- 2.4) Bottom 50 am schlechtesten bewertete Filme (SVD)
+plot_movie_comparison(rating_matrix, svd_reconstructed, bottom_50_movies,
+                      title_prefix="Bottom 50 (schlechteste) - SVD")
+
+# --------------------------------------------------
+# 3) Durchschnittlicher Fehler (MAE) pro Rating-Kategorie
+# --------------------------------------------------
+# Original-Ratings
+original = rating_matrix.flatten()
+als_vals = als_reconstructed.flatten()
+svd_vals = svd_reconstructed.flatten()
+
+# Maske der gültigen (nicht-NaN) Originalwerte
+valid_mask = ~np.isnan(original)
+original = original[valid_mask]
+als_vals = als_vals[valid_mask]
+svd_vals = svd_vals[valid_mask]
+
+# Auf [1..5] begrenzen und ggf. runden
+als_vals = np.clip(als_vals, 1, 5)
+svd_vals = np.clip(svd_vals, 1, 5)
+
+# Berechnet absoluten Fehler je Paar
+abs_error_als = np.abs(original - als_vals)
+abs_error_svd = np.abs(original - svd_vals)
+
+# Gruppieren nach den 5 möglichen Rating-Kategorien (1 bis 5).
+rating_categories = [1, 2, 3, 4, 5]
+als_mae_by_category = []
+svd_mae_by_category = []
+
+for r in rating_categories:
+    # Findet Einträge, bei denen Original == r
+    cat_mask = (original == r)
+    if np.sum(cat_mask) > 0:
+        mae_als_cat = np.mean(abs_error_als[cat_mask])
+        mae_svd_cat = np.mean(abs_error_svd[cat_mask])
+    else:
+        mae_als_cat = np.nan
+        mae_svd_cat = np.nan
+    als_mae_by_category.append(mae_als_cat)
+    svd_mae_by_category.append(mae_svd_cat)
+
+# Erstellt das Balkendiagramm
+x_pos = np.arange(len(rating_categories))
+width = 0.4
+
+plt.figure(figsize=(8, 5))
+plt.bar(x_pos - 0.2, als_mae_by_category, width, label="ALS Fehler")
+plt.bar(x_pos + 0.2, svd_mae_by_category, width, label="SVD Fehler")
+plt.xticks(x_pos, rating_categories)
+plt.xlabel("Rating")
+plt.ylabel("Durchschnittlicher Fehler (MAE)")
+plt.title("Durchschnittlicher Fehler nach Rating-Kategorien")
+plt.legend()
+plt.grid(axis='y')
+plt.tight_layout()
+plt.show()
+
+# --------------------------------------------------
+#   rating_matrix         -> Originale Ratings (teils NaN)
+#   training_matrix       -> Trainingsmatrix (NaN an Test-Stellen)
+#   mask                  -> Test-Maske (True = Test-Eintrag)
+#   apply_classical_svd() -> deine SVD-Funktion
+# --------------------------------------------------
+def svd_with_metrics(train_matrix, k=15):
+    """
+    Führt die klassische SVD mit Rank k durch,
+    gibt (reconstruction, runtime, memory_usage) zurück.
+    """
+    tracemalloc.start()
+    start_time = time.time()
+
+    # Aufruf SVD-Methode
+    U_k, Sigma_k, V_k, svd_reconstructed = apply_classical_svd(train_matrix, k=k)
+
+    # Messungen stoppen
+    end_time = time.time()
+    current, peak = tracemalloc.get_traced_memory()
+    tracemalloc.stop()
+
+    runtime = end_time - start_time
+    memory_usage = peak / 1024 / 1024  # in MB
+
+    return svd_reconstructed, runtime, memory_usage
+
+
+# --------------------------------------------------
+# 1) Verschiedene Werte für k definieren
+# --------------------------------------------------
+k_values = [5, 10, 15, 20, 25, 30]
+rmse_svd = []
+runtime_svd = []
+memory_svd = []
+
+# --------------------------------------------------
+# 2) Schleife über verschiedene k
+# --------------------------------------------------
+for k in k_values:
+    print(f"===> Starte SVD mit k={k} ...")
+    # SVD-Ausführung
+    reconstructed, run_time, mem_usage = svd_with_metrics(training_matrix_svd, k)
+
+    # Ergebnis auf [1..5] beschränken.
+    reconstructed = np.clip(reconstructed, 1, 5)
+
+    # RMSE auf dem Test-Set berechnen
+    # Originalwerte
+    original_test = rating_matrix[mask]
+    # Vorhersagewerte
+    predicted_test = reconstructed[mask]
+
+    # Nur gültige Stellen (wo das Original nicht NaN ist)
+    valid = ~np.isnan(original_test)
+    original_test = original_test[valid]
+    predicted_test = predicted_test[valid]
+
+    current_rmse = np.sqrt(mean_squared_error(original_test, predicted_test))
+
+    # Werte speichern für das Plotten
+    rmse_svd.append(current_rmse)
+    runtime_svd.append(run_time)
+    memory_svd.append(mem_usage)
+
+# --------------------------------------------------
+# 3) Visualisieren (RMSE & Laufzeit in 2D)
+# --------------------------------------------------
+plt.figure(figsize=(8, 5))
+plt.plot(k_values, rmse_svd, marker='o', color='blue', label="RMSE (SVD)")
+plt.xlabel("Latente Dimension k")
+plt.ylabel("RMSE")
+plt.title("2D-Plot: RMSE vs. latente Dimension (k) - SVD")
+plt.grid(True)
+plt.legend()
+plt.tight_layout()
+plt.show()
+
+# --------------------------------------------------
+# 4)  Laufzeit in separatem oder demselben Diagramm
+# --------------------------------------------------
+plt.figure(figsize=(8, 5))
+plt.plot(k_values, runtime_svd, marker='s', color='red', label="Laufzeit (s)")
+plt.xlabel("Latente Dimension k")
+plt.ylabel("Laufzeit (Sek.)")
+plt.title("2D-Plot: Laufzeit vs. latente Dimension (k) - SVD")
+plt.grid(True)
+plt.legend()
+plt.tight_layout()
+plt.show()
+
+# --------------------------------------------------
+# 5)  Speicherverbrauch
+# --------------------------------------------------
+plt.figure(figsize=(8, 5))
+plt.plot(k_values, memory_svd, marker='^', color='green', label="Speicherverbrauch (MB)")
+plt.xlabel("Latente Dimension k")
+plt.ylabel("Speicher (MB)")
+plt.title("2D-Plot: Speicherverbrauch vs. latente Dimension (k) - SVD")
+plt.grid(True)
+plt.legend()
+plt.tight_layout()
+plt.show()
+
+
+original_vals = rating_matrix.flatten()        # Original-Bewertungen
+als_vals = als_reconstructed.flatten()         # ALS-Schätzung
+svd_vals = svd_reconstructed.flatten()         # SVD-Schätzung
+
+# Gültige Einträge filtern (keine NaN)
+valid_mask = ~np.isnan(original_vals)
+original_vals = original_vals[valid_mask]
+als_vals = als_vals[valid_mask]
+svd_vals = svd_vals[valid_mask]
+
+# Auf 1..5 clippen und runden
+als_vals_rounded = np.clip(np.rint(als_vals), 1, 5)
+svd_vals_rounded = np.clip(np.rint(svd_vals), 1, 5)
+
+# Konfusionsmatrix ALS
+cm_als = confusion_matrix(original_vals, als_vals_rounded, labels=[1,2,3,4,5])
+
+plt.figure(figsize=(5,4))
+sns.heatmap(
+    cm_als, annot=True, fmt="d", cmap="Blues",
+    xticklabels=[1,2,3,4,5], yticklabels=[1,2,3,4,5]
+)
+plt.title("Konfusionsmatrix (ALS)")
+plt.xlabel("Vorhergesagte Bewertung")
+plt.ylabel("Tatsächliche Bewertung")
+plt.tight_layout()
+plt.show()
+
+# Konfusionsmatrix SVD
+cm_svd = confusion_matrix(original_vals, svd_vals_rounded, labels=[1,2,3,4,5])
+
+plt.figure(figsize=(5,4))
+sns.heatmap(
+    cm_svd, annot=True, fmt="d", cmap="Greens",
+    xticklabels=[1,2,3,4,5], yticklabels=[1,2,3,4,5]
+)
+plt.title("Konfusionsmatrix (SVD)")
+plt.xlabel("Vorhergesagte Bewertung")
+plt.ylabel("Tatsächliche Bewertung")
+plt.tight_layout()
+plt.show()
+
+
+# Anzahl nicht-NaN pro Benutzer (Zeile)
+user_ratings_count = np.sum(~np.isnan(rating_matrix), axis=1)
+
+plt.figure(figsize=(8,5))
+plt.hist(user_ratings_count, bins=50, color='blue', alpha=0.7)
+plt.title("Anzahl Bewertungen pro Benutzer (Sparseness)")
+plt.xlabel("Anzahl Bewertungen")
+plt.ylabel("Anzahl Benutzer")
+plt.grid(True)
+plt.tight_layout()
+plt.show()
+
+###########################################
+# 3) SVD anwenden
+###########################################
+k = 15  # Anzahl der latenten Dimensionen für den Plot
+U_k, Sigma_k, Vt_k, reconstructed  = apply_classical_svd(rating_matrix_filled, k=k)
+
+###########################################
+# 4) Item-Features aus V^T extrahieren
+###########################################
+# Annahme: rating_matrix hat shape (num_users x num_items)
+# => Die Spalten repräsentieren "Items" (z.B. Filme)
+# => Vt_k (k x num_items) => transponieren => (num_items x k)
+item_features = Vt_k.T  # num_items x k
+
+###########################################
+# 5) 2D-Scatterplot erstellen
+###########################################
+x_coords = item_features[:, 0]
+y_coords = item_features[:, 1]
+
+plt.figure(figsize=(8, 5))
+sns.scatterplot(x=x_coords, y=y_coords, alpha=0.8)
+plt.title("2D-Scatterplot der Item-Features (klassische SVD)")
+plt.xlabel("Latente Dimension 1")
+plt.ylabel("Latente Dimension 2")
+plt.grid(True)
+plt.tight_layout()
+plt.show()
+
+# Anzahl nicht-NaN pro Film (Spalte in rating_matrix)
+movie_ratings_count = np.sum(~np.isnan(rating_matrix), axis=0)
+
+# Sortieren (absteigend)
+sorted_counts = np.sort(movie_ratings_count)[::-1]
+
+plt.figure(figsize=(8,5))
+plt.plot(sorted_counts, marker='o', linewidth=1)
+plt.title("Long-Tail: Beliebtheit (Anzahl Ratings) pro Film")
+plt.xlabel("Film (sortiert nach Popularität)")
+plt.ylabel("Anzahl Ratings")
+plt.grid(True)
+plt.tight_layout()
+plt.show()
+
+# Angenommen, in 'data' (DataFrame) stehen:
+#   data['UserID'], data['MovieID'], data['Rating'], data['Timestamp']
+
+# 1) Zeitspalte konvertieren
+data['Date'] = pd.to_datetime(data['Timestamp'], unit='s')
+
+# 2) Gruppieren nach Jahr-Monat oder nur Jahr
+data['YearMonth'] = data['Date'].dt.to_period('M')
+
+# 3) Zählen, wie viele Ratings in jedem Monat abgegeben wurden
+ratings_per_month = data.groupby('YearMonth')['Rating'].count().reset_index()
+
+# 4) Plotten
+plt.figure(figsize=(10,5))
+plt.plot(ratings_per_month['YearMonth'].astype(str), ratings_per_month['Rating'], marker='o')
+plt.xticks(rotation=45)
+plt.title("Anzahl abgegebener Bewertungen pro Monat (MovieLens 1M)")
+plt.xlabel("Monat")
+plt.ylabel("Anzahl Bewertungen")
+plt.tight_layout()
+plt.show()
+
+
+
+
+
+
+
+
+
+
+
+