Update app.py

app.py

@@ -10,6 +10,7 @@ GPU configurations for Large Language Model (LLM) deployment and training.
 Author: Rudali Huidrom
 Version: 4.0.0
 First Written On: 08 December 2025
+Last Updated: 18 December 2025
 
 Overview
 --------
@@ -27,6 +28,9 @@ Key Features
 - Multi-GPU configuration support with communication overhead modeling
 - Framework-specific optimizations (vLLM, HuggingFace, TensorRT)
 - Real-time cost estimation with multiple pricing tiers
+- Throughput scaling with sequence length
+- CSV export with detailed analysis and formulas
+- Responsive UI with dark mode support
 
 Technical Approach
 -----------------
@@ -261,6 +265,46 @@ CUSTOM_CSS = """
     outline: 2px solid #3b82f6 !important;
     outline-offset: 2px !important;
 }
+
+/* ============================================
+   PLOTLY CHART RESPONSIVE STYLES
+   ============================================ */
+/* Make Plotly chart container responsive */
+.js-plotly-plot, .plotly {
+    width: 100% !important;
+}
+
+.js-plotly-plot .plotly .main-svg {
+    width: 100% !important;
+}
+
+/* Mobile: Ensure chart doesn't overflow */
+@media screen and (max-width: 768px) {
+    .js-plotly-plot, .plotly, .plot-container {
+        width: 100% !important;
+        overflow-x: auto !important;
+    }
+    
+    /* Make Gradio plot component full width */
+    .gradio-plot {
+        width: 100% !important;
+        min-height: 400px !important;
+    }
+}
+
+/* Small mobile: Compact chart */
+@media screen and (max-width: 480px) {
+    .gradio-plot {
+        min-height: 350px !important;
+    }
+}
+
+/* Landscape phone: Give more width to chart */
+@media screen and (max-width: 900px) and (orientation: landscape) {
+    .gradio-plot {
+        min-height: 300px !important;
+    }
+}
 </style>
 """
 
@@ -453,8 +497,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 +656,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: 17 December 2025
+# Last Updated: 16 December 2025
 # Sources:
 # - MLPerf Training v3.1 (November 2023)
 # - NVIDIA TensorRT-LLM benchmarks (Q4 2024)
@@ -795,72 +839,85 @@ def get_lora_overhead_factor(
         spec: Model specification (for hidden_dim and layers)
         
     Returns:
-        Throughput multiplier (< 1.0 means slower due to LoRA overhead)
+        Throughput multiplier relative to Full Fine-Tuning baseline.
+        > 1.0 means faster (LoRA/QLoRA train fewer parameters)
+        = 1.0 means baseline (Full FT)
+        
+    Real-world behavior:
+        - Full FT: Updates ALL parameters = baseline (slowest)
+        - LoRA: Updates only adapter params (~0.1-1%) = 2-4x faster
+        - QLoRA: Same as LoRA but quant overhead reduces speedup slightly
         
     Example:
         >>> get_lora_overhead_factor(64, "QLoRA", 7.0, spec)
-        0.87  # 13% throughput reduction with rank=64 on 7B model
+        2.5  # 2.5x faster than Full FT with rank=64 on 7B model
     """
     if ft_method not in ["LoRA", "QLoRA"] or rank is None:
-        return 1.0  # No LoRA overhead
-    
-    # Empirical overhead data from real-world benchmarks
-    # These account for: kernel launch overhead, memory bandwidth, cache effects
-    # Not just theoretical FLOPs (which underestimate actual impact)
+        return 1.0  # Full FT baseline - no speedup
+    
+    # LoRA/QLoRA speedup factors based on empirical benchmarks
+    # The speedup comes from:
+    # 1. Training only adapter parameters (0.1-1% of model)
+    # 2. Smaller gradient computations
+    # 3. Reduced optimizer state updates
+    #
+    # However, there are overheads:
+    # 1. Forward pass still processes full model
+    # 2. Adapter computations add some latency
+    # 3. Higher ranks = more adapter params = less speedup
     
     if model_size_bn <= 10:
-        # 7B models - LoRA overhead is most significant
-        # Kernel launch costs and memory bandwidth dominate
-        overhead_map = {
-            8: 0.98,    # 2% slowdown
-            16: 0.96,   # 4% slowdown  
-            32: 0.92,   # 8% slowdown
-            64: 0.87,   # 13% slowdown
-            128: 0.80,  # 20% slowdown
-            256: 0.70,  # 30% slowdown
+        # 7B models - LoRA provides significant speedup
+        speedup_map = {
+            8: 3.5,     # Very small adapter = big speedup
+            16: 3.2,
+            32: 2.8,
+            64: 2.4,
+            128: 2.0,
+            256: 1.6,
         }
     elif model_size_bn <= 20:
         # 13B models
-        overhead_map = {
-            8: 0.99,
-            16: 0.97,
-            32: 0.94,
-            64: 0.89,
-            128: 0.83,
-            256: 0.74,
+        speedup_map = {
+            8: 3.2,
+            16: 2.9,
+            32: 2.5,
+            64: 2.2,
+            128: 1.8,
+            256: 1.5,
         }
     elif model_size_bn <= 100:
-        # 70B models - LoRA overhead is less significant
-        # Base model computation dominates
-        overhead_map = {
-            8: 0.99,
-            16: 0.98,
-            32: 0.96,
-            64: 0.92,
-            128: 0.87,
-            256: 0.79,
+        # 70B models - LoRA speedup is proportionally larger
+        # because adapter is even smaller relative to model
+        speedup_map = {
+            8: 4.0,
+            16: 3.6,
+            32: 3.0,
+            64: 2.5,
+            128: 2.0,
+            256: 1.6,
         }
     else:
-        # 405B+ models - LoRA is proportionally tiny
-        overhead_map = {
-            8: 1.00,    # Negligible
-            16: 0.99,
-            32: 0.98,
-            64: 0.95,
-            128: 0.91,
-            256: 0.84,
+        # 405B+ models - largest relative speedup
+        speedup_map = {
+            8: 4.5,
+            16: 4.0,
+            32: 3.4,
+            64: 2.8,
+            128: 2.2,
+            256: 1.8,
         }
     
     # Find or interpolate for the given rank
-    if rank in overhead_map:
-        return overhead_map[rank]
+    if rank in speedup_map:
+        return speedup_map[rank]
     
     # Interpolate for ranks not in the map
-    ranks = sorted(overhead_map.keys())
+    ranks = sorted(speedup_map.keys())
     for i in range(len(ranks) - 1):
         if ranks[i] < rank < ranks[i+1]:
             r1, r2 = ranks[i], ranks[i+1]
-            v1, v2 = overhead_map[r1], overhead_map[r2]
+            v1, v2 = speedup_map[r1], speedup_map[r2]
             # Linear interpolation in log-space for smoother scaling
             import math
             log_rank = math.log(rank)
@@ -871,10 +928,10 @@ def get_lora_overhead_factor(
     
     # Extrapolate if beyond range
     if rank < ranks[0]:
-        return 1.0  # No overhead for very small ranks (< 8)
+        return speedup_map[ranks[0]]  # Use smallest rank speedup
     else:
-        # For very high ranks (> 256), assume overhead continues growing
-        return max(0.5, overhead_map[ranks[-1]] * 0.9)
+        # For very high ranks (> 256), speedup diminishes toward 1.0
+        return max(1.2, speedup_map[ranks[-1]] * 0.9)
 
 def calculate_throughput(
     gpu_config: GPUConfig,
@@ -884,7 +941,8 @@ def calculate_throughput(
     precision: str = "fp16",
     framework: str = "vllm",
     ft_method: Optional[str] = None,
-    rank: Optional[int] = None
+    rank: Optional[int] = None,
+    seq_len: int = 2048
 ) -> Tuple[float, float, str]:
     """
     Calculate estimated throughput for a GPU configuration.
@@ -893,7 +951,8 @@ def calculate_throughput(
     1. Quantization (INT8/INT4 Tensor Cores provide 2-4x speedup)
     2. Framework (TensorRT-LLM > vLLM > HuggingFace)
     3. Batch size and GPU architecture
-    4. LoRA rank (for training - higher rank = more overhead)
+    4. Sequence length (longer sequences reduce throughput)
+    5. LoRA rank (for training - higher rank = more overhead)
     
     Args:
         gpu_config: GPU configuration
@@ -903,6 +962,7 @@ def calculate_throughput(
         precision: Quantization/precision format (e.g., 'fp16', 'int8', 'int4')
         framework: Inference framework ('vllm', 'huggingface', 'tensorrt')
         ft_method: Fine-tuning method ('LoRA', 'QLoRA', 'Full Fine-Tuning')
+        seq_len: Sequence length (affects KV cache access and attention compute)
         rank: LoRA rank (only used for LoRA/QLoRA training)
         
     Returns:
@@ -944,12 +1004,12 @@ def calculate_throughput(
     framework_speedup = FRAMEWORK_SPEEDUP.get(framework.lower(), 1.0)
     tps_per_gpu *= framework_speedup
     
-    # Apply LoRA overhead if applicable (TRAINING ONLY)
-    # LoRA adds extra matrix multiplications that reduce throughput
-    lora_overhead = 1.0  # Default: no overhead
+    # Apply LoRA/QLoRA speedup if applicable (TRAINING ONLY)
+    # LoRA/QLoRA train only adapter parameters = faster than Full FT
+    lora_speedup = 1.0  # Default: Full FT baseline (no speedup)
     if task == "Training":
-        lora_overhead = get_lora_overhead_factor(rank, ft_method, model_size_bn, spec)
-        tps_per_gpu *= lora_overhead
+        lora_speedup = get_lora_overhead_factor(rank, ft_method, model_size_bn, spec)
+        tps_per_gpu *= lora_speedup
     
     # Calculate combined speedup for description
     combined_speedup = quant_speedup * framework_speedup
@@ -972,6 +1032,17 @@ def calculate_throughput(
         batch_efficiency = (batch_size / 8) ** 0.7
         tps_per_gpu *= batch_efficiency
     
+    # Apply sequence length scaling
+    # Longer sequences reduce throughput due to:
+    # 1. Increased KV cache memory bandwidth
+    # 2. O(n²) attention complexity (though optimized with Flash Attention)
+    # 3. More memory pressure reducing effective parallelism
+    # Baseline: 2048 tokens, ~15% reduction per doubling of sequence length
+    SEQ_LEN_BASELINE = 2048
+    if seq_len != SEQ_LEN_BASELINE:
+        seq_factor = (SEQ_LEN_BASELINE / seq_len) ** 0.15
+        tps_per_gpu *= seq_factor
+    
     # Apply multi-GPU communication overhead
     if gpu_config.count > 1:
         if gpu_config.count <= 4:
@@ -993,8 +1064,8 @@ def calculate_throughput(
     else:
         desc = f"Training throughput ({precision})"
         if ft_method in ["LoRA", "QLoRA"] and rank:
-            # Add LoRA rank info and efficiency
-            desc += f", LoRA r={rank}, {lora_overhead:.0%} efficiency"
+            # Add LoRA rank info and speedup factor
+            desc += f", LoRA r={rank}, {lora_speedup:.1f}x vs Full FT"
     
     if gpu_config.count > 1:
         desc += f" ({gpu_config.count}x GPUs, {comm_efficiency:.0%} efficiency)"
@@ -1061,10 +1132,12 @@ def validate_inputs(
     if batch > 512:
         warnings.append("WARNING: Very large batch size may exceed VRAM limits")
     
-    if rank < 4:
-        warnings.append("WARNING: LoRA rank < 4 may be too low for effective fine-tuning")
-    if rank > 256:
-        warnings.append("WARNING: LoRA rank > 256 may be inefficient (diminishing returns)")
+    # Only validate rank for training with LoRA/QLoRA
+    if rank is not None:
+        if rank < 4:
+            warnings.append("WARNING: LoRA rank < 4 may be too low for effective fine-tuning")
+        if rank > 256:
+            warnings.append("WARNING: LoRA rank > 256 may be inefficient (diminishing returns)")
     
     if sample_count < 1:
         warnings.append("ERROR: Sample count must be at least 1")
@@ -1773,8 +1846,8 @@ def generate_analysis_csv(
     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",
+            "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",
@@ -1808,6 +1881,7 @@ def recommend_hardware(
     ft_method: Optional[str] = None,
     rank: Optional[int] = None,
     manufacturers: Optional[list[str]] = None,
+    seq_len: int = 2048,
 ) -> Tuple[Optional[str], str, str, Dict[str, Any]]:
     """
     Recommend GPU configurations based on VRAM requirements.
@@ -1826,6 +1900,8 @@ def recommend_hardware(
         output_tokens: Output tokens per sample
         ft_method: Fine-tuning method (for training tasks)
         rank: LoRA rank (for LoRA/QLoRA training)
+        manufacturers: List of GPU manufacturers to filter by
+        seq_len: Sequence length (affects throughput calculation)
         
     Returns:
         Tuple of (error_message, budget_rec, runner_up_rec, chart_data)
@@ -1876,16 +1952,26 @@ def recommend_hardware(
         "vram_util": [],
         "cost_efficiency": [],  # tokens per rupee
         "gpu_details": [],  # Full details for CSV export
+        "short_names": [],  # Shortened names for mobile-friendly chart display
     }
     
+    def get_short_name(full_name: str) -> str:
+        """Create a shorter display name for charts."""
+        # Remove vendor prefix and simplify
+        name = full_name.replace("Nvidia ", "").replace("AMD ", "").replace("Intel ", "")
+        # Shorten common patterns
+        name = name.replace(" SXM ", " ").replace(" NVL ", " ").replace(" PCIe ", " ")
+        return name
+    
     for config in chart_configs:
         price = config.get_price(pricing_tier)
         vram_util = (required_vram / config.vram) * 100
         _, total_tps, _ = calculate_throughput(
-            config, spec, task, batch_size, precision, framework, ft_method, rank
+            config, spec, task, batch_size, precision, framework, ft_method, rank, seq_len
         )
         
         chart_data["names"].append(config.name)
+        chart_data["short_names"].append(get_short_name(config.name))
         chart_data["throughput"].append(total_tps)
         chart_data["cost"].append(price)
         chart_data["vram_util"].append(vram_util)
@@ -1916,7 +2002,7 @@ def recommend_hardware(
         vram_util = (required_vram / config.vram) * 100
         
         tps_per_gpu, total_tps, throughput_desc = calculate_throughput(
-            config, spec, task, batch_size, precision, framework, ft_method, rank
+            config, spec, task, batch_size, precision, framework, ft_method, rank, seq_len
         )
         
         time_estimate = ""
@@ -1993,7 +2079,7 @@ def process_request(
         # Convert to integers
         seq_len = int(seq_len)
         batch = int(batch)
-        rank = int(rank)
+        rank = int(rank) if rank is not None else None
         sample_count = int(sample_count)
         input_tokens = int(input_tokens)
         output_tokens = int(output_tokens)
@@ -2039,6 +2125,7 @@ def process_request(
         error, budget_rec, runner_up_rec, chart_data = recommend_hardware(
             total_vram, task, spec, weights_gb, batch, dataset_tier, actual_precision, fw,
             sample_count, input_tokens, output_tokens, ft_method, rank, manufacturers=manufacturers,
+            seq_len=seq_len,
         )
         
         if error:
@@ -2089,49 +2176,62 @@ def process_request(
             combined_chart = go.Figure(data=[
                 go.Bar(
                     name='Throughput',
-                    x=chart_data["names"],
+                    x=chart_data["short_names"],  # Use shorter names for mobile
                     y=throughput_normalized,
                     marker_color='#22c55e',
-                    hovertemplate='%{x}<br>Throughput: %{customdata:,.0f} tok/s<extra></extra>',
-                    customdata=chart_data["throughput"]
+                    hovertemplate='%{customdata[0]}<br>Throughput: %{customdata[1]:,.0f} tok/s<extra></extra>',
+                    customdata=list(zip(chart_data["names"], chart_data["throughput"]))  # Full name in hover
                 ),
                 go.Bar(
                     name='Cost',
-                    x=chart_data["names"],
+                    x=chart_data["short_names"],
                     y=cost_normalized,
                     marker_color='#3b82f6',
-                    hovertemplate='%{x}<br>Cost: ₹%{customdata:,.2f}/hr<extra></extra>',
-                    customdata=chart_data["cost"]
+                    hovertemplate='%{customdata[0]}<br>Cost: ₹%{customdata[1]:,.2f}/hr<extra></extra>',
+                    customdata=list(zip(chart_data["names"], chart_data["cost"]))
                 ),
                 go.Bar(
-                    name='VRAM Utilization',
-                    x=chart_data["names"],
+                    name='VRAM Util',
+                    x=chart_data["short_names"],
                     y=chart_data["vram_util"],
                     marker_color='#a855f7',
-                    hovertemplate='%{x}<br>VRAM Util: %{y:.1f}%<extra></extra>'
+                    hovertemplate='%{customdata}<br>VRAM Util: %{y:.1f}%<extra></extra>',
+                    customdata=chart_data["names"]
                 )
             ])
             
             combined_chart.update_layout(
                 title_text="GPU Comparison (Top 10 by Cost)",
-                xaxis_title="GPU Configuration",
+                xaxis_title="",  # Remove redundant title - GPU names are self-explanatory
                 yaxis_title="Normalized Value (% of max)",
                 barmode='group',
-                height=450,
+                height=520,  # Slightly taller for legend spacing
+                autosize=True,  # Enable responsive sizing
                 xaxis_tickangle=-45,
-                margin=dict(b=120, t=40, l=60, r=140),  # Right margin for legend
+                margin=dict(b=160, t=50, l=50, r=20),  # More bottom margin for legend
                 legend=dict(
-                    orientation="v",  # Vertical legend
-                    yanchor="middle",
-                    y=0.5,
-                    xanchor="left",
-                    x=1.02,  # Position to the right of chart
-                    bgcolor="rgba(255,255,255,0.8)",
+                    orientation="h",  # Horizontal legend
+                    yanchor="top",
+                    y=-0.38,  # Move further below to avoid overlap
+                    xanchor="center",
+                    x=0.5,
+                    bgcolor="rgba(255,255,255,0.9)",
                     bordercolor="rgba(0,0,0,0.1)",
-                    borderwidth=1
+                    borderwidth=1,
+                    font=dict(size=12),
+                    itemsizing='constant',
+                    traceorder='normal',
+                ),
+                font=dict(size=10),
+                title_font=dict(size=13),
+                # Make x-axis labels more readable
+                xaxis=dict(
+                    tickfont=dict(size=9),
+                ),
+                yaxis=dict(
+                    tickfont=dict(size=9),
+                    title_font=dict(size=11),
                 ),
-                font=dict(size=11),
-                title_font=dict(size=14),
             )
         
         # Generate CSV content and save to file