Update app.py

app.py

@@ -453,8 +453,8 @@ MODEL_CHOICES = [
 # Note: nf4 (NormalFloat4) is specifically designed for QLoRA and provides
 # better quality than standard int4 at the same bitwidth
 PRECISION_MAP = {
-    "float32": 4.0,
-    "fp32": 4.0,
+    # "float32": 4.0,
+    # "fp32": 4.0,
     "bf16": 2.0,        # BFloat16 - preferred for training (better range than fp16)
     "fp16": 2.0,        # Float16 - standard for inference
     "nf4": 0.5625,      # NormalFloat4 - QLoRA's quantization format
@@ -612,7 +612,7 @@ GPU_DATABASE = [
 # Based on real-world benchmarks from MLPerf, vendor data, and community testing
 # Tokens per second per GPU for different model sizes
 # 
-# Last Updated: 16 December 2025
+# Last Updated: 17 December 2025
 # Sources:
 # - MLPerf Training v3.1 (November 2023)
 # - NVIDIA TensorRT-LLM benchmarks (Q4 2024)
@@ -1504,7 +1504,9 @@ def calculate_vram(
         weights_gb = calculate_model_weights(spec, precision)
     
     # Calculate KV cache
-    kv_cache_gb = calculate_kv_cache(spec, batch_size, seq_len, precision)
+    # For training, KV cache is always at compute precision (bf16/fp16), not quantized
+    kv_precision = "bf16" if task == "Training" else precision
+    kv_cache_gb = calculate_kv_cache(spec, batch_size, seq_len, kv_precision)
     
     if task == "Inference":
         # Inference: weights + KV cache + framework overhead
@@ -1514,7 +1516,9 @@ def calculate_vram(
         
     else:  # Training
         # Training: weights + KV + activations + optimizer + gradients
-        activations_gb = calculate_activations(spec, batch_size, seq_len, precision)
+        # IMPORTANT: Activations are always stored at compute precision (bf16/fp16)
+        # even for QLoRA, because the forward pass computes at full precision
+        activations_gb = calculate_activations(spec, batch_size, seq_len, "bf16")
         optimizer_gb, _ = calculate_optimizer_states(weights_gb, ft_method or "Full Fine-Tuning", rank or 64, spec)
         gradients_gb, _ = calculate_gradients(weights_gb, ft_method or "Full Fine-Tuning", rank or 64, spec)
         
@@ -1540,6 +1544,255 @@ def calculate_vram(
 # Hardware Recommendation Engine
 # =================================================================================================
 
+def generate_analysis_csv(
+    # Input parameters
+    model_name: str,
+    task: str,
+    quant: str,
+    framework: str,
+    batch_size: int,
+    seq_len: int,
+    ft_method: Optional[str],
+    rank: Optional[int],
+    sample_count: int,
+    input_tokens: int,
+    output_tokens: int,
+    pricing_tier: str,
+    manufacturers: List[str],
+    # Calculated values
+    spec: 'ModelSpec',
+    weights_gb: float,
+    variable_gb: float,
+    total_vram: float,
+    actual_precision: str,
+    # GPU recommendations
+    gpu_recommendations: List[Dict[str, Any]],
+    source: str,
+) -> str:
+    """
+    Generate a detailed CSV containing all analysis parameters, formulas, and recommendations.
+    
+    Returns:
+        CSV content as a string
+    """
+    import csv
+    import io
+    from datetime import datetime
+    
+    output = io.StringIO()
+    writer = csv.writer(output)
+    
+    # ==========================================
+    # SECTION 1: HEADER
+    # ==========================================
+    writer.writerow(["IndiaAI GPU Infrastructure Recommender - Analysis Report"])
+    writer.writerow(["Generated", datetime.now().strftime("%Y-%m-%d %H:%M:%S")])
+    writer.writerow([])
+    
+    # ==========================================
+    # SECTION 2: INPUT PARAMETERS
+    # ==========================================
+    writer.writerow(["*" * 50])
+    writer.writerow(["INPUT PARAMETERS"])
+    writer.writerow(["*" * 50])
+    writer.writerow(["Parameter", "Value", "Description"])
+    writer.writerow(["Model Name", model_name, "User-specified model identifier"])
+    writer.writerow(["Task", task, "Inference or Training"])
+    writer.writerow(["Quantization", quant, "Precision format for model weights"])
+    writer.writerow(["Framework", framework, "Inference/training framework"])
+    writer.writerow(["Batch Size", batch_size, "Number of samples processed together"])
+    writer.writerow(["Sequence Length", seq_len, "Maximum context length (tokens)"])
+    if task == "Training":
+        writer.writerow(["Fine-tuning Method", ft_method or "N/A", "Training strategy (QLoRA/LoRA/Full FT)"])
+        writer.writerow(["LoRA Rank", rank if ft_method in ["LoRA", "QLoRA"] else "N/A", "Adapter rank for LoRA/QLoRA"])
+    writer.writerow(["Sample Count", sample_count, "Total samples to process"])
+    writer.writerow(["Input Tokens", input_tokens, "Average input tokens per sample"])
+    writer.writerow(["Output Tokens", output_tokens, "Average output tokens per sample"])
+    writer.writerow(["Pricing Tier", pricing_tier, "Selected pricing model"])
+    writer.writerow(["GPU Manufacturers", ", ".join(manufacturers), "Filtered GPU vendors"])
+    writer.writerow([])
+    
+    # ==========================================
+    # SECTION 3: MODEL ARCHITECTURE (Derived)
+    # ==========================================
+    writer.writerow(["*" * 50])
+    writer.writerow(["MODEL ARCHITECTURE (Derived)"])
+    writer.writerow(["*" * 50])
+    writer.writerow(["Parameter", "Value", "Formula / Source"])
+    writer.writerow(["Source", source, "How model info was obtained"])
+    writer.writerow(["Parameters (Billions)", f"{spec.params_bn:.2f}", "From model config or estimated from name"])
+    writer.writerow(["Parameters (Exact)", f"{spec.params:,}", "params_bn × 1,000,000,000"])
+    writer.writerow(["Layers", spec.layers, "Number of transformer layers"])
+    writer.writerow(["Attention Heads", spec.heads, "Number of query attention heads"])
+    writer.writerow(["KV Heads", spec.kv_heads, "Number of key/value heads (GQA)"])
+    writer.writerow(["Head Dimension", spec.head_dim, "Dimension per attention head"])
+    writer.writerow(["Hidden Size", spec.heads * spec.head_dim, "heads × head_dim"])
+    writer.writerow(["Max Context Length", spec.context, "Maximum supported sequence length"])
+    writer.writerow([])
+    
+    # ==========================================
+    # SECTION 4: PRECISION PARAMETERS
+    # ==========================================
+    writer.writerow(["*" * 50])
+    writer.writerow(["PRECISION PARAMETERS"])
+    writer.writerow(["*" * 50])
+    writer.writerow(["Parameter", "Value", "Formula / Explanation"])
+    
+    bytes_per_param = PRECISION_MAP.get(quant, 2.0)
+    writer.writerow(["Selected Precision", quant, "User-selected quantization format"])
+    writer.writerow(["Bytes per Parameter", bytes_per_param, f"From PRECISION_MAP['{quant}']"])
+    writer.writerow(["Actual Precision Used", actual_precision, "May differ for LoRA/Full FT (requires bf16)"])
+    
+    if actual_precision != quant:
+        actual_bytes = PRECISION_MAP.get(actual_precision, 2.0)
+        writer.writerow(["Actual Bytes per Param", actual_bytes, f"Overridden to {actual_precision} for training"])
+    writer.writerow([])
+    
+    # ==========================================
+    # SECTION 5: VRAM CALCULATION BREAKDOWN
+    # ==========================================
+    writer.writerow(["*" * 50])
+    writer.writerow(["VRAM CALCULATION BREAKDOWN"])
+    writer.writerow(["*" * 50])
+    writer.writerow(["Component", "Value (GB)", "Formula"])
+    
+    # Model weights calculation
+    actual_bytes_per_param = PRECISION_MAP.get(actual_precision, 2.0)
+    weights_formula = f"{spec.params_bn:.2f}B params × {actual_bytes_per_param} bytes / 1024³"
+    writer.writerow(["Model Weights", f"{weights_gb:.2f}", weights_formula])
+    
+    # KV Cache calculation
+    # For training, KV cache uses bf16 (compute precision), not quantized
+    if task == "Training":
+        kv_bytes_per_elem = 2.0  # Always bf16 for training
+        kv_cache_gb = calculate_kv_cache(spec, batch_size, seq_len, "bf16")
+        kv_formula = f"2 × {spec.layers} layers × {batch_size} batch × {seq_len} seq × {spec.kv_heads} kv_heads × {spec.head_dim} head_dim × {kv_bytes_per_elem} bytes (bf16) / 1024³"
+    else:
+        kv_bytes_per_elem = 2.0 if quant in ['nf4', '4bit', 'int4'] else PRECISION_MAP.get(quant, 2.0)
+        kv_cache_gb = calculate_kv_cache(spec, batch_size, seq_len, quant)
+        kv_formula = f"2 × {spec.layers} layers × {batch_size} batch × {seq_len} seq × {spec.kv_heads} kv_heads × {spec.head_dim} head_dim × {kv_bytes_per_elem} bytes / 1024³"
+    writer.writerow(["KV Cache", f"{kv_cache_gb:.2f}", kv_formula])
+    
+    if task == "Training":
+        # Activations - always at bf16 compute precision, even for QLoRA
+        # The forward pass computes at full precision, so activations are stored at bf16
+        hidden_size = spec.heads * spec.head_dim
+        activations_gb = calculate_activations(spec, batch_size, seq_len, "bf16")
+        act_formula = f"{batch_size} × {seq_len} × {hidden_size} hidden × {spec.layers} layers × 12 (checkpointing) × 2 bytes (bf16) / 1024³"
+        writer.writerow(["Activations", f"{activations_gb:.2f}", act_formula])
+        
+        # Optimizer states
+        optimizer_gb, opt_desc = calculate_optimizer_states(weights_gb, ft_method or "Full Fine-Tuning", rank or 64, spec)
+        if ft_method == "Full Fine-Tuning":
+            opt_formula = f"{weights_gb:.2f} GB weights × 4 (Adam: 2 states × fp32)"
+        else:
+            adapter_params = 2 * (rank or 64) * hidden_size * spec.layers
+            opt_formula = f"LoRA adapters ({adapter_params:,} params) × 4 (Adam states)"
+        writer.writerow(["Optimizer States", f"{optimizer_gb:.2f}", opt_formula])
+        
+        # Gradients
+        gradients_gb, grad_desc = calculate_gradients(weights_gb, ft_method or "Full Fine-Tuning", rank or 64, spec)
+        if ft_method == "Full Fine-Tuning":
+            grad_formula = f"{weights_gb:.2f} GB weights × 2 (fp32 gradients)"
+        else:
+            grad_formula = f"LoRA adapter gradients (fp16)"
+        writer.writerow(["Gradients", f"{gradients_gb:.2f}", grad_formula])
+        
+        # LoRA adapters
+        if ft_method in ["LoRA", "QLoRA"]:
+            adapter_params = 2 * (rank or 64) * hidden_size * spec.layers
+            adapter_gb = (adapter_params * 2) / (1024**3)
+            adapter_formula = f"2 × {rank} rank × {hidden_size} hidden × {spec.layers} layers × 2 bytes / 1024³"
+            writer.writerow(["LoRA Adapters", f"{adapter_gb:.4f}", adapter_formula])
+    else:
+        # Framework overhead for inference
+        overhead_gb = FRAMEWORK_OVERHEAD.get(framework, 2.0)
+        writer.writerow(["Framework Overhead", f"{overhead_gb:.2f}", f"FRAMEWORK_OVERHEAD['{framework}']"])
+    
+    writer.writerow([])
+    raw_total = weights_gb + variable_gb
+    buffer_amount = raw_total * 0.1
+    total_with_buffer = raw_total * 1.1
+    writer.writerow(["TOTAL VRAM (calculated)", f"{raw_total:.2f}", "Sum of all components"])
+    writer.writerow(["Safety Buffer (10%)", f"{buffer_amount:.2f}", "Total × 0.10 (used for GPU selection)"])
+    writer.writerow(["TOTAL VRAM + BUFFER", f"{total_with_buffer:.2f}", "Total × 1.10 (GPUs must have >= this VRAM)"])
+    writer.writerow([])
+    
+    # ==========================================
+    # SECTION 6: GPU RECOMMENDATIONS (Top 10)
+    # ==========================================
+    writer.writerow(["*" * 50])
+    writer.writerow(["GPU RECOMMENDATIONS (Top 10 by Cost)"])
+    writer.writerow(["*" * 50])
+    writer.writerow([
+        "Rank", "GPU Configuration", "Total VRAM (GB)", "VRAM/GPU (GB)", "GPU Count",
+        "VRAM Utilization (%)", "Throughput (tok/s)", "Price (₹/hr)", 
+        "Cost Efficiency (tok/₹)", "TFLOPS", "Bandwidth (GB/s)"
+    ])
+    
+    for i, gpu in enumerate(gpu_recommendations, 1):
+        writer.writerow([
+            i,
+            gpu["name"],
+            gpu["vram"],
+            gpu["vram_per_gpu"],
+            gpu["gpu_count"],
+            f"{gpu['vram_util']:.1f}",
+            f"{gpu['throughput']:.0f}",
+            f"{gpu['price']:.2f}",
+            f"{gpu['cost_efficiency']:.2f}",
+            f"{gpu['tflops']:.0f}",
+            f"{gpu['bandwidth']:.0f}",
+        ])
+    
+    writer.writerow([])
+    
+    # ==========================================
+    # SECTION 7: FORMULAS REFERENCE
+    # ==========================================
+    writer.writerow(["*" * 50])
+    writer.writerow(["FORMULAS REFERENCE"])
+    writer.writerow(["*" * 50])
+    writer.writerow(["Calculation", "Formula"])
+    writer.writerow(["Model Weights (GB)", "num_parameters × bytes_per_param / 1024³"])
+    writer.writerow(["KV Cache (GB)", "2 × layers × batch × seq_len × kv_heads × head_dim × bytes_per_elem / 1024³"])
+    writer.writerow(["Activations (GB)", "batch × seq_len × hidden_size × layers × multiplier × bytes / 1024³"])
+    writer.writerow(["Optimizer States (GB)", "trainable_params × 8 bytes (Adam: momentum + variance at fp32)"])
+    writer.writerow(["Gradients (GB)", "trainable_params × bytes_per_grad"])
+    writer.writerow(["LoRA Adapter Size", "2 × rank × hidden_dim × layers × 2 bytes"])
+    writer.writerow(["VRAM Utilization (%)", "(required_vram / gpu_vram) × 100"])
+    writer.writerow(["Cost Efficiency", "throughput (tok/s) / price (₹/hr)"])
+    writer.writerow([])
+    
+    # ==========================================
+    # SECTION 8: PRECISION MAP REFERENCE
+    # ==========================================
+    writer.writerow(["*" * 50])
+    writer.writerow(["PRECISION MAP REFERENCE"])
+    writer.writerow(["*" * 50])
+    writer.writerow(["Format", "Bytes per Parameter", "Notes"])
+    for fmt, bytes_val in PRECISION_MAP.items():
+        notes = {
+            # "fp32": "Full precision - maximum accuracy",
+            # "float32": "Full precision - maximum accuracy",
+            "bf16": "Brain Float16 - preferred for training",
+            "fp16": "Half precision - standard for inference",
+            "nf4": "NormalFloat4 - QLoRA format",
+            "4bit": "4-bit quantization",
+            "int4": "Integer 4-bit",
+            "int8": "Integer 8-bit - good accuracy/size tradeoff",
+            "awq": "Activation-aware Weight Quantization (inference-only)",
+            "gptq": "GPTQ quantization (inference-only)",
+        }.get(fmt, "")
+        writer.writerow([fmt, bytes_val, notes])
+    writer.writerow([])
+    
+    writer.writerow(["*" * 50])
+    writer.writerow(["END OF REPORT"])
+    writer.writerow(["*" * 50])
+    
+    return output.getvalue()
+
 def recommend_hardware(
     required_vram: float,
     task: str,
@@ -1622,6 +1875,7 @@ def recommend_hardware(
         "cost": [],
         "vram_util": [],
         "cost_efficiency": [],  # tokens per rupee
+        "gpu_details": [],  # Full details for CSV export
     }
     
     for config in chart_configs:
@@ -1636,7 +1890,22 @@ def recommend_hardware(
         chart_data["cost"].append(price)
         chart_data["vram_util"].append(vram_util)
         # Cost efficiency: tokens per rupee per hour
-        chart_data["cost_efficiency"].append(total_tps / price if price > 0 else 0)
+        cost_eff = total_tps / price if price > 0 else 0
+        chart_data["cost_efficiency"].append(cost_eff)
+        
+        # Full GPU details for CSV export
+        chart_data["gpu_details"].append({
+            "name": config.name,
+            "vram": config.vram,
+            "vram_per_gpu": config.vram_per_gpu,
+            "gpu_count": config.count,
+            "vram_util": vram_util,
+            "throughput": total_tps,
+            "price": price,
+            "cost_efficiency": cost_eff,
+            "tflops": config.tflops,
+            "bandwidth": config.bandwidth,
+        })
     
     # Generate recommendation cards
     def make_card(title: str, emoji: str, config: Optional[GPUConfig]) -> str:
@@ -1708,14 +1977,14 @@ def process_request(
     output_tokens: float,
     dataset_tier: str,
     manufacturers: list[str],
-) -> Tuple[str, str, str, Any]:
+) -> Tuple[str, str, str, Any, Optional[str]]:
     """
     Main request processing function.
     
     Orchestrates model resolution, VRAM calculation, and hardware recommendation.
     
     Returns:
-        Tuple of (report, budget_rec, runner_up_rec, combined_chart)
+        Tuple of (report, budget_rec, runner_up_rec, combined_chart, csv_filepath)
     """
     try:
         # Validate inputs
@@ -1773,7 +2042,7 @@ def process_request(
         )
         
         if error:
-            return error, "", "", None
+            return error, "", "", None, None
         
         # Generate report
         report = f"""
@@ -1843,23 +2112,6 @@ def process_request(
                 )
             ])
             
-            # combined_chart.update_layout(
-            #     title_text="GPU Comparison (Top 10 by Cost)",
-            #     xaxis_title="GPU Configuration",
-            #     yaxis_title="Normalized Value (% of max)",
-            #     barmode='group',
-            #     height=450,
-            #     xaxis_tickangle=-45,
-            #     margin=dict(b=120),
-            #     legend=dict(
-            #         orientation="h",
-            #         yanchor="bottom",
-            #         y=1.02,
-            #         xanchor="center",
-            #         x=0.5
-            #     )
-            # )
-
             combined_chart.update_layout(
                 title_text="GPU Comparison (Top 10 by Cost)",
                 xaxis_title="GPU Configuration",
@@ -1882,7 +2134,48 @@ def process_request(
                 title_font=dict(size=14),
             )
         
-        return report, budget_rec, runner_up_rec, combined_chart
+        # Generate CSV content and save to file
+        csv_filepath = None
+        if chart_data and chart_data.get("gpu_details"):
+            csv_content = generate_analysis_csv(
+                model_name=model_name,
+                task=task,
+                quant=quant,
+                framework=fw,
+                batch_size=batch,
+                seq_len=seq_len,
+                ft_method=ft_method,
+                rank=rank,
+                sample_count=sample_count,
+                input_tokens=input_tokens,
+                output_tokens=output_tokens,
+                pricing_tier=dataset_tier,
+                manufacturers=manufacturers,
+                spec=spec,
+                weights_gb=weights_gb,
+                variable_gb=variable_gb,
+                total_vram=total_vram,
+                actual_precision=actual_precision,
+                gpu_recommendations=chart_data["gpu_details"],
+                source=source,
+            )
+            
+            # Save CSV to a temporary file
+            import tempfile
+            import os
+            
+            # Create a filename based on model and timestamp
+            from datetime import datetime
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            safe_model_name = model_name.replace("/", "_").replace(" ", "_")[:30]
+            filename = f"gpu_analysis_{safe_model_name}_{timestamp}.csv"
+            
+            # Save to temp directory
+            csv_filepath = os.path.join(tempfile.gettempdir(), filename)
+            with open(csv_filepath, 'w', newline='', encoding='utf-8') as f:
+                f.write(csv_content)
+        
+        return report, budget_rec, runner_up_rec, combined_chart, csv_filepath
         
     except Exception as e:
         error_msg = f"""
@@ -1891,7 +2184,7 @@ def process_request(
 <p>{str(e)}</p>
 </div>
         """
-        return error_msg, "", "", None
+        return error_msg, "", "", None, None
 
 # =================================================================================================
 # UI Event Handlers
@@ -2053,6 +2346,16 @@ def create_interface() -> gr.Blocks:
                     with gr.Column(elem_classes=["runner-box"]):
                         rec_out_2 = gr.Markdown()
                 
+                # Download button for CSV export
+                with gr.Row():
+                    csv_download = gr.File(
+                        label="📥 Download Analysis (CSV)",
+                        visible=True,
+                        file_count="single",
+                        type="filepath",
+                        interactive=False,
+                    )
+                
                 # Bar chart comparison section
                 with gr.Accordion("📊 GPU Comparison (Top 10 by Cost)", open=False):
                     combined_plot = gr.Plot(label="GPU Comparison")
@@ -2091,7 +2394,7 @@ def create_interface() -> gr.Blocks:
                 ft_method, rank, batch, sample_count,
                 input_tokens, output_tokens, dataset_tier, manufacturers,
             ],
-            outputs=[report_out, rec_out_1, rec_out_2, combined_plot]
+            outputs=[report_out, rec_out_1, rec_out_2, combined_plot, csv_download]
         )
     
     return demo