CycleUser

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler, MaxAbsScaler, QuantileTransformer, Normalizer
from sklearn.manifold import Isomap
import warnings
import pandas as pd

import platform

# Suppress warnings
warnings.filterwarnings('ignore')

# Set aesthetic style
sns.set(style="whitegrid", context="talk")

# Configure fonts for Chinese support and correct minus sign
system = platform.system()
if system == 'Windows':
    plt.rcParams['font.sans-serif'] = ['Microsoft YaHei', 'SimHei', 'Arial']
elif system == 'Darwin':
    plt.rcParams['font.sans-serif'] = ['Arial Unicode MS', 'PingFang SC']
else:
    plt.rcParams['font.sans-serif'] = ['WenQuanYi Micro Hei', 'DejaVu Sans']

plt.rcParams['axes.unicode_minus'] = False # Use ASCII hyphen for minus sign

def generate_visible_data(n_samples=500, n_features=10):
    """
    Generate data that is 'badly behaved' (skewed, outliers) 
    but within a reasonable range (0-30) to be comparable with normalized data (-3 to 3).
    """
    np.random.seed(42)
    # 1. Base: Log-Normal centered around 5.0 (approx)
    # Mean = exp(mu + sigma^2/2)
    # If we want mean ~5, let's use mu=1.5, sigma=0.5 -> exp(1.5+0.125) ~ 5.0
    data = np.random.lognormal(mean=1.5, sigma=0.5, size=(n_samples, n_features))

    # 2. Add moderate outliers (e.g., values around 25-30)
    # Not too extreme so they fit on the plot
    n_outliers = int(0.05 * n_samples)
    outlier_indices = np.random.choice(n_samples, n_outliers, replace=False)
    data[outlier_indices, 0] = np.random.uniform(20, 30, size=n_outliers)

    # Ensure strictly positive for Log methods
    data = np.maximum(data, 1e-6)
    return data

# --- Custom Transformers ---
def layer_norm(X):
    mean = np.mean(X, axis=1, keepdims=True)
    std = np.std(X, axis=1, keepdims=True)
    return (X - mean) / (std + 1e-8)

def rms_norm(X):
    rms = np.sqrt(np.mean(X**2, axis=1, keepdims=True))
    return X / (rms + 1e-8)

def log_centering(X):
    log_X = np.log1p(X)
    mean_log = np.mean(log_X, axis=0, keepdims=True)
    return log_X - mean_log

def clr_transform(X):
    log_X = np.log(X)
    mean_log = np.mean(log_X, axis=1, keepdims=True)
    return log_X - mean_log

def decimal_scaling(X):
    max_abs = np.max(np.abs(X), axis=0, keepdims=True)
    j = np.ceil(np.log10(np.maximum(max_abs, 1e-8)))
    return X / (10**j)

def isomap_norm(X):
    # Use fewer samples for speed
    sample_mask = np.random.choice(X.shape[0], min(300, X.shape[0]), replace=False)
    X_sub = X[sample_mask]
    iso = Isomap(n_components=1, n_neighbors=15)
    X_transformed = iso.fit_transform(X_sub)
    # Z-score result
    return StandardScaler().fit_transform(X_transformed).flatten()

def plot_points_comparison():
    print("Generating data...")
    X = generate_visible_data()
    feature_idx = 0  # Plot distribution of Feature 0

    # Prepare data for plotting
    plot_data = []

    methods = [
        ("ORIGINAL DATA", lambda x: x),  # Original first
        ("Z-score (StandardScaler)", StandardScaler()),
        ("RobustScaler", RobustScaler()),
        ("Min-Max (0-1)", MinMaxScaler()),
        ("MaxAbs (-1 to 1)", MaxAbsScaler()),
        ("Layer Normalization", layer_norm),
        ("RMSNorm", rms_norm),
        ("Log-Centering", log_centering),
        ("CLR Transform", clr_transform),
        ("Quantile (Normal)", QuantileTransformer(output_distribution='normal', random_state=42)),
        ("Decimal Scaling", decimal_scaling),
        ("Unit Vector (L2)", Normalizer()),
        ("ISOMAP (Manifold)", isomap_norm)
    ]

    print("Transforming data...")
    for name, transformer in methods:
        try:
            if hasattr(transformer, 'fit_transform'):
                X_new = transformer.fit_transform(X)
            elif callable(transformer):
                X_new = transformer(X)
            else:
                X_new = transformer.transform(X)

            # Extract data to plot
            if name.startswith("ISOMAP"):
                data_points = X_new # Already flattened
            elif X_new.ndim == 1:
                data_points = X_new
            else:
                data_points = X_new[:, feature_idx] # Feature 0

            # Store for DataFrame
            for val in data_points:
                plot_data.append({'Method': name, 'Value': val})

        except Exception as e:
            print(f"Error processing {name}: {e}")

    df = pd.DataFrame(plot_data)

    # Create Figure
    plt.figure(figsize=(16, 12))

    # Use a high-contrast palette
    # Assign specific color to ORIGINAL DATA (e.g., Red or Black)
    palette = sns.color_palette("husl", len(methods))
    palette[0] = (0.2, 0.2, 0.2) # Dark Grey/Black for Original

    print("Plotting Strip Plot...")
    # 1. Strip Plot (Raw Points)
    sns.stripplot(x="Value", y="Method", data=df, 
                  size=3, jitter=0.25, alpha=0.6, palette=palette, orient='h', zorder=1)

    print("Plotting Box Plot...")
    # 2. Box Plot (Summary) - Transparent with colored edges
    # Note: seaborn boxplot doesn't support 'edgecolor' easily with hue, so we use standard boxplot
    sns.boxplot(x="Value", y="Method", data=df,
                whis=1.5, showfliers=False, width=0.5,
                boxprops=dict(alpha=0.3), 
                palette=palette, orient='h', zorder=2)

    # Add reference line at 0
    plt.axvline(x=0, color='gray', linestyle='--', linewidth=1, alpha=0.5, zorder=0)

    # Add title and labels
    plt.title("Comparison of Normalization Methods: Distribution & Range\n(Points = Samples | Box = IQR)", 
              fontsize=20, fontweight='bold', pad=20)
    plt.xlabel("Value Magnitude (SymLog Scale)", fontsize=14)
    plt.ylabel("")

    # Use SymLog scale to show both 0-1 and 0-30 ranges clearly
    plt.xscale('symlog', linthresh=1.0)

    # Customize grid
    plt.grid(True, axis='x', alpha=0.3, which='both')

    # Remove spines
    sns.despine(left=True, bottom=False)

    plt.tight_layout()

    output_file = "normalization_points_comparison.png"
    plt.savefig(output_file, dpi=150, bbox_inches='tight')
    print(f"Saved to {output_file}")

if __name__ == "__main__":
    plot_points_comparison()