Upload 6 files

app.py

@@ -0,0 +1,441 @@
+import gradio as gr
+import pandas as pd
+import numpy as np
+import plotly.graph_objects as go
+import tempfile
+import os
+import re
+from data_loader import loader
+from scoring import ScoringEngine, PRESET_CONFIGS, METRIC_MAP
+from dev_tools import DevSuite
+from config import *
+
+# Lazy loading state
+_CACHED_DF = None
+
+def get_dataframe():
+    """Lazy load dataframe."""
+    global _CACHED_DF
+    if _CACHED_DF is None:
+        if FORCE_REFRESH_ON_STARTUP:
+            print("🔄 First load: Clearing cache...")
+            loader.clear_cache()
+        df = loader.load_data()
+        if not df.empty:
+            _CACHED_DF = ScoringEngine(df).calculate_all()
+        else:
+            _CACHED_DF = df
+    return _CACHED_DF
+
+def format_params(row):
+    total = row.get('Total Parameters', 0)
+    active = row.get('Active Parameters', 0)
+    if pd.isna(total) or total <= 0:
+        return "N/A"
+    def fmt(x):
+        try:
+            val = float(x)
+            if val <= 0: return "?"
+            if val < 1: return f"{val*1000:.0f}M"
+            return f"{val:.1f}B"
+        except:
+            return "?"
+    if pd.isna(active) or active <= 0 or active == total:
+        return fmt(total)
+    else:
+        return f"{fmt(total)} (Act: {fmt(active)})"
+
+def escape_markdown(text):
+    return re.sub(r'([\[\]()\*_#~`])', r'\\\1', str(text))
+
+def format_model_link(row):
+    name = str(row.get('author/model_name', 'Unknown'))
+    link = row.get('Model Link', '')
+    safe_name = escape_markdown(name)
+    if pd.notna(link) and isinstance(link, str) and link.startswith('http'):
+        return f"[{safe_name}]({link})"
+    return safe_name
+
+def get_architecture_choices(df):
+    if df is None or df.empty:
+        return []
+    valid_archs = [a for a in df['Architecture'].dropna().unique() 
+                   if str(a).lower() not in ['unknown', 'nan', 'null', 'none']]
+    return sorted(valid_archs)
+
+def filter_leaderboard(df, preset, query, param_min, param_max, proprietary, 
+                      moe_only, thinking_mode, model_types, architecture, top_n,
+                      balance_filter):
+    if df is None or df.empty:
+        return pd.DataFrame(), pd.DataFrame()
+
+    mask = pd.Series(True, index=df.index)
+
+    # Search
+    if query:
+        search_mask = (
+            df['author/model_name'].astype(str).str.contains(query, case=False, na=False) |
+            df['Architecture'].astype(str).str.contains(query, case=False, na=False)
+        )
+        mask &= search_mask
+
+    # Preset filtering (Pocket Genius)
+    if preset == "🤏 Pocket Genius":
+        mask &= (df['Total Parameters'] <= 12.0)
+
+    # Params filtering
+    has_params = df['Total Parameters'].notna() & (df['Total Parameters'] > 0)
+    in_range = (df['Total Parameters'] >= param_min) & (df['Total Parameters'] <= param_max)
+    
+    if proprietary:
+        mask &= (has_params & in_range) | ~has_params
+    else:
+        mask &= has_params & in_range
+
+    if moe_only:
+        mask &= (df['Active Parameters'] < df['Total Parameters'])
+
+    if thinking_mode == "Hide Thinking":
+        mask &= ~df['Is Thinking Model']
+    elif thinking_mode == "Only Thinking":
+        mask &= df['Is Thinking Model']
+
+    # Model Types
+    type_mask = pd.Series(False, index=df.index)
+    for model_type, col in [("Foundation", "Is Foundation"), ("Finetuned", "Is Finetuned"), ("Merged", "Is Merged")]:
+        if model_type in model_types and col in df.columns:
+            type_mask |= df[col]
+    if type_mask.any():
+        mask &= type_mask
+
+    if architecture and architecture != "All":
+        mask &= (df['Architecture'] == architecture)
+
+# === BALANCE FILTER LOGIC ===
+    if balance_filter != "Show All":
+        threshold = 0.0
+        if "Perfect" in balance_filter: threshold = 0.7
+        elif "Good" in balance_filter: threshold = 0.5
+        elif "Basic" in balance_filter: threshold = 0.3
+        
+        target_col = "Score_💎 Perfect Balance"
+        
+        if target_col in df.columns:
+            mask &= (df[target_col] >= threshold)
+
+    score_col = f"Score_{preset}"
+    
+    if score_col not in df.columns:
+        return pd.DataFrame(), pd.DataFrame()
+
+    result = df[mask].sort_values(score_col, ascending=False).head(top_n).copy()
+    
+    if result.empty:
+        return pd.DataFrame(), pd.DataFrame()
+
+    export_df = result.copy()
+
+    # Formatting
+    result['Rank'] = range(1, len(result) + 1)
+    result['Model Name'] = result.apply(format_model_link, axis=1)
+    result['Parameters'] = result.apply(format_params, axis=1)
+    result['Architecture'] = result['Architecture'].apply(str)
+    result['Date'] = pd.to_datetime(result['Release Date'], errors='coerce').dt.strftime('%Y-%m-%d').fillna('-')
+    result = result.rename(columns={score_col: "⭐ Score"})
+
+    display_cols = ['Rank', 'Model Name', "⭐ Score", 'Date', 'Badges', 'Parameters', 'Architecture']
+    return result[display_cols], export_df
+
+def compare_models(df, model_names_text):
+    if df is None or not model_names_text:
+        return None, pd.DataFrame()
+    targets = [x.strip() for x in model_names_text.split('\n') if x.strip()]
+    subset = df[df['author/model_name'].isin(targets)].copy()
+    if subset.empty:
+        return None, pd.DataFrame()
+
+    metrics = {'Logic': 'Composite_WorldModel', 'Knowledge': 'norm_Textbook', 'Style': 'norm_Style',
+               'Roleplay': 'gauss_Dialogue', 'Freedom': 'Composite_Unbound'}
+    fig = go.Figure()
+    for _, row in subset.iterrows():
+        values = []
+        for col in metrics.values():
+            val = float(row.get(col, 0))
+            if abs(val) > 90000: val = 0 # Handle sentinel values
+            values.append(val)
+        values.append(values[0])
+        categories = list(metrics.keys()) + [list(metrics.keys())[0]]
+        fig.add_trace(go.Scatterpolar(r=values, theta=categories, fill='toself', name=row['author/model_name'][:30]))
+    fig.update_layout(polar=dict(radialaxis=dict(visible=True, range=[0, 1])), showlegend=True, height=500)
+
+    compare_cols = ['author/model_name', 'Total Parameters', 'Score_🌌 Divine RP', 'norm_Style', 'Composite_WorldModel']
+    compare_df = subset[compare_cols].rename(columns={
+        'author/model_name': 'Model', 'Total Parameters': 'Params', 'Score_🌌 Divine RP': 'Divine RP',
+        'norm_Style': 'Writing Style', 'Composite_WorldModel': 'World Model'
+    })
+    return fig, compare_df
+
+def calculate_custom_score(df, weights_dict):
+    if df is None or df.empty:
+        return pd.DataFrame()
+    temp_engine = ScoringEngine(df.copy())
+    df = df.copy()
+    df['Custom_Score'] = temp_engine.calculate_weighted_score(weights_dict).round(3)
+    result = df.sort_values('Custom_Score', ascending=False).head(50)
+    display = result[['author/model_name', 'Custom_Score', 'Total Parameters', 'Badges']].copy()
+    display = display.rename(columns={'author/model_name': 'Model', 'Custom_Score': '⭐ Score', 'Total Parameters': 'Params'})
+    return display
+
+def run_diagnostics(df):
+    if df is None or df.empty:
+        return "❌ No data loaded", pd.DataFrame(), pd.DataFrame()
+    dev = DevSuite(df)
+    return dev.run_all_tests(), dev.get_anomalies_df(), dev.get_statistics_df()
+
+def clear_and_reload():
+    global _CACHED_DF
+    _CACHED_DF = None
+    loader.clear_cache()
+    new_df = get_dataframe()
+    status = f"✅ Cache cleared!\nDeleted files: data_cache.parquet, meta.json\n🔄 Data reloaded: {len(new_df)} rows"
+    return new_df, status
+
+with gr.Blocks() as demo:
+    initial_df = get_dataframe()
+    df_state = gr.State(initial_df)
+    filtered_raw_state = gr.State()
+
+    gr.Markdown(f"""
+    # 🏆 UGI Leaderboard: Presets Edition v3.6
+    **Last Updated:** {loader.last_updated} | **Models:** {len(initial_df)} | **PID:** {os.getpid()}
+    """)
+
+    with gr.Tabs():
+        with gr.Tab("🏅 Leaderboard"):
+            # Upper Control Panel
+            with gr.Row(variant="panel", equal_height=True):
+                with gr.Column(scale=5):
+                    preset_dropdown = gr.Radio(
+                        choices=list(PRESET_CONFIGS.keys()) + ["⚡ Efficiency King", "🤏 Pocket Genius"],
+                        value="🌌 Divine RP", 
+                        label="🎯 Preset", 
+                        interactive=True
+                    )
+                with gr.Column(scale=1, min_width=150):
+                    refresh_btn = gr.Button("🔄 Refresh Data", variant="secondary", size="lg")
+
+            # Filters Accordion
+            with gr.Accordion("⚙️ Hardware & Filters", open=False):
+                with gr.Row():
+                    param_min = gr.Slider(0, MAX_PARAMS_SLIDER, 0, step=1, label="Min Parameters (B)")
+                    param_max = gr.Slider(0, MAX_PARAMS_SLIDER, MAX_PARAMS_SLIDER, step=1, label="Max Parameters (B)")
+                with gr.Row():
+                    proprietary_check = gr.Checkbox(value=True, label="Include Proprietary (unknown params)")
+                    moe_check = gr.Checkbox(value=False, label="MoE Only")
+                    thinking_mode = gr.Radio(["Show All", "Hide Thinking", "Only Thinking"], value="Show All", label="Reasoning Models")
+                with gr.Row():
+                    model_types = gr.CheckboxGroup(["Foundation", "Finetuned", "Merged"], value=["Foundation", "Finetuned", "Merged"], label="Model Types")
+                    arch_dropdown = gr.Dropdown(["All"] + get_architecture_choices(initial_df), value="All", label="Architecture")
+                    top_n_slider = gr.Slider(10, 500, DEFAULT_TOP_N, step=10, label="Top N")
+                
+                # NEW BALANCE FILTER
+                with gr.Row():
+                    balance_filter = gr.Radio(
+                        choices=["Show All", "💎 Perfect (≥0.7)", "🏅 Good (≥0.5)", "⚖️ Basic (≥0.3)"],
+                        value="Show All",
+                        label="🛡️ Robustness Filter (Objective Metrics Only)",
+                        info="Filters out models with weak spots in 13 core metrics (Knowledge, Logic, Syntax)."
+                    )
+
+            search_box = gr.Textbox(label="🔍 Search Models (name or architecture)", placeholder="e.g., Llama, Qwen, MistralForCausalLM...")
+            leaderboard_table = gr.Dataframe(datatype=["number", "markdown", "number", "str", "str", "str", "str"], wrap=True, interactive=False)
+
+            # Export
+            with gr.Row():
+                with gr.Column(scale=1):
+                    export_btn = gr.Button("📥 Export CSV", variant="primary", size="sm")
+                with gr.Column(scale=4):
+                    export_file = gr.File(label="Download CSV", visible=False, height=50)
+
+        with gr.Tab("⚖️ Compare"):
+            gr.Markdown("### Compare Multiple Models")
+            with gr.Row():
+                with gr.Column(scale=2):
+                    search_compare = gr.Textbox(label="🔍 Search to Add Models", placeholder="Type model name...")
+                    search_results_radio = gr.Radio(choices=[], label="Select from results", interactive=True)
+                    add_model_btn = gr.Button("➕ Add Model", variant="secondary")
+                with gr.Column(scale=3):
+                    compare_textbox = gr.Textbox(label="📋 Comparing (one per line)", lines=8, placeholder="Add models using search...")
+
+            compare_btn = gr.Button("📊 Generate Comparison", variant="primary")
+            with gr.Row():
+                radar_plot = gr.Plot(label="📈 Radar Chart")
+            compare_table = gr.Dataframe(label="📊 Comparison Table")
+
+        with gr.Tab("🎨 Custom Weights"):
+            gr.Markdown("### Create Your Own Preset")
+            gr.Markdown("Adjust weights for each metric (must sum to 1.0)")
+            with gr.Row():
+                with gr.Column():
+                    w_textbook = gr.Slider(0, 1, 0.12, step=0.01, label="📚 Textbook Knowledge")
+                    w_popculture = gr.Slider(0, 1, 0.08, step=0.01, label="🎬 Pop Culture")
+                    w_worldmodel = gr.Slider(0, 1, 0.10, step=0.01, label="🌍 World Model")
+                    w_instruction = gr.Slider(0, 1, 0.10, step=0.01, label="📋 Instruction Following")
+                    w_style = gr.Slider(0, 1, 0.25, step=0.01, label="✍️ Writing Style")
+                with gr.Column():
+                    w_originality = gr.Slider(0, 1, 0.10, step=0.01, label="✨ Originality")
+                    w_dialogue = gr.Slider(0, 1, 0.15, step=0.01, label="💬 Dialogue Balance")
+                    w_unbound = gr.Slider(0, 1, 0.05, step=0.01, label="🔓 Unbound")
+                    w_redundancy = gr.Slider(0, 1, 0.05, step=0.01, label="🧹 Low Redundancy")
+            weight_sum_display = gr.Markdown("**Total Weight:** 1.00")
+            calc_custom_btn = gr.Button("🎯 Calculate Custom Score", variant="primary")
+            custom_results = gr.Dataframe(label="Top 50 Models")
+
+        with gr.Tab("📖 About"):
+                    gr.Markdown(f"""
+                    # 🏆 About UGI Leaderboard v3.6
+
+                    ## 🎯 Presets Explained
+
+                    ### 🌌 Divine RP
+                    Perfect balance for roleplay and creative storytelling. Emphasizes writing style (25%), dialogue (15%), and world knowledge.
+
+                    ### 🌶️ Erotic Storyteller
+                    Optimized for NSFW creative content. High unbound weight (30%), NSFW tone (15%).
+
+                    ### 💎 Perfect Balance (NEW)
+                    **Hybrid Score (Min × Geometric Mean).** Requires consistency across all objective metrics (Knowledge, Logic, Style, Structure). Rewards models that are "good at everything" and punishes those with even one weak spot.
+
+                    ### ⚖️ No Weak Spots (NEW)
+                    **Harmonic Mean.** Extremely strict. One failing metric (e.g., poor instruction following) will destroy the entire score, regardless of how good the other metrics are.
+
+                    ### 🤖 T-800 Logic
+                    Pure logic and knowledge. Prioritizes textbook (40%) and world model (35%).
+
+                    ### ✒️ Literary Virtuoso
+                    Literary quality above all. Writing style (35%), originality (30%), low redundancy (15%).
+
+                    ### 🎲 Dungeon Master
+                    World-building specialist. World model (30%), combined knowledge (30%).
+
+                    ### 🌑 Dark Novelist
+                    Dark fiction specialist. Dark tone (25%), writing style (25%), hazardous (15%).
+
+                    ### 🧼 Anti-Slop
+                    Maximum originality. Fights generic outputs with originality (45%) and redundancy penalties (35%).
+
+                    ### 🎯 Concise Assistant
+                    Direct and efficient. Instruction (35%), low redundancy (30%).
+
+                    ### 🎪 Entertainment Savant
+                    Pop culture expert. Pop culture (40%), entertainment (25%).
+
+                    ### 🔬 Unfiltered Scholar
+                    Uncensored knowledge. Textbook (30%), hazardous (25%), unbound (20%).
+
+                    ### ⚡ Efficiency King
+                    Best performance per parameter. Calculated as: `Divine RP Score / (Params ^ 0.4)`.
+
+                    ---
+
+                    ## 🏷️ Badges Key
+
+                    - **🆕** = **Fresh**: Tested within the last 7 days.
+                    - **🧠** = **Thinking**: Uses Chain-of-Thought (CoT) or reasoning tokens.
+                    - **🔞** = **NSFW**: High frequency of explicit content generation.
+                    - **📉** = **Repetitive**: Detected repetition loops in outputs.
+                    - **🤏** = **Pocket**: Efficient model with ≤ 10B parameters.
+                    - **🐳** = **Giant**: Massive model with ≥ 70B parameters.
+
+                    ---
+
+                    ## 📊 Scoring System (v3.6 Updated)
+
+                    ### 1. Weighted Average (Smart Handling)
+                    Unlike previous versions that filled missing data with artificial values, **v3.6 uses dynamic re-weighting**.
+                    - If a model lacks a specific metric (e.g., "Music Theory"), that metric is excluded from the calculation.
+                    - The weights of the remaining metrics are scaled up proportionally to sum to 1.0.
+                    - **Penalty:** If a model has data for less than **{int(INSUFFICIENT_DATA_THRESHOLD*100)}%** of the preset's total weight, the final score is multiplied by **{INSUFFICIENT_DATA_PENALTY}**.
+
+                    ### 2. Robust Normalization
+                    Metrics are normalized using the **5th and 95th percentiles** to ignore outliers.
+                    - `Score = (Value - P5) / (P95 - P5)`
+                    - This ensures that one extremely high-scoring model doesn't squash everyone else to zero.
+
+                    ### 3. Composites
+                    - **World Model**: Average of Cooking, GeoGuesser, Weight Estimation, and Music Theory.
+                    - **Unbound**: Average of Direct Refusal (inverse), Entertainment, and Hazardous knowledge.
+                    - **Redundancy**: Combination of Semantic and Lexical redundancy metrics.
+
+                    ---
+
+                    ## 🚀 Technical Details
+                    - **Framework**: Gradio 5.x + Pandas + Plotly
+                    - **Caching**: Data is cached for {int(CACHE_DURATION/3600)} hours to speed up loading.
+                    - **Filters**: You can now filter by specific model architectures and robustness levels.
+                    
+                    *Last Updated: {loader.last_updated}*
+                    """)
+
+        diag_btn = None
+        clear_btn = None
+        
+        if SHOW_DIAGNOSTICS:
+            with gr.Tab("🛠️ Diagnostics"):
+                with gr.Row():
+                    diag_btn = gr.Button("🧪 Run Diagnostics", variant="primary")
+                    clear_btn = gr.Button("🗑️ Clear Cache & Reload Data", variant="stop")
+                
+                cache_status = gr.Textbox(label="Status", lines=3, interactive=False)
+                diag_report = gr.Code(label="📋 Diagnostic Report", language="markdown")
+                
+                with gr.Accordion("🔍 Anomalies", open=False):
+                    anomalies_table = gr.Dataframe(label="Detected Anomalies")
+                with gr.Accordion("📊 Statistics", open=False):
+                    stats_table = gr.Dataframe(label="Normalization Statistics")
+
+    # === INTERACTIONS (BINDING) ===
+    
+    filter_inputs = [df_state, preset_dropdown, search_box, param_min, param_max, proprietary_check, 
+                     moe_check, thinking_mode, model_types, arch_dropdown, top_n_slider, balance_filter]
+    filter_outputs = [leaderboard_table, filtered_raw_state]
+
+    for inp in filter_inputs[1:]:
+        inp.change(filter_leaderboard, inputs=filter_inputs, outputs=filter_outputs)
+
+    def refresh_handler():
+        global _CACHED_DF
+        _CACHED_DF = None
+        loader.clear_cache()
+        new_df = get_dataframe()
+        return new_df, gr.update(choices=["All"] + get_architecture_choices(new_df))
+
+    refresh_btn.click(refresh_handler, outputs=[df_state, arch_dropdown]).then(filter_leaderboard, inputs=filter_inputs, outputs=filter_outputs)
+
+    def export_handler(df):
+        if df is None or df.empty:
+            return gr.update(value=None, visible=False)
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.csv', mode='w', encoding='utf-8')
+        df.to_csv(temp_file.name, index=False)
+        return gr.update(value=temp_file.name, visible=True)
+
+    export_btn.click(export_handler, inputs=[filtered_raw_state], outputs=[export_file])
+
+    # Compare logic
+    search_compare.change(lambda df, q: gr.update(choices=df[df['author/model_name'].str.contains(q, case=False, na=False)]['author/model_name'].head(10).tolist() if q and df is not None else []), inputs=[df_state, search_compare], outputs=[search_results_radio])
+    add_model_btn.click(lambda t, s: t + ("\n" if t else "") + s if s else t, inputs=[compare_textbox, search_results_radio], outputs=[compare_textbox])
+    compare_btn.click(compare_models, inputs=[df_state, compare_textbox], outputs=[radar_plot, compare_table])
+    
+    # Custom Weights logic
+    weight_inputs = [w_textbook, w_popculture, w_worldmodel, w_instruction, w_style, w_originality, w_dialogue, w_unbound, w_redundancy]
+    for w in weight_inputs: w.change(lambda *args: f"**Total Weight:** {sum(args):.2f}", inputs=weight_inputs, outputs=[weight_sum_display])
+    calc_custom_btn.click(lambda *args: calculate_custom_score(get_dataframe(), {k: v for k, v in zip(['Textbook', 'Pop Culture', 'World Model', 'Instruction', 'Writing Style', 'Originality', 'Dialogue', 'Unbound', 'Redundancy'], args)}), inputs=weight_inputs, outputs=[custom_results])
+
+    if SHOW_DIAGNOSTICS and diag_btn and clear_btn:
+        diag_btn.click(run_diagnostics, inputs=[df_state], outputs=[diag_report, anomalies_table, stats_table])
+        clear_btn.click(clear_and_reload, outputs=[df_state, cache_status]).then(filter_leaderboard, inputs=filter_inputs, outputs=filter_outputs)
+
+    demo.load(filter_leaderboard, inputs=filter_inputs, outputs=filter_outputs)
+
+if __name__ == "__main__":
+    demo.launch()

config.py

@@ -0,0 +1,50 @@
+"""Configuration constants for UGI Leaderboard."""
+
+# Caching
+CSV_URL = "https://huggingface.co/spaces/DontPlanToEnd/UGI-Leaderboard/resolve/main/ugi-leaderboard-data.csv"
+CACHE_FILE = "data_cache.parquet"
+META_FILE = "meta.json"
+CACHE_DURATION = 6 * 3600  # 6 hours
+
+# Scoring Penalties
+INSUFFICIENT_DATA_THRESHOLD = 0.70
+INSUFFICIENT_DATA_PENALTY = 0.3
+REPETITION_BASE = 0.85
+THINKING_THRESHOLD = 5000
+THINKING_PENALTY_POWER = 0.5
+
+# Gaussian Targets
+GAUSSIAN_DIALOGUE_TARGET = 0.38
+GAUSSIAN_DIALOGUE_SIGMA = 0.15
+GAUSSIAN_VERBNOUN_TARGET = 0.85
+GAUSSIAN_VERBNOUN_SIGMA = 0.2
+
+# Normalization
+ROBUST_QUANTILE_LOW = 0.05
+ROBUST_QUANTILE_HIGH = 0.95
+MIN_STD_THRESHOLD = 1e-9
+
+# UI Defaults
+MAX_PARAMS_SLIDER = 500
+DEFAULT_TOP_N = 50
+FORCE_REFRESH_ON_STARTUP = True
+
+# === DEV MODE ===
+SHOW_DIAGNOSTICS = False
+
+# Objective Metrics List for Balance/Robustness Presets
+# FIXED: Removed 'gauss_VerbNoun' due to scale mismatch
+BALANCE_METRICS_LIST = [
+    'norm_Textbook',      # Knowledge
+    'norm_PopCulture',    # Culture
+    'norm_Recipe',        # Logic
+    'norm_Geo',           # Geography
+    'norm_Weight',        # Physics
+    'norm_Music',         # Music
+    'norm_Style',         # Style
+    'norm_Originality',   # Originality
+    'gauss_Dialogue',     # Structure
+    'norm_Instruction',   # Precision
+    'inv_Semantic',       # Coherence
+    'inv_Lexical'         # Variety
+]

data_loader.py

@@ -0,0 +1,243 @@
+import pandas as pd
+import numpy as np
+import os, time, json
+from datetime import datetime, timedelta
+from config import *
+
+class DataLoader:
+    def __init__(self):
+        self.df, self.last_updated = None, "Unknown"
+
+    def load_data(self, force_refresh=False):
+        """Загрузка данных с поддержкой принудительного обновления."""
+        if force_refresh or self._needs_update():
+            print("🔄 Cache expired or missing. Fetching fresh data...")
+            try:
+                self.df = self._process_data(pd.read_csv(CSV_URL, on_bad_lines='skip'))
+                self._save_cache()
+                print(f"✅ Data processed. Rows: {len(self.df)}")
+            except Exception as e:
+                print(f"⚠️ Error fetching data: {e}")
+                self.df = pd.read_parquet(CACHE_FILE) if os.path.exists(CACHE_FILE) else pd.DataFrame()
+                self._load_meta()
+        else:
+            print("⚡ Loading from cache.")
+            self.df = pd.read_parquet(CACHE_FILE)
+            self._load_meta()
+        return self.df
+
+    def _needs_update(self):
+        """Проверка необходимости обновления кеша."""
+        if not os.path.exists(CACHE_FILE) or not os.path.exists(META_FILE):
+            return True
+        try:
+            with open(META_FILE) as f:
+                return (time.time() - json.load(f).get('timestamp', 0)) > CACHE_DURATION
+        except:
+            return True
+
+    def clear_cache(self):
+        """Принудительная очистка всех файлов кеша."""
+        deleted = []
+        for file in [CACHE_FILE, META_FILE]:
+            if os.path.exists(file):
+                try:
+                    os.remove(file)
+                    deleted.append(file)
+                except Exception as e:
+                    print(f"⚠️ Failed to delete {file}: {e}")
+        if deleted:
+            print(f"🗑️ Cleared cache: {', '.join(deleted)}")
+        return deleted
+
+    def _save_cache(self):
+        self.df.to_parquet(CACHE_FILE)
+        with open(META_FILE, 'w') as f:
+            json.dump({'timestamp': time.time()}, f)
+        self.last_updated = datetime.fromtimestamp(time.time()).strftime("%Y-%m-%d %H:%M")
+
+    def _load_meta(self):
+        try:
+            with open(META_FILE) as f:
+                self.last_updated = datetime.fromtimestamp(json.load(f)['timestamp']).strftime("%Y-%m-%d %H:%M")
+        except:
+            pass
+
+    def _clean_column(self, series, scale=1.0):
+        """Безопасная очистка и масштабирование числовых колонок."""
+        if pd.api.types.is_string_dtype(series) or series.dtype == 'object':
+            series = series.astype(str).str.rstrip('%')
+        series = pd.to_numeric(series, errors='coerce')
+        return series / scale if scale > 1 else series
+
+    def _get_model_type(self, row):
+        """Определение типа модели для сортировки."""
+        # Returns: (sort_value, short_code, full_name)
+        if pd.isna(row.get('Total Parameters')) or row.get('Total Parameters', 0) <= 0:
+            return (3, 'P', 'Proprietary')
+        
+        is_foundation = row.get('Is Foundation', False)
+        is_merged = row.get('Is Merged', False)
+        
+        if is_foundation and not is_merged:
+            return (0, 'B', 'Base')
+        if is_merged:
+            return (2, 'M', 'Merge')
+        if row.get('Is Finetuned', False) and not is_merged:
+            return (1, 'F', 'Finetune')
+            
+        return (4, '', 'Unknown')
+
+    def _process_data(self, df):
+        """Основной пайплайн обработки."""
+        print("⚙️ Processing pipeline started...")
+        df.columns = df.columns.str.strip()
+
+        # === 1. COLUMN GROUPS ===
+        col_groups = {
+            'percentage': (['Textbook', 'Pop Culture', 'Dialogue_Percentage', 'Verb_to_Noun_Ratio', 
+                           'Show Rec Correlation', 'avg_length_error_pct'], 100.0),
+            'already_norm': (['avg_writing_style_score', 'originality_score', 'internal_semantic_redundancy',
+                             'lexical_stuckness', 'wm_recipe_percent_error_score', 'wm_geoguessr_mae_score',
+                             'wm_weight_percent_error_score', 'wm_music_mae_score'], 1.0),
+            'numeric': (['Total Parameters', 'Active Parameters', 'Repetition Interrupts', 'Avg Thinking Chars'], 1.0),
+            'scale_10': (['avg_nsfw_score', 'avg_dark_score', 'Hazardous', 'Entertainment', 
+                         'SocPol', 'W/10-Direct', 'W/10-Adherence'], 10.0)
+        }
+
+        for group, (cols, scale) in col_groups.items():
+            for col in cols:
+                if col in df.columns:
+                    df[col] = self._clean_column(df[col], scale)
+                    if group == 'already_norm':
+                        df[col] = df[col].clip(0, 1.0)
+                else:
+                    df[col] = np.nan
+
+        # === 2. BOOLEANS & STRINGS ===
+        if 'Is Thinking Model' in df.columns:
+            df['Is Thinking Model'] = (
+                df['Is Thinking Model'].astype(str).fillna('FALSE').str.strip().str.upper() == 'TRUE'
+            )
+        else:
+            df['Is Thinking Model'] = False
+
+        df['Architecture'] = df.get('Architecture', 'Unknown').fillna('Unknown').replace('null', 'Unknown')
+
+        # === 3. MODEL TYPES & DATES ===
+        type_data = df.apply(self._get_model_type, axis=1)
+        df['_type_sort'] = type_data.apply(lambda x: x[0])
+        df['Type_Code'] = type_data.apply(lambda x: x[1])
+        df['Type_Name'] = type_data.apply(lambda x: x[2])
+
+        if 'Test Date' in df.columns:
+            df['Test Date'] = pd.to_datetime(df['Test Date'], format='%m/%d/%Y', errors='coerce')
+            week_ago = datetime.now() - timedelta(days=7)
+            df['Is_New'] = df['Test Date'].apply(lambda x: True if pd.notna(x) and x >= week_ago else False)
+            df['Test Date'] = df['Test Date'].dt.strftime('%Y-%m-%d')
+        else:
+            df['Is_New'] = False
+
+        # === 4. PENALTIES ===
+        df['penalty_repetition'] = REPETITION_BASE ** df['Repetition Interrupts'].fillna(0)
+        
+        chars = df['Avg Thinking Chars'].fillna(0)
+        df['penalty_thinking'] = np.where(
+            df['Is Thinking Model'] & (chars > THINKING_THRESHOLD),
+            np.power(THINKING_THRESHOLD / (chars + 1e-6), THINKING_PENALTY_POWER).clip(upper=1.0),
+            1.0
+        )
+
+        # === 5. GAUSSIAN SCORES ===
+        df['gauss_Dialogue'] = self._gaussian_score(df['Dialogue_Percentage'], GAUSSIAN_DIALOGUE_TARGET, GAUSSIAN_DIALOGUE_SIGMA)
+        df['gauss_VerbNoun'] = self._gaussian_score(df['Verb_to_Noun_Ratio'], GAUSSIAN_VERBNOUN_TARGET, GAUSSIAN_VERBNOUN_SIGMA)
+
+        # === 6. NORMALIZATION ===
+        norm_config = {
+            # Direct normalization (Higher = Better)
+            'norm_Textbook': ('Textbook', 'direct'),
+            'norm_PopCulture': ('Pop Culture', 'direct'),
+            'norm_ShowRec': ('Show Rec Correlation', 'direct'),
+            'norm_Style': ('avg_writing_style_score', 'direct'),
+            'norm_Originality': ('originality_score', 'direct'),
+            'norm_NSFW': ('avg_nsfw_score', 'direct'),
+            'norm_Dark': ('avg_dark_score', 'direct'),
+            'norm_Hazardous': ('Hazardous', 'direct'),
+            'norm_Entertainment': ('Entertainment', 'direct'),
+            'norm_Instruction': ('W/10-Adherence', 'direct'),
+            'norm_Unbound_Direct': ('W/10-Direct', 'direct'),
+            # World Model (Direct)
+            'norm_Recipe': ('wm_recipe_percent_error_score', 'direct'),
+            'norm_Geo': ('wm_geoguessr_mae_score', 'direct'),
+            'norm_Weight': ('wm_weight_percent_error_score', 'direct'),
+            'norm_Music': ('wm_music_mae_score', 'direct'),
+            # Inverse normalization (Higher = Worse)
+            'inv_Semantic': ('internal_semantic_redundancy', 'inverse'),
+            'inv_Lexical': ('lexical_stuckness', 'inverse'),
+            'inv_LengthErr': ('avg_length_error_pct', 'inverse')
+        }
+
+        for dest, (src, mode) in norm_config.items():
+            if src in df.columns:
+                df[dest] = self._inverse_normalize(df[src]) if mode == 'inverse' else self._robust_normalize(df[src])
+            else:
+                df[dest] = np.nan
+
+        # === 7. COMPOSITES ===
+        composites = {
+            'Composite_WorldModel': ['norm_Recipe', 'norm_Geo', 'norm_Weight', 'norm_Music'],
+            'Composite_Unbound': ['norm_Unbound_Direct', 'norm_Entertainment', 'norm_Hazardous'],
+            'Composite_Redundancy': ['inv_Semantic', 'inv_Lexical']
+        }
+        for comp, cols in composites.items():
+            df[comp] = df[cols].mean(axis=1, skipna=False)
+
+        # === 8. SMART NA FILLING (For Sorting) ===
+        print("🔧 Applying smart NA handling for sorting...")
+        higher_is_better = [
+            'Show Rec Correlation', 'norm_Textbook', 'norm_PopCulture', 'norm_ShowRec',
+            'norm_Style', 'norm_Originality', 'Composite_WorldModel', 'Composite_Unbound',
+            'norm_Recipe', 'norm_Geo', 'norm_Weight', 'norm_Music'
+        ]
+        for col in higher_is_better:
+            if col in df.columns:
+                df[col] = df[col].fillna(-99999)
+
+        lower_is_better = [
+            'avg_length_error_pct', 'internal_semantic_redundancy', 'lexical_stuckness',
+            'inv_Semantic', 'inv_Lexical', 'inv_LengthErr'
+        ]
+        for col in lower_is_better:
+            if col in df.columns:
+                df[col] = df[col].fillna(99999)
+
+        print("✅ Processing complete!")
+        return df
+
+    def _robust_normalize(self, series):
+        """Robust normalization with divide-by-zero protection."""
+        valid = series.dropna()
+        if valid.empty or valid.std() < MIN_STD_THRESHOLD:
+            return pd.Series(np.nan, index=series.index)
+        q05, q95 = valid.quantile(ROBUST_QUANTILE_LOW), valid.quantile(ROBUST_QUANTILE_HIGH)
+        denominator = q95 - q05
+        if abs(denominator) < MIN_STD_THRESHOLD:
+            return pd.Series(np.nan, index=series.index)
+        return (series.clip(q05, q95) - q05) / denominator
+
+    def _inverse_normalize(self, series):
+        """Inverse robust normalization."""
+        valid = series.dropna()
+        if valid.empty or valid.std() < MIN_STD_THRESHOLD:
+            return pd.Series(np.nan, index=series.index)
+        p5, p95 = valid.quantile(ROBUST_QUANTILE_LOW), valid.quantile(ROBUST_QUANTILE_HIGH)
+        denominator = p95 - p5
+        if abs(denominator) < MIN_STD_THRESHOLD:
+            return pd.Series(np.nan, index=series.index)
+        return (p95 - series.clip(p5, p95)) / denominator
+
+    def _gaussian_score(self, series, target, sigma):
+        return np.exp(-((series - target) ** 2) / (2 * sigma ** 2))
+
+# Create instance
+loader = DataLoader()

dev_tools.py

@@ -0,0 +1,102 @@
+import pandas as pd
+import numpy as np
+from datetime import datetime
+from scoring import METRIC_MAP, PRESET_CONFIGS
+
+class DevSuite:
+    def __init__(self, df):
+        self.df = df
+        self.report = {
+            "summary": {"critical": 0, "medium": 0, "low": 0, "tests_passed": 0},
+            "critical_issues": [], "medium_issues": [], "low_issues": [], "anomalies": [], "statistics": {}
+        }
+
+    def run_all_tests(self):
+        if self.df is None or self.df.empty:
+            self._add_issue("critical", "DataFrame is empty or None.")
+            return self._generate_markdown_report()
+        
+        self._test_normalization_bounds()
+        self._test_parameter_scaling()
+        self._test_badges_logic()
+        self._test_weight_sums()
+        self._test_score_ranges()
+        self._collect_normalization_stats()
+        
+        return self._generate_markdown_report()
+
+    def get_anomalies_df(self):
+        return pd.DataFrame(self.report["anomalies"]) if self.report["anomalies"] else pd.DataFrame()
+
+    def get_statistics_df(self):
+        return pd.DataFrame(self.report["statistics"]).T if self.report["statistics"] else pd.DataFrame()
+
+    def _test_normalization_bounds(self):
+        norm_cols = [v[0] for k, v in METRIC_MAP.items() if v[0] in self.df.columns]
+        for col in norm_cols:
+            # Ignore sentinel values
+            values = self.df[col].dropna()
+            values = values[values.abs() < 90000]
+            if values.empty: continue
+            if values.min() < -1e-6 or values.max() > 1.0 + 1e-6:
+                self._add_issue("critical", f"Normalization bounds broken in '{col}'")
+            else:
+                self.report["summary"]["tests_passed"] += 1
+
+    def _test_parameter_scaling(self):
+        if 'Total Parameters' in self.df.columns:
+            # Check a known big model
+            big_model = self.df[self.df['author/model_name'].str.contains("Llama-3.1-405B", case=False, na=False)]
+            if not big_model.empty and big_model.iloc[0]['Total Parameters'] < 400:
+                self._add_issue("critical", "Parameter scaling issue: 405B model appears small.")
+            else:
+                self.report["summary"]["tests_passed"] += 1
+
+    def _test_badges_logic(self):
+        if 'Badges' in self.df.columns:
+            pocket = self.df[self.df['Badges'].str.contains("🤏")]
+            if not pocket.empty and pocket['Total Parameters'].max() > 15:
+                self._add_issue("medium", "Pocket badge assigned to large model.")
+            else:
+                self.report["summary"]["tests_passed"] += 1
+
+    def _test_weight_sums(self):
+        for preset, weights in PRESET_CONFIGS.items():
+            if isinstance(weights, dict) and 'special_type' not in weights:
+                if abs(sum(weights.values()) - 1.0) > 1e-4:
+                    self._add_issue("medium", f"Preset '{preset}' weights != 1.0")
+                else:
+                    self.report["summary"]["tests_passed"] += 1
+
+    def _test_score_ranges(self):
+        score_cols = [c for c in self.df.columns if c.startswith("Score_")]
+        for col in score_cols:
+            if 'Efficiency' in col: continue
+            vals = self.df[col].dropna()
+            if not vals.empty and (vals.min() < 0 or vals.max() > 1.1):
+                self._add_issue("medium", f"Score out of range in {col}")
+            else:
+                self.report["summary"]["tests_passed"] += 1
+
+    def _collect_normalization_stats(self):
+        norm_cols = [v[0] for k, v in METRIC_MAP.items() if v[0] in self.df.columns]
+        for col in norm_cols:
+            values = self.df[col].dropna()
+            values = values[values.abs() < 90000]
+            self.report["statistics"][col] = {
+                "min": float(values.min()) if not values.empty else 0,
+                "max": float(values.max()) if not values.empty else 0,
+                "mean": float(values.mean()) if not values.empty else 0
+            }
+
+    def _add_issue(self, level, message):
+        self.report["summary"][level] += 1
+        self.report[f"{level}_issues"].append(message)
+
+    def _generate_markdown_report(self):
+        r = self.report
+        md = [f"## Executive Summary\n- Passed: {r['summary']['tests_passed']}\n- Critical: {r['summary']['critical']}"]
+        if r['critical_issues']:
+            md.append("### Critical Issues")
+            md.extend([f"- {i}" for i in r['critical_issues']])
+        return "\n".join(md)

requirements.txt

@@ -0,0 +1,6 @@
+gradio>=5.0.0
+pandas>=2.0.0
+numpy>=1.24.0
+pyarrow>=12.0.0
+requests>=2.0.0
+plotly>=5.0.0

scoring.py

@@ -0,0 +1,203 @@
+import pandas as pd
+import numpy as np
+from config import *
+
+METRIC_MAP = {
+    'Textbook': ('norm_Textbook', 'Textbook'),
+    'Pop Culture': ('norm_PopCulture', 'Pop Culture'),
+    'World Model': ('Composite_WorldModel', 'Composite_WorldModel'),
+    'Instruction': ('norm_Instruction', 'W/10-Adherence'),
+    'Writing Style': ('norm_Style', 'avg_writing_style_score'),
+    'Originality': ('norm_Originality', 'originality_score'),
+    'Dialogue': ('gauss_Dialogue', 'Dialogue_Percentage'),
+    'Unbound': ('Composite_Unbound', 'Composite_Unbound'),
+    'NSFW Tone': ('norm_NSFW', 'avg_nsfw_score'),
+    'Dark Tone': ('norm_Dark', 'avg_dark_score'),
+    'Redundancy': ('Composite_Redundancy', 'Composite_Redundancy'),
+    'Hazardous': ('norm_Hazardous', 'Hazardous'),
+    'Entertainment': ('norm_Entertainment', 'Entertainment'),
+    'Length Acc': ('inv_LengthErr', 'avg_length_error_pct'),
+    'VerbNoun': ('gauss_VerbNoun', 'Verb_to_Noun_Ratio')
+}
+
+PRESET_CONFIGS = {
+    "🌌 Divine RP": {
+        'Textbook': 0.12, 'Pop Culture': 0.08, 'World Model': 0.10,
+        'Instruction': 0.10, 'Writing Style': 0.25, 'Originality': 0.10,
+        'Dialogue': 0.15, 'Unbound': 0.05, 'Redundancy': 0.05
+    },
+    "🌶️ Erotic Storyteller": {
+        'World Model': 0.10, 'Instruction': 0.05, 'Writing Style': 0.15,
+        'Originality': 0.05, 'Dialogue': 0.15, 'Unbound': 0.30,
+        'NSFW Tone': 0.15, 'Redundancy': 0.05
+    },
+    "🤖 T-800 Logic": {
+        'Textbook': 0.40, 'World Model': 0.35, 'Instruction': 0.20, 'Redundancy': 0.05
+    },
+    "✒️ Literary Virtuoso": {
+        'Writing Style': 0.35, 'Originality': 0.30, 'Redundancy': 0.15,
+        'Instruction': 0.10, 'Dialogue': 0.10
+    },
+    "🎲 Dungeon Master": {
+        'World Model': 0.30, 'Textbook': 0.15, 'Pop Culture': 0.15,
+        'Instruction': 0.20, 'Originality': 0.10, 'Dialogue': 0.10
+    },
+    "🌑 Dark Novelist": {
+        'Dark Tone': 0.25, 'Writing Style': 0.25, 'Hazardous': 0.15,
+        'Originality': 0.20, 'Unbound': 0.15
+    },
+    "🧼 Anti-Slop": {
+        'Originality': 0.45, 'Redundancy': 0.35, 'Writing Style': 0.10, 'Instruction': 0.10
+    },
+    "🎯 Concise Assistant": {
+        'Instruction': 0.35, 'Redundancy': 0.30, 'Textbook': 0.20,
+        'World Model': 0.10, 'Dialogue': 0.05
+    },
+    "🎪 Entertainment Savant": {
+        'Pop Culture': 0.40, 'Entertainment': 0.25, 'Instruction': 0.15,
+        'Writing Style': 0.10, 'Dialogue': 0.10
+    },
+    "🔬 Unfiltered Scholar": {
+        'Textbook': 0.30, 'Hazardous': 0.25, 'Unbound': 0.20,
+        'Instruction': 0.15, 'Originality': 0.05, 'Redundancy': 0.05
+    },
+    # === BALANCE PRESETS ===
+    "💎 Perfect Balance": {
+        'special_type': 'balanced',
+        'metrics': BALANCE_METRICS_LIST
+    },
+    "⚖️ No Weak Spots": {
+        'special_type': 'harmonic',
+        'metrics': BALANCE_METRICS_LIST
+    }
+}
+
+class ScoringEngine:
+    def __init__(self, df):
+        self.df = df.copy()
+
+    def calculate_all(self):
+        if self.df.empty:
+            return self.df
+
+        print("🧮 Calculating scores...")
+
+        for preset_name, config in PRESET_CONFIGS.items():
+            col_name = f"Score_{preset_name}"
+            
+            if isinstance(config, dict) and 'special_type' in config:
+                if config['special_type'] == 'balanced':
+                    self.df[col_name] = self._calculate_balanced_score(config['metrics'])
+                elif config['special_type'] == 'harmonic':
+                    self.df[col_name] = self._calculate_harmonic_score(config['metrics'])
+            else:
+                self.df[col_name] = self.calculate_weighted_score(config)
+
+        # Efficiency King
+        params = self.df['Total Parameters'].fillna(0).replace(0, 9999)
+        base_score = self.df.get("Score_🌌 Divine RP", 0)
+        divisor = np.power(params, 0.4)
+        self.df["Score_⚡ Efficiency King"] = (base_score / divisor) * 10
+        self.df["Score_⚡ Efficiency King"] = self.df["Score_⚡ Efficiency King"].fillna(0)
+
+        self.df["Score_🤏 Pocket Genius"] = self.df.get("Score_🌌 Divine RP", 0)
+
+        self._generate_badges_vectorized()
+
+        # Round scores
+        score_cols = [c for c in self.df.columns if c.startswith("Score_")]
+        self.df[score_cols] = self.df[score_cols].round(3)
+
+        return self.df
+
+    def calculate_weighted_score(self, weights_dict):
+        """Standard weighted average logic ignoring sentinel values."""
+        weighted_sum = pd.Series(0.0, index=self.df.index)
+        total_valid_weight = pd.Series(0.0, index=self.df.index)
+        total_preset_weight = sum(weights_dict.values())
+
+        for key, weight in weights_dict.items():
+            if key not in METRIC_MAP: continue
+            norm_col, _ = METRIC_MAP[key]
+            if norm_col not in self.df.columns: continue
+
+            values = self.df[norm_col]
+            mask = values.notna() & (values.abs() < 90000)
+            
+            weighted_sum[mask] += values[mask] * weight
+            total_valid_weight[mask] += weight
+
+        final_score = weighted_sum / total_valid_weight.replace(0, np.nan)
+        final_score = final_score.fillna(0.0)
+
+        # Penalties
+        valid_weight_ratio = total_valid_weight / total_preset_weight
+        insufficient_mask = valid_weight_ratio < INSUFFICIENT_DATA_THRESHOLD
+        final_score[insufficient_mask] *= INSUFFICIENT_DATA_PENALTY
+
+        self._apply_global_penalties(final_score)
+        return final_score
+
+    def _calculate_balanced_score(self, metric_keys):
+        """Hybrid: sqrt(min) * sqrt(geometric_mean)."""
+        return self._calculate_special_score(metric_keys, method='hybrid')
+
+    def _calculate_harmonic_score(self, metric_keys):
+        """Harmonic Mean."""
+        return self._calculate_special_score(metric_keys, method='harmonic')
+
+    def _calculate_special_score(self, metric_keys, method):
+        cols_to_use = [col for col in metric_keys if col in self.df.columns]
+        if not cols_to_use:
+            return pd.Series(0.0, index=self.df.index)
+
+        subset = self.df[cols_to_use].copy()
+        
+        # Filter out sentinel values
+        for col in subset.columns:
+            subset[col] = subset[col].where(subset[col].abs() < 90000)
+
+        # FIXED: Soft NaN handling ( (0.3 + median)/2 )
+        for col in subset.columns:
+            col_median = subset[col].median()
+            if pd.isna(col_median) or col_median <= 0:
+                fill_val = 0.3
+            else:
+                fill_val = (0.3 + col_median) / 2
+            subset[col] = subset[col].fillna(fill_val)
+
+        # FIXED: Softer clip (0.1 instead of 0.01)
+        subset = subset.clip(lower=0.1, upper=1.0)
+
+        if method == 'hybrid':
+            min_score = subset.min(axis=1)
+            log_mean = np.log(subset).mean(axis=1)
+            geom_score = np.exp(log_mean)
+            final_score = np.sqrt(min_score) * np.sqrt(geom_score)
+            
+        elif method == 'harmonic':
+            n = len(cols_to_use)
+            sum_inverse = (1.0 / subset).sum(axis=1)
+            final_score = n / sum_inverse
+
+        self._apply_global_penalties(final_score)
+        return final_score
+
+    def _apply_global_penalties(self, score_series):
+        if 'penalty_repetition' in self.df.columns:
+            score_series *= self.df['penalty_repetition'].fillna(1.0)
+        if 'penalty_thinking' in self.df.columns:
+            score_series *= self.df['penalty_thinking'].fillna(1.0)
+
+    def _generate_badges_vectorized(self):
+        badges = pd.Series("", index=self.df.index)
+        if 'Is_New' in self.df: badges += np.where(self.df['Is_New'], "🆕 ", "")
+        if 'Is Thinking Model' in self.df: badges += np.where(self.df['Is Thinking Model'], "🧠 ", "")
+        if 'norm_NSFW' in self.df: badges += np.where((self.df['norm_NSFW'] > 0.5) & (self.df['norm_NSFW'] < 90000), "🔞 ", "")
+        if 'Repetition Interrupts' in self.df: badges += np.where(self.df['Repetition Interrupts'] >= 1.0, "📉 ", "")
+        
+        params = self.df.get('Total Parameters', 999).fillna(999)
+        badges += np.where((params > 0) & (params <= 10), "🤏 ", "")
+        badges += np.where(params >= 70, "🐳 ", "")
+        
+        self.df['Badges'] = badges.str.strip()