Upload folder using huggingface_hub

__pycache__/app.cpython-311.pyc

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a5a5f57c1929a7fa923f92f6a6522741c51bb6b424ff1abf62a5084a0f3d0d9e
-size 126179
+oid sha256:64e05fdbfb34e223a6459477a52724bfa95d8ba16076b2527b84a60063adb015
+size 123258

app.py

@@ -1035,204 +1035,187 @@ def _create_error_figure(result: Dict[str, Any]) -> go.Figure:
     return fig
 
 def _create_comprehensive_dashboard(result: Dict[str, Any]) -> go.Figure:
-    """Create comprehensive privacy dashboard with multiple visualizations"""
+    """Create simplified privacy dashboard focused on key metrics"""
     from plotly.subplots import make_subplots
     
-    # Create subplot structure with better spacing
+    # Simplified 2x2 layout focusing on essential information
     fig = make_subplots(
-        rows=2, cols=3,
+        rows=2, cols=2,
         subplot_titles=(
-            "Distance Distribution Analysis", 
-            "Privacy Risk Assessment", 
-            "Data Quality Indicators",
-            "Dataset Overview",
-            "Privacy Bounds Comparison",
-            "Processing Pipeline Status"
+            "Distance Statistics", 
+            "Privacy Risk Level", 
+            "Data Quality Assessment",
+            "Key Metrics Summary"
         ),
         specs=[
-            [{"type": "bar"}, {"type": "indicator"}, {"type": "scatter"}],
-            [{"type": "bar"}, {"type": "bar"}, {"type": "bar"}]
+            [{"type": "bar"}, {"type": "indicator"}],
+            [{"type": "bar"}, {"type": "table"}]
         ],
-        vertical_spacing=0.15,
-        horizontal_spacing=0.1
+        vertical_spacing=0.2,
+        horizontal_spacing=0.15
     )
     
-    _add_distance_analysis(fig, result)
-    _add_risk_assessment(fig, result)
-    _add_quality_indicators(fig, result)
-    _add_dataset_overview(fig, result)
-    _add_privacy_bounds(fig, result)
-    _add_processing_status(fig, result)
+    _add_simplified_distance_analysis(fig, result)
+    _add_simplified_risk_assessment(fig, result)
+    _add_simplified_quality_assessment(fig, result)
+    _add_key_metrics_table(fig, result)
     
-    # Enhanced layout with professional styling
+    # Clean, minimal layout
     fig.update_layout(
         title={
-            "text": "<b>Privacy Audit Dashboard</b><br><sub>Comprehensive Analysis of Synthetic Data Privacy</sub>",
+            "text": "Privacy Audit Results",
             "x": 0.5,
             "xanchor": "center",
-            "font": {"size": 20, "color": "#2c3e50"}
+            "font": {"size": 18, "color": "#000000"}
         },
-        height=700,
+        height=600,
         showlegend=False,
         plot_bgcolor="white",
-        paper_bgcolor="#f8f9fa",
-        font=dict(family="Arial, sans-serif", size=11, color="#2c3e50"),
-        margin=dict(t=120, b=50, l=50, r=50)
+        paper_bgcolor="white",
+        font=dict(family="Arial, sans-serif", size=12, color="#000000"),
+        margin=dict(t=80, b=50, l=60, r=60)
     )
     
     return fig
         
         
-def _add_distance_analysis(fig, result: Dict[str, Any]):
-    """Add enhanced distance distribution analysis"""
+def _add_simplified_distance_analysis(fig, result: Dict[str, Any]):
+    """Add simplified distance analysis focusing on key metrics"""
     stats = result.get("distance_statistics", {})
     
-    # Create meaningful distance metrics with better labeling
-    metrics = ["Mean Distance", "Median Distance", "Standard Dev", "25th Percentile", "75th Percentile"]
+    # Focus on most important metrics
+    metrics = ["Mean", "Median", "Max"]
     values = [
         stats.get("mean_nearest_distance", 0),
         stats.get("median_nearest_distance", 0),
-        stats.get("std_nearest_distance", 0),
-        stats.get("q25_nearest_distance", 0),
-        stats.get("q75_nearest_distance", 0)
+        stats.get("max_nearest_distance", 0)
     ]
     
-    # Use colorblind-friendly palette with semantic meaning
-    colors = ['#3498db', '#2ecc71', '#f39c12', '#9b59b6', '#e74c3c']
-    
+    # Use simple, accessible colors
     fig.add_trace(
         go.Bar(
             x=metrics,
             y=values,
-            marker_color=colors,
-            text=[f"{v:.6f}" if v > 0 else "0" for v in values],
+            marker_color='#2563eb',
+            marker_line=dict(color='#1e40af', width=1),
+            text=[f"{v:.4f}" if v > 0 else "0.0000" for v in values],
             textposition='outside',
-            textfont=dict(size=10, color="#2c3e50"),
-            hovertemplate="<b>%{x}</b><br>Value: %{y:.6f}<extra></extra>",
-            name="Distance Metrics"
+            textfont=dict(size=11, color="#000000"),
+            hovertemplate="<b>%{x}</b><br>%{y:.6f}<extra></extra>",
+            showlegend=False
         ),
         row=1, col=1
     )
     
-    # Customize axes for better readability
-    fig.update_xaxes(title_text="Distance Metrics", row=1, col=1, tickangle=45)
-    fig.update_yaxes(title_text="Distance Value", row=1, col=1, tickformat=".2e")
+    fig.update_xaxes(title_text="Distance Metric", row=1, col=1, title_font_size=12)
+    fig.update_yaxes(title_text="Value", row=1, col=1, title_font_size=12)
         
-def _add_risk_assessment(fig, result: Dict[str, Any]):
-    """Add enhanced privacy risk assessment gauge"""
+def _add_simplified_risk_assessment(fig, result: Dict[str, Any]):
+    """Add simplified risk assessment indicator"""
     risk_level = result.get("privacy_assessment", {}).get("risk_level", "UNKNOWN")
     epsilon = result.get("privacy_assessment", {}).get("primary_epsilon", 0)
     
-    # Enhanced risk color palette with better accessibility
+    # Simple risk color mapping
     risk_colors = {
-        "EXCEPTIONAL": "#27ae60", "VERY LOW": "#2ecc71", "LOW": "#f1c40f",
-        "MEDIUM": "#e67e22", "HIGH": "#e74c3c", "VERY HIGH": "#c0392b", 
-        "CRITICAL": "#8e44ad", "UNKNOWN": "#7f8c8d"
+        "EXCEPTIONAL": "#059669", "VERY LOW": "#059669", "LOW": "#0891b2",
+        "MEDIUM": "#ea580c", "HIGH": "#dc2626", "VERY HIGH": "#dc2626", 
+        "CRITICAL": "#991b1b", "UNKNOWN": "#6b7280"
     }
     
-    # Determine gauge range based on epsilon value
-    max_range = max(5.0, epsilon * 1.5) if epsilon > 0 else 5.0
-    
     fig.add_trace(
         go.Indicator(
-            mode="gauge+number+delta",
+            mode="number+gauge",
             value=epsilon,
             title={
-                "text": f"<b>ε-DP Privacy Budget</b><br><span style='font-size:14px'>{risk_level} Risk</span>",
-                "font": {"size": 16}
+                "text": f"Privacy Risk: {risk_level}<br>Epsilon Value",
+                "font": {"size": 14, "color": "#000000"}
             },
-            number={"font": {"size": 24, "color": risk_colors.get(risk_level, "#7f8c8d")}},
-            delta={"reference": 1.0, "valueformat": ".6f"},
+            number={"font": {"size": 20, "color": risk_colors.get(risk_level, "#6b7280")}},
             gauge={
-                "axis": {
-                    "range": [0, max_range],
-                    "tickwidth": 1,
-                    "tickcolor": "#2c3e50",
-                    "tickfont": {"size": 10}
-                },
-                "bar": {"color": risk_colors.get(risk_level, "#7f8c8d"), "thickness": 0.8},
-                "steps": [
-                    {"range": [0, 0.01], "color": "#d5f4e6", "name": "Exceptional"},
-                    {"range": [0.01, 0.1], "color": "#a9dfbf", "name": "Very Low"},
-                    {"range": [0.1, 0.5], "color": "#fcf3cf", "name": "Low"},
-                    {"range": [0.5, 1.0], "color": "#f8c471", "name": "Medium"},
-                    {"range": [1.0, 2.0], "color": "#f1948a", "name": "High"},
-                    {"range": [2.0, max_range], "color": "#e8daef", "name": "Critical"}
-                ],
-                "threshold": {
-                    "line": {"color": "#2c3e50", "width": 3},
-                    "thickness": 0.9,
-                    "value": 1.0  # Reference line at ε = 1.0
-                }
+                "axis": {"range": [0, 5], "tickcolor": "#000000"},
+                "bar": {"color": risk_colors.get(risk_level, "#6b7280")},
+                "bgcolor": "white",
+                "bordercolor": "#d1d5db",
+                "borderwidth": 2
             }
         ),
         row=1, col=2
     )
         
-def _add_quality_indicators(fig, result: Dict[str, Any]):
-    """Add data quality indicators with memorization detection"""
+def _add_simplified_quality_assessment(fig, result: Dict[str, Any]):
+    """Add simplified quality assessment"""
     stats = result.get("distance_statistics", {})
     
-    # Calculate meaningful quality percentages
     total_samples = result.get("dataset_info", {}).get("real_samples_used", 1)
     zero_distances = stats.get("zero_distance_count", 0)
     small_distances = stats.get("small_distance_count", 0)
     
-    # Create scatter plot showing memorization vs privacy
-    memorization_pct = (zero_distances / total_samples) * 100 if total_samples > 0 else 0
-    near_memorization_pct = ((small_distances - zero_distances) / total_samples) * 100 if total_samples > 0 else 0
-    safe_samples_pct = 100 - memorization_pct - near_memorization_pct
-    
-    categories = ["Safe Samples", "Near Matches", "Exact Matches"]
-    percentages = [safe_samples_pct, near_memorization_pct, memorization_pct]
-    colors = ['#27ae60', '#f39c12', '#e74c3c']
+    categories = ["Safe", "Near Match", "Exact Match"]
+    counts = [total_samples - small_distances, small_distances - zero_distances, zero_distances]
     
-    # Create horizontal bar chart for better readability
     fig.add_trace(
         go.Bar(
-            y=categories,
-            x=percentages,
-            orientation='h',
-            marker_color=colors,
-            text=[f"{p:.1f}%" for p in percentages],
-            textposition='auto',
-            hovertemplate="<b>%{y}</b><br>Percentage: %{x:.1f}%<br>Count: %{customdata}<extra></extra>",
-            customdata=[total_samples - small_distances, small_distances - zero_distances, zero_distances],
-            name="Data Quality"
+            x=categories,
+            y=counts,
+            marker_color=['#059669', '#ea580c', '#dc2626'],
+            marker_line=dict(color='#000000', width=1),
+            text=[f"{c:,}" for c in counts],
+            textposition='outside',
+            textfont=dict(size=11, color="#000000"),
+            hovertemplate="<b>%{x}</b><br>Count: %{y:,}<extra></extra>",
+            showlegend=False
         ),
-        row=1, col=3
+        row=2, col=1
     )
     
-    fig.update_xaxes(title_text="Percentage of Samples", row=1, col=3, range=[0, 100])
-    fig.update_yaxes(title_text="Sample Categories", row=1, col=3)
+    fig.update_xaxes(title_text="Sample Type", row=2, col=1, title_font_size=12)
+    fig.update_yaxes(title_text="Count", row=2, col=1, title_font_size=12)
         
-def _add_dataset_overview(fig, result: Dict[str, Any]):
-    """Add dataset overview with key metrics"""
+def _add_key_metrics_table(fig, result: Dict[str, Any]):
+    """Add key metrics summary table"""
     dataset_info = result.get("dataset_info", {})
+    stats = result.get("distance_statistics", {})
+    risk_level = result.get("privacy_assessment", {}).get("risk_level", "UNKNOWN")
+    epsilon = result.get("privacy_assessment", {}).get("primary_epsilon", 0)
+    
+    metrics = [
+        "Real Samples",
+        "Synthetic Samples", 
+        "Dimensions",
+        "Risk Level",
+        "Epsilon Value",
+        "Exact Matches"
+    ]
     
-    metrics = ["Real Samples", "Synthetic Samples", "Dimensions", "Common Features"]
     values = [
-        dataset_info.get("real_samples_used", 0),
-        dataset_info.get("synthetic_samples", 0),
-        dataset_info.get("dimensions", 0),
-        dataset_info.get("common_features", 0)
+        f"{dataset_info.get('real_samples_used', 0):,}",
+        f"{dataset_info.get('synthetic_samples', 0):,}",
+        f"{dataset_info.get('dimensions', 0)}",
+        risk_level,
+        f"{epsilon:.6f}",
+        f"{stats.get('zero_distance_count', 0):,}"
     ]
     
     fig.add_trace(
-        go.Bar(
-            x=metrics,
-            y=values,
-            marker_color=['#3498db', '#9b59b6', '#e74c3c', '#2ecc71'],
-            text=[f"{v:,}" for v in values],
-            textposition='outside',
-            hovertemplate="<b>%{x}</b><br>Count: %{y:,}<extra></extra>",
-            name="Dataset Metrics"
+        go.Table(
+            header=dict(
+                values=["<b>Metric</b>", "<b>Value</b>"],
+                fill_color="#f3f4f6",
+                font=dict(size=12, color="#000000"),
+                align="left",
+                line_color="#d1d5db"
+            ),
+            cells=dict(
+                values=[metrics, values],
+                fill_color="white",
+                font=dict(size=11, color="#000000"),
+                align="left",
+                line_color="#d1d5db",
+                height=30
+            )
         ),
-        row=2, col=1
+        row=2, col=2
     )
-    
-    fig.update_xaxes(title_text="Dataset Characteristics", row=2, col=1, tickangle=45)
-    fig.update_yaxes(title_text="Count", row=2, col=1)
 
 def _add_privacy_bounds(fig, result: Dict[str, Any]):
     """Add privacy bounds comparison across confidence levels"""
@@ -1295,81 +1278,46 @@ def _add_processing_status(fig, result: Dict[str, Any]):
     fig.update_yaxes(title_text="Processing Completion %", row=2, col=3, range=[0, 100])
 
 def create_safe_epsilon_plot(result: Dict[str, Any]) -> go.Figure:
-    """Create safe epsilon plot with error handling"""
+    """Create simplified epsilon analysis plot"""
     try:
         if "error" in result:
-            fig = go.Figure()
-            fig.add_annotation(
-                text=f"Audit Error: {result.get('error', 'Unknown error')}",
-                x=0.5, y=0.5, showarrow=False,
-                font=dict(size=16, color="red")
-            )
-            return fig
+            return _create_error_figure(result)
         
         epsilon_bounds = result.get("epsilon_bounds", {})
-        
         confidence_levels = [90, 95, 99]
         epsilon_values = [epsilon_bounds.get(f"eps_lb_{conf}", 0) for conf in confidence_levels]
         
-        # Risk level colors
-        risk_colors = []
-        risk_levels = []
-        for eps in epsilon_values:
-            risk = auditor.assess_privacy_risk(eps) if auditor else "UNKNOWN"
-            risk_levels.append(risk)
-            color_map = {
-                "EXCEPTIONAL": '#2ca02c', "VERY LOW": '#8dd3c7', "LOW": '#ffd92f',
-                "MEDIUM": '#ff7f0e', "HIGH": '#d62728', "VERY HIGH": '#8b0000', 
-                "CRITICAL": '#4b0082', "UNKNOWN": '#gray'
-            }
-            risk_colors.append(color_map.get(risk, '#gray'))
-        
         fig = go.Figure()
         
-        # Bar chart with risk level annotations
+        # Simple bar chart
         fig.add_trace(go.Bar(
             x=[f"{conf}%" for conf in confidence_levels],
             y=epsilon_values,
-            marker_color=risk_colors,
-            text=[f"ε = {eps:.6f}<br>{risk}" for eps, risk in zip(epsilon_values, risk_levels)],
-            textposition='auto',
-            name="ε Lower Bounds",
-            hovertemplate="<b>Confidence: %{x}</b><br>ε Lower Bound: %{y:.6f}<br>Risk: %{text}<extra></extra>"
+            marker_color='#2563eb',
+            marker_line=dict(color='#1e40af', width=1),
+            text=[f"{eps:.6f}" for eps in epsilon_values],
+            textposition='outside',
+            textfont=dict(size=11, color="#000000"),
+            hovertemplate="<b>%{x} Confidence</b><br>Epsilon: %{y:.6f}<extra></extra>",
+            showlegend=False
         ))
         
-        # Add reference lines for risk thresholds
-        fig.add_hline(y=0.1, line_dash="dash", line_color="green", 
-                      annotation_text="Low Risk Threshold")
-        fig.add_hline(y=1.0, line_dash="dash", line_color="orange", 
-                      annotation_text="Medium Risk Threshold")
-        fig.add_hline(y=2.0, line_dash="dash", line_color="red", 
-                      annotation_text="High Risk Threshold")
-        
-        # Use log scale if values span multiple orders of magnitude
-        use_log_scale = max(epsilon_values) > 0 and (max(epsilon_values) / max(min(epsilon_values), 1e-10)) > 100
-        
         fig.update_layout(
-            title="Privacy Budget (ε) Analysis Across Confidence Levels",
+            title="Privacy Budget Analysis",
             xaxis_title="Confidence Level",
-            yaxis_title="ε Lower Bound" + (" (log scale)" if use_log_scale else ""),
-            yaxis_type="log" if use_log_scale else "linear",
-            template="plotly_white",
-            height=500,
-            showlegend=False
+            yaxis_title="Epsilon Lower Bound",
+            plot_bgcolor="white",
+            paper_bgcolor="white",
+            font=dict(family="Arial, sans-serif", size=12, color="#000000"),
+            height=400,
+            margin=dict(t=80, b=50, l=60, r=60)
         )
         
         return fig
         
     except Exception as e:
         logger.error(f"Epsilon plot creation failed: {e}")
-        # Return error figure
-        fig = go.Figure()
-        fig.add_annotation(
-            text=f"Visualization Error: {str(e)}",
-            x=0.5, y=0.5, showarrow=False,
-            font=dict(size=16, color="red")
-        )
-        return fig
+        return _create_error_figure({"error": str(e)})
 
 def generate_safe_report(result: Dict[str, Any]) -> str:
     """Generate safe executive report with error handling"""
@@ -2141,7 +2089,7 @@ Run a privacy audit to generate a comprehensive executive report including:
             try:
                 # Update status to running
                 yield (
-                    gr.update(value="**Audit in progress...**\n\nProcessing your datasets and running privacy analysis..."),
+                    gr.update(value="Audit in progress. Processing your datasets and running privacy analysis."),
                     gr.update(), gr.update(), gr.update(), gr.update(), gr.update(visible=False)
                 )
                 
@@ -2152,10 +2100,10 @@ Run a privacy audit to generate a comprehensive executive report including:
                 if result[0] and "error" not in result[0]:
                     risk_level = result[0].get("privacy_assessment", {}).get("risk_level", "UNKNOWN")
                     epsilon = result[0].get("privacy_assessment", {}).get("primary_epsilon", 0)
-                    status_msg = f"**Audit completed successfully!**\n\n**Risk Level:** {risk_level}\n**ε-DP Bound:** {epsilon:.6f}"
+                    status_msg = f"Audit completed successfully.\n\nRisk Level: {risk_level}\nEpsilon-DP Bound: {epsilon:.6f}"
                 else:
                     error_msg = result[0].get("error", "Unknown error") if result[0] else "Unknown error"
-                    status_msg = f"**Audit failed**\n\n{error_msg}"
+                    status_msg = f"Audit failed: {error_msg}"
                 
                 # Make export visible if successful
                 export_visible = result[4] is not None
@@ -2173,8 +2121,8 @@ Run a privacy audit to generate a comprehensive executive report including:
                 error_msg = f"Interface error: {str(e)}"
                 logger.error(error_msg)
                 yield (
-                    gr.update(value=f"**Interface Error**\n\n{error_msg}"),
-                    {"error": error_msg}, None, None, f"ERROR: {error_msg}", gr.update(visible=False)
+                    gr.update(value=f"Interface Error: {error_msg}"),
+                    {"error": error_msg}, None, None, f"Error: {error_msg}", gr.update(visible=False)
                 )
         
         # Connect the interface - FIXED: Now returns 6 outputs

logs/privacy_audit_detailed.log

@@ -37,3 +37,9 @@
 2025-09-07 02:50:30,255 - app - INFO - __init__:265 - Initialized Privacy Auditor - Session: 2d9998de
 2025-09-07 02:50:30,255 - app - INFO - __init__:266 - Configuration: {'confidence_level': 0.95, 'subsample_size': None, 'categorical_encoding': 'onehot', 'numerical_scaling': 'standard', 'distance_metric': 'euclidean', 'enable_preprocessing_report': True, 'max_file_size_mb': 500, 'timeout_seconds': 300, 'enable_data_validation': True, 'chunk_size': 10000, 'max_categories_onehot': 50}
 2025-09-07 02:50:30,255 - app - INFO - <module>:999 - Privacy auditor initialized successfully
+2025-09-07 03:03:38,859 - app - INFO - <module>:51 - Privacy Auditor Starting - 2025-09-07 03:03:38
+2025-09-07 03:03:38,860 - app - INFO - __init__:265 - Initialized Privacy Auditor - Session: 852aeeb3
+2025-09-07 03:03:38,860 - app - INFO - __init__:266 - Configuration: {'confidence_level': 0.95, 'subsample_size': None, 'categorical_encoding': 'onehot', 'numerical_scaling': 'standard', 'distance_metric': 'euclidean', 'enable_preprocessing_report': True, 'max_file_size_mb': 500, 'timeout_seconds': 300, 'enable_data_validation': True, 'chunk_size': 10000, 'max_categories_onehot': 50}
+2025-09-07 03:03:38,860 - app - INFO - <module>:999 - Privacy auditor initialized successfully
+2025-09-07 03:03:39,448 - httpx - INFO - _send_single_request:1038 - HTTP Request: GET https://checkip.amazonaws.com/ "HTTP/1.1 200 "
+2025-09-07 03:03:39,804 - httpx - INFO - _send_single_request:1038 - HTTP Request: GET https://api.gradio.app/pkg-version "HTTP/1.1 200 OK"