Update app.py

app.py

@@ -4,16 +4,44 @@ import numpy as np
 import plotly.express as px
 import plotly.graph_objects as go
 
-# Pricing data
-# Only matching T4-based instances for fair comparison:
+# Updated pricing data - restructured for better comparison
 aws_instances = {
-    "g4dn.xlarge":  {"vcpus": 4, "memory": 16, "gpu": "1x NVIDIA T4", "hourly_rate": 0.526, "gpu_memory": "16GB"},
-    "g4dn.2xlarge": {"vcpus": 8, "memory": 32, "gpu": "1x NVIDIA T4", "hourly_rate": 0.752, "gpu_memory": "16GB"},
+    # T4 GPU Instances (entry level)
+    "g4dn.xlarge": {"vcpus": 4, "memory": 16, "gpu": "1x NVIDIA T4", "hourly_rate": 0.526, "gpu_memory": "16GB", "tier": "Entry"},
+    "g4dn.2xlarge": {"vcpus": 8, "memory": 32, "gpu": "1x NVIDIA T4", "hourly_rate": 0.752, "gpu_memory": "16GB", "tier": "Entry"},
+    
+    # A10G GPU Instances (mid-tier)
+    "g5.xlarge": {"vcpus": 4, "memory": 16, "gpu": "1x NVIDIA A10G", "hourly_rate": 0.65, "gpu_memory": "24GB", "tier": "Mid"},
+    "g5.2xlarge": {"vcpus": 8, "memory": 32, "gpu": "1x NVIDIA A10G", "hourly_rate": 1.006, "gpu_memory": "24GB", "tier": "Mid"},
+    
+    # V100 GPU Instances (high-tier)
+    "p3.2xlarge": {"vcpus": 8, "memory": 61, "gpu": "1x NVIDIA V100", "hourly_rate": 3.06, "gpu_memory": "16GB", "tier": "High"},
+    
+    # A100 GPU Instances (premium)
+    "p4d.24xlarge": {"vcpus": 96, "memory": 1152, "gpu": "8x NVIDIA A100", "hourly_rate": 32.77, "gpu_memory": "8x40GB", "tier": "Premium"},
+    
+    # Added comparable instances to match GCP
+    "p4d.xlarge": {"vcpus": 12, "memory": 85, "gpu": "1x NVIDIA A100", "hourly_rate": 4.10, "gpu_memory": "40GB", "tier": "Premium"},
+    "p4d.2xlarge": {"vcpus": 24, "memory": 170, "gpu": "2x NVIDIA A100", "hourly_rate": 8.20, "gpu_memory": "2x40GB", "tier": "Premium"},
+    "p4d.4xlarge": {"vcpus": 48, "memory": 340, "gpu": "4x NVIDIA A100", "hourly_rate": 16.40, "gpu_memory": "4x40GB", "tier": "Premium"},
 }
 
 gcp_instances = {
-    "n1-standard-4-t4": {"vcpus": 4, "memory": 15, "gpu": "1x NVIDIA T4", "hourly_rate": 0.49, "gpu_memory": "16GB"},
-    "n1-standard-8-t4": {"vcpus": 8, "memory": 30, "gpu": "1x NVIDIA T4", "hourly_rate": 0.69, "gpu_memory": "16GB"},
+    # T4 GPU Instances (entry level)
+    "n1-standard-4-t4": {"vcpus": 4, "memory": 15, "gpu": "1x NVIDIA T4", "hourly_rate": 0.49, "gpu_memory": "16GB", "tier": "Entry"},
+    "n1-standard-8-t4": {"vcpus": 8, "memory": 30, "gpu": "1x NVIDIA T4", "hourly_rate": 0.69, "gpu_memory": "16GB", "tier": "Entry"},
+    
+    # L4 GPU Instances (mid-tier)
+    "g2-standard-4": {"vcpus": 4, "memory": 16, "gpu": "1x NVIDIA L4", "hourly_rate": 0.59, "gpu_memory": "24GB", "tier": "Mid"},
+    "g2-standard-8": {"vcpus": 8, "memory": 32, "gpu": "1x NVIDIA L4", "hourly_rate": 0.89, "gpu_memory": "24GB", "tier": "Mid"},
+    
+    # Added comparable V100 instance
+    "n1-standard-8-v100": {"vcpus": 8, "memory": 60, "gpu": "1x NVIDIA V100", "hourly_rate": 2.95, "gpu_memory": "16GB", "tier": "High"},
+    
+    # A100 GPU Instances (premium)
+    "a2-highgpu-1g": {"vcpus": 12, "memory": 85, "gpu": "1x NVIDIA A100", "hourly_rate": 1.46, "gpu_memory": "40GB", "tier": "Premium"},
+    "a2-highgpu-2g": {"vcpus": 24, "memory": 170, "gpu": "2x NVIDIA A100", "hourly_rate": 2.93, "gpu_memory": "2x40GB", "tier": "Premium"},
+    "a2-highgpu-4g": {"vcpus": 48, "memory": 340, "gpu": "4x NVIDIA A100", "hourly_rate": 5.86, "gpu_memory": "4x40GB", "tier": "Premium"},
 }
 
 api_pricing = {
@@ -69,8 +97,8 @@ def calculate_gcp_cost(instance, hours, storage, reserved=False, spot=False, yea
 
 def calculate_api_cost(provider, model, in_tokens, out_tokens, calls):
     m = api_pricing[provider][model]
-    input_cost = in_tokens * m['input_per_1M']
-    output_cost = out_tokens * m['output_per_1M']
+    input_cost = in_tokens * m['input_per_1M'] / 1000000
+    output_cost = out_tokens * m['output_per_1M'] / 1000000
     call_cost = calls * 0.0001 if provider == 'TogetherAI' else 0
     return {'total_cost': input_cost + output_cost + call_cost, 'details': m}
 
@@ -91,45 +119,53 @@ def filter_compatible(instances, min_mem):
 
 def generate_cost_comparison(
     compute_hours, tokens_per_month, input_ratio, api_calls,
-    model_size, storage_gb, reserved_instances, spot_instances, multi_year_commitment
+    model_size, storage_gb, reserved_instances, spot_instances, multi_year_commitment,
+    comparison_tier
 ):
     years = int(multi_year_commitment)
-    in_tokens = tokens_per_month * (input_ratio/100)
-    out_tokens = tokens_per_month - in_tokens
+    in_tokens = tokens_per_month * 1000000 * (input_ratio/100)
+    out_tokens = tokens_per_month * 1000000 - in_tokens
     min_mem = model_sizes[model_size]['memory_required']
 
+    # Filter by both memory requirements and tier if a tier is selected
     aws_comp = filter_compatible(aws_instances, min_mem)
     gcp_comp = filter_compatible(gcp_instances, min_mem)
+    
+    if comparison_tier != "All":
+        aws_comp = {k: v for k, v in aws_comp.items() if v.get('tier', '') == comparison_tier}
+        gcp_comp = {k: v for k, v in gcp_comp.items() if v.get('tier', '') == comparison_tier}
 
     results = []
 
     # AWS table
     aws_html = '<h3>AWS Instances</h3>'
-    aws_html += '<table width="100%"><tr><th>Instance</th><th>vCPUs</th><th>Memory</th><th>GPU</th><th>Monthly Cost ($)</th></tr>'
+    aws_html += '<table width="100%"><tr><th>Instance</th><th>vCPUs</th><th>Memory</th><th>GPU</th><th>Tier</th><th>Monthly Cost ($)</th></tr>'
     if aws_comp:
         for inst in aws_comp:
             res = calculate_aws_cost(inst, compute_hours, storage_gb, reserved_instances, spot_instances, years)
-            aws_html += f'<tr><td>{inst}</td><td>{res["details"]["vcpus"]}</td><td>{res["details"]["memory"]}GB</td><td>{res["details"]["gpu"]}</td><td>${res["total_cost"]:.2f}</td></tr>'
+            aws_html += f'<tr><td>{inst}</td><td>{res["details"]["vcpus"]}</td><td>{res["details"]["memory"]}GB</td><td>{res["details"]["gpu"]}</td><td>{res["details"].get("tier", "")}</td><td>${res["total_cost"]:.2f}</td></tr>'
         # best AWS
         best_aws = min(aws_comp, key=lambda x: calculate_aws_cost(x, compute_hours, storage_gb, reserved_instances, spot_instances, years)['total_cost'])
         best_aws_cost = calculate_aws_cost(best_aws, compute_hours, storage_gb, reserved_instances, spot_instances, years)['total_cost']
-        results.append({'provider': f'AWS ({best_aws})', 'cost': best_aws_cost, 'type': 'Cloud'})
+        best_aws_tier = aws_instances[best_aws].get('tier', '')
+        results.append({'provider': f'AWS ({best_aws})', 'cost': best_aws_cost, 'type': 'Cloud', 'tier': best_aws_tier})
     else:
-        aws_html += '<tr><td colspan="5">No compatible instances</td></tr>'
+        aws_html += '<tr><td colspan="6">No compatible instances</td></tr>'
     aws_html += '</table>'
 
     # GCP table
     gcp_html = '<h3>GCP Instances</h3>'
-    gcp_html += '<table width="100%"><tr><th>Instance</th><th>vCPUs</th><th>Memory</th><th>GPU</th><th>Monthly Cost ($)</th></tr>'
+    gcp_html += '<table width="100%"><tr><th>Instance</th><th>vCPUs</th><th>Memory</th><th>GPU</th><th>Tier</th><th>Monthly Cost ($)</th></tr>'
     if gcp_comp:
         for inst in gcp_comp:
             res = calculate_gcp_cost(inst, compute_hours, storage_gb, reserved_instances, spot_instances, years)
-            gcp_html += f'<tr><td>{inst}</td><td>{res["details"]["vcpus"]}</td><td>{res["details"]["memory"]}GB</td><td>{res["details"]["gpu" ]}</td><td>${res["total_cost"]:.2f}</td></tr>'
+            gcp_html += f'<tr><td>{inst}</td><td>{res["details"]["vcpus"]}</td><td>{res["details"]["memory"]}GB</td><td>{res["details"]["gpu"]}</td><td>{res["details"].get("tier", "")}</td><td>${res["total_cost"]:.2f}</td></tr>'
         best_gcp = min(gcp_comp, key=lambda x: calculate_gcp_cost(x, compute_hours, storage_gb, reserved_instances, spot_instances, years)['total_cost'])
         best_gcp_cost = calculate_gcp_cost(best_gcp, compute_hours, storage_gb, reserved_instances, spot_instances, years)['total_cost']
-        results.append({'provider': f'GCP ({best_gcp})', 'cost': best_gcp_cost, 'type': 'Cloud'})
+        best_gcp_tier = gcp_instances[best_gcp].get('tier', '')
+        results.append({'provider': f'GCP ({best_gcp})', 'cost': best_gcp_cost, 'type': 'Cloud', 'tier': best_gcp_tier})
     else:
-        gcp_html += '<tr><td colspan="5">No compatible instances</td></tr>'
+        gcp_html += '<tr><td colspan="6">No compatible instances</td></tr>'
     gcp_html += '</table>'
 
     # API table
@@ -140,28 +176,71 @@ def generate_cost_comparison(
         for mdl in api_pricing[prov]:
             res = calculate_api_cost(prov, mdl, in_tokens, out_tokens, api_calls)
             details = api_pricing[prov][mdl]
-            api_html += f'<tr><td>{prov}</td><td>{mdl}</td><td>${in_tokens * details["input_per_1M"]:.2f}</td><td>${out_tokens * details["output_per_1M"]:.2f}</td><td>${res["total_cost"]:.2f}</td><td>{details["token_context"]:,}</td></tr>'
+            api_html += f'<tr><td>{prov}</td><td>{mdl}</td><td>${in_tokens * details["input_per_1M"] / 1000000:.2f}</td><td>${out_tokens * details["output_per_1M"] / 1000000:.2f}</td><td>${res["total_cost"]:.2f}</td><td>{details["token_context"]:,}</td></tr>'
             api_costs[(prov, mdl)] = res['total_cost']
     api_html += '</table>'
-    best_api = min(api_costs, key=api_costs.get)
-    results.append({'provider': f'{best_api[0]} ({best_api[1]})', 'cost': api_costs[best_api], 'type': 'API'})
+    
+    if api_costs:
+        best_api = min(api_costs, key=api_costs.get)
+        results.append({'provider': f'{best_api[0]} ({best_api[1]})', 'cost': api_costs[best_api], 'type': 'API', 'tier': 'API'})
 
-    # Recommendation and Breakeven omitted for brevity
+    # Direct comparison tables for similar instances
+    direct_comparison_html = ""
+    if comparison_tier != "All" and comparison_tier != "API":
+        direct_comparison_html = f'<h3>Direct {comparison_tier} Tier Comparison</h3>'
+        direct_comparison_html += '<table width="100%"><tr><th>Provider</th><th>Instance</th><th>vCPUs</th><th>Memory</th><th>GPU</th><th>Monthly Cost ($)</th></tr>'
+        
+        aws_filtered = {k: v for k, v in aws_instances.items() if v.get('tier', '') == comparison_tier}
+        gcp_filtered = {k: v for k, v in gcp_instances.items() if v.get('tier', '') == comparison_tier}
+        
+        # Group by vCPU for comparison
+        vcpu_groups = {}
+        for inst, data in aws_filtered.items():
+            vcpu = data['vcpus']
+            if vcpu not in vcpu_groups:
+                vcpu_groups[vcpu] = {'aws': [], 'gcp': []}
+            vcpu_groups[vcpu]['aws'].append(inst)
+        
+        for inst, data in gcp_filtered.items():
+            vcpu = data['vcpus']
+            if vcpu not in vcpu_groups:
+                vcpu_groups[vcpu] = {'aws': [], 'gcp': []}
+            vcpu_groups[vcpu]['gcp'].append(inst)
+        
+        # Display direct comparisons
+        for vcpu in sorted(vcpu_groups.keys()):
+            group = vcpu_groups[vcpu]
+            for aws_inst in group['aws']:
+                aws_cost = calculate_aws_cost(aws_inst, compute_hours, storage_gb, reserved_instances, spot_instances, years)
+                aws_data = aws_cost['details']
+                direct_comparison_html += f'<tr><td>AWS</td><td>{aws_inst}</td><td>{aws_data["vcpus"]}</td><td>{aws_data["memory"]}GB</td><td>{aws_data["gpu"]}</td><td>${aws_cost["total_cost"]:.2f}</td></tr>'
+            
+            for gcp_inst in group['gcp']:
+                gcp_cost = calculate_gcp_cost(gcp_inst, compute_hours, storage_gb, reserved_instances, spot_instances, years)
+                gcp_data = gcp_cost['details']
+                direct_comparison_html += f'<tr><td>GCP</td><td>{gcp_inst}</td><td>{gcp_data["vcpus"]}</td><td>{gcp_data["memory"]}GB</td><td>{gcp_data["gpu"]}</td><td>${gcp_cost["total_cost"]:.2f}</td></tr>'
+            
+            # Add separator between different vCPU groups
+            if vcpu != sorted(vcpu_groups.keys())[-1]:
+                direct_comparison_html += '<tr><td colspan="6" style="border-bottom: 1px solid #ccc; height: 10px;"></td></tr>'
+        
+        direct_comparison_html += '</table>'
 
     # Chart with annotations
     df = pd.DataFrame(results)
-    colors = {r['provider']: c for r,c in zip(results, ['#FF9900','#4285F4','#D62828'])}
+    colors = {'Entry': '#66BB6A', 'Mid': '#42A5F5', 'High': '#FFA726', 'Premium': '#EF5350', 'API': '#AB47BC'}
     
     # Create figure using plotly graph objects for more control
     fig = go.Figure()
     
     # Add bars
     for i, row in df.iterrows():
+        tier_color = colors.get(row.get('tier', 'API'), '#9E9E9E')
         fig.add_trace(go.Bar(
             x=[row['provider']], 
             y=[row['cost']], 
             name=row['provider'],
-            marker_color=colors[row['provider']]
+            marker_color=tier_color
         ))
     
     # Add annotations on top of each bar
@@ -186,6 +265,7 @@ def generate_cost_comparison(
 
     html = f"""
     <div style='padding:20px;font-family:Arial;'>
+      {direct_comparison_html}
       {aws_html}
       {gcp_html}
       {api_html}
@@ -204,6 +284,7 @@ with gr.Blocks(title="Cloud Cost Estimator", theme=gr.themes.Soft(primary_hue="i
             api_calls = gr.Slider(label="API Calls per Month", minimum=100, maximum=100000, value=5000, step=100)
             model_size = gr.Dropdown(label="Model Size", choices=list(model_sizes.keys()), value="Medium (13B parameters)")
             storage_gb = gr.Slider(label="Storage (GB)", minimum=10, maximum=1000, value=100)
+            comparison_tier = gr.Radio(label="Comparison Tier", choices=["All", "Entry", "Mid", "High", "Premium", "API"], value="All")
             reserved_instances = gr.Checkbox(label="Reserved Instances", value=False)
             spot_instances = gr.Checkbox(label="Spot Instances", value=False)
             multi_year_commitment = gr.Radio(label="Commitment Period (years)", choices=["1","3"], value="1")
@@ -213,21 +294,14 @@ with gr.Blocks(title="Cloud Cost Estimator", theme=gr.themes.Soft(primary_hue="i
     
     # Create inputs list for the function
     inputs = [compute_hours, tokens_per_month, input_ratio, api_calls,
-             model_size, storage_gb, reserved_instances, spot_instances, multi_year_commitment]
+             model_size, storage_gb, reserved_instances, spot_instances, multi_year_commitment, comparison_tier]
     outputs = [out_html, out_plot]
     
     # Initial calculation on load
     demo.load(generate_cost_comparison, inputs, outputs)
     
     # Update on each input change
-    compute_hours.change(generate_cost_comparison, inputs, outputs)
-    tokens_per_month.change(generate_cost_comparison, inputs, outputs)
-    input_ratio.change(generate_cost_comparison, inputs, outputs)
-    api_calls.change(generate_cost_comparison, inputs, outputs)
-    model_size.change(generate_cost_comparison, inputs, outputs)
-    storage_gb.change(generate_cost_comparison, inputs, outputs)
-    reserved_instances.change(generate_cost_comparison, inputs, outputs)
-    spot_instances.change(generate_cost_comparison, inputs, outputs)
-    multi_year_commitment.change(generate_cost_comparison, inputs, outputs)
+    for input_component in inputs:
+        input_component.change(generate_cost_comparison, inputs, outputs)
 
 demo.launch()