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