update app.py

app.py

@@ -1,559 +1,9 @@
 import gradio as gr
-import pandas as pd
-import numpy as np
-import plotly.express as px
-import plotly.graph_objects as go
 
-# Initialize pricing data
-# AWS pricing - Instance types and their properties
-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"},
-    "g5.xlarge": {"vcpus": 4, "memory": 16, "gpu": "1x NVIDIA A10G", "hourly_rate": 0.65, "gpu_memory": "24GB"},
-    "g5.2xlarge": {"vcpus": 8, "memory": 32, "gpu": "1x NVIDIA A10G", "hourly_rate": 1.006, "gpu_memory": "24GB"},
-    "p3.2xlarge": {"vcpus": 8, "memory": 61, "gpu": "1x NVIDIA V100", "hourly_rate": 3.06, "gpu_memory": "16GB"},
-    "p4d.24xlarge": {"vcpus": 96, "memory": 1152, "gpu": "8x NVIDIA A100", "hourly_rate": 32.77, "gpu_memory": "8x40GB"}
-}
+def greet(name):
+    return "Hello " + name + "!!"
 
-# GCP pricing - Instance types and their properties
-gcp_instances = {
-    "a2-highgpu-1g": {"vcpus": 12, "memory": 85, "gpu": "1x NVIDIA A100", "hourly_rate": 1.46, "gpu_memory": "40GB"},
-    "a2-highgpu-2g": {"vcpus": 24, "memory": 170, "gpu": "2x NVIDIA A100", "hourly_rate": 2.93, "gpu_memory": "2x40GB"},
-    "a2-highgpu-4g": {"vcpus": 48, "memory": 340, "gpu": "4x NVIDIA A100", "hourly_rate": 5.86, "gpu_memory": "4x40GB"},
-    "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"},
-    "g2-standard-4": {"vcpus": 4, "memory": 16, "gpu": "1x NVIDIA L4", "hourly_rate": 0.59, "gpu_memory": "24GB"}
-}
+demo = gr.Interface(fn=greet, inputs="text", outputs="text")
 
-# API pricing - Models and their prices
-api_pricing = {
-    "OpenAI": {
-        "GPT-3.5-Turbo": {"input_per_1M": 0.5, "output_per_1M": 1.5, "token_context": 16385},
-        "GPT-4o": {"input_per_1M": 5.0, "output_per_1M": 15.0, "token_context": 32768},
-        "GPT-4o-mini": {"input_per_1M": 2.5, "output_per_1M": 7.5, "token_context": 32768},
-    },
-    "TogetherAI": {
-        "Llama-3-8B": {"input_per_1M": 0.15, "output_per_1M": 0.15, "token_context": 8192},
-        "Llama-3-70B": {"input_per_1M": 0.9, "output_per_1M": 0.9, "token_context": 8192},
-        "Llama-2-13B": {"input_per_1M": 0.6, "output_per_1M": 0.6, "token_context": 4096},
-        "Llama-2-70B": {"input_per_1M": 2.5, "output_per_1M": 2.5, "token_context": 4096},
-        "DeepSeek-Coder-33B": {"input_per_1M": 2.0, "output_per_1M": 2.0, "token_context": 16384},
-    },
-    "Anthropic": {
-        "Claude-3-Opus": {"input_per_1M": 15.0, "output_per_1M": 75.0, "token_context": 200000},
-        "Claude-3-Sonnet": {"input_per_1M": 3.0, "output_per_1M": 15.0, "token_context": 200000},
-        "Claude-3-Haiku": {"input_per_1M": 0.25, "output_per_1M": 1.25, "token_context": 200000},
-    }
-}
-
-# Model sizes and memory requirements
-model_sizes = {
-    "Small (7B parameters)": {"memory_required": 14, "throughput_factor": 1.0},
-    "Medium (13B parameters)": {"memory_required": 26, "throughput_factor": 0.7},
-    "Large (70B parameters)": {"memory_required": 140, "throughput_factor": 0.3},
-    "XL (180B parameters)": {"memory_required": 360, "throughput_factor": 0.15},
-}
-
-# Calculate costs
-def calculate_aws_cost(instance, hours, storage, reserved=False, spot=False, years=1):
-    instance_data = aws_instances[instance]
-    base_hourly = instance_data["hourly_rate"]
-    
-    # Apply discounts for reservation or spot
-    if spot:
-        hourly_rate = base_hourly * 0.3  # 70% discount for spot
-    elif reserved:
-        discount_factors = {1: 0.6, 3: 0.4}  # 40% for 1 year, 60% for 3 years
-        hourly_rate = base_hourly * discount_factors.get(years, 0.6)
-    else:
-        hourly_rate = base_hourly
-    
-    compute_cost = hourly_rate * hours
-    storage_cost = storage * 0.10  # $0.10 per GB for EBS
-    
-    return {
-        "compute_cost": compute_cost,
-        "storage_cost": storage_cost,
-        "total_cost": compute_cost + storage_cost,
-        "instance_details": instance_data
-    }
-
-def calculate_gcp_cost(instance, hours, storage, reserved=False, spot=False, years=1):
-    instance_data = gcp_instances[instance]
-    base_hourly = instance_data["hourly_rate"]
-    
-    # Apply discounts
-    if spot:
-        hourly_rate = base_hourly * 0.2  # 80% discount for preemptible
-    elif reserved:
-        discount_factors = {1: 0.7, 3: 0.5}  # 30% for 1 year, 50% for 3 years
-        hourly_rate = base_hourly * discount_factors.get(years, 0.7)
-    else:
-        hourly_rate = base_hourly
-    
-    compute_cost = hourly_rate * hours
-    storage_cost = storage * 0.04  # $0.04 per GB for Standard SSD
-    
-    return {
-        "compute_cost": compute_cost,
-        "storage_cost": storage_cost,
-        "total_cost": compute_cost + storage_cost,
-        "instance_details": instance_data
-    }
-
-def calculate_api_cost(provider, model, input_tokens, output_tokens, api_calls):
-    model_data = api_pricing[provider][model]
-    
-    input_cost = (input_tokens * model_data["input_per_1M"]) / 1
-    output_cost = (output_tokens * model_data["output_per_1M"]) / 1
-    
-    # Add a small cost for API calls for some providers
-    api_call_costs = 0
-    if provider == "TogetherAI":
-        api_call_costs = api_calls * 0.0001  # $0.0001 per request
-    
-    total_cost = input_cost + output_cost + api_call_costs
-    
-    return {
-        "input_cost": input_cost,
-        "output_cost": output_cost,
-        "api_call_cost": api_call_costs,
-        "total_cost": total_cost,
-        "model_details": model_data
-    }
-
-# Filter instances based on model size requirements
-def filter_compatible_instances(instances_dict, min_memory_required):
-    compatible = {}
-    for name, data in instances_dict.items():
-        # Parse GPU memory
-        memory_str = data["gpu_memory"]
-        
-        # Handle multiple GPUs
-        if "x" in memory_str and not memory_str.startswith(("1x", "2x", "4x", "8x")):
-            # Format: "16GB"
-            memory_val = int(memory_str.split("GB")[0])
-        elif "x" in memory_str:
-            # Format: "8x40GB"
-            parts = memory_str.split("x")
-            num_gpus = int(parts[0])
-            memory_per_gpu = int(parts[1].split("GB")[0])
-            memory_val = num_gpus * memory_per_gpu
-        else:
-            # Format: "40GB"
-            memory_val = int(memory_str.split("GB")[0])
-        
-        if memory_val >= min_memory_required:
-            compatible[name] = data
-            
-    return compatible
-
-def generate_cost_comparison(
-    compute_hours, 
-    tokens_per_month, 
-    input_ratio, 
-    api_calls, 
-    model_size, 
-    storage_gb, 
-    reserved_instances, 
-    spot_instances, 
-    multi_year_commitment
-):
-    # Calculate input and output tokens
-    input_tokens = tokens_per_month * (input_ratio / 100)
-    output_tokens = tokens_per_month * (1 - (input_ratio / 100))
-    
-    # Check model memory requirements
-    min_memory_required = model_sizes[model_size]["memory_required"]
-    
-    # Filter compatible instances
-    compatible_aws = filter_compatible_instances(aws_instances, min_memory_required)
-    compatible_gcp = filter_compatible_instances(gcp_instances, min_memory_required)
-    
-    results = []
-    
-    # Generate HTML for AWS options
-    if compatible_aws:
-        aws_results = "<h3>AWS Compatible Instances</h3>"
-        aws_results += "<table width='100%'><tr><th>Instance</th><th>vCPUs</th><th>Memory</th><th>GPU</th><th>Hourly Rate</th><th>Monthly Cost</th></tr>"
-        
-        best_aws = None
-        best_aws_cost = float('inf')
-        
-        for instance in compatible_aws:
-            cost_result = calculate_aws_cost(instance, compute_hours, storage_gb, reserved_instances, spot_instances, multi_year_commitment)
-            total_cost = cost_result["total_cost"]
-            
-            if total_cost < best_aws_cost:
-                best_aws = instance
-                best_aws_cost = total_cost
-            
-            aws_results += f"<tr><td>{instance}</td><td>{compatible_aws[instance]['vcpus']}</td><td>{compatible_aws[instance]['memory']}GB</td><td>{compatible_aws[instance]['gpu']}</td><td>${compatible_aws[instance]['hourly_rate']:.3f}</td><td>${total_cost:.2f}</td></tr>"
-        
-        aws_results += "</table>"
-        
-        if best_aws:
-            best_aws_data = calculate_aws_cost(best_aws, compute_hours, storage_gb, reserved_instances, spot_instances, multi_year_commitment)
-            results.append({
-                "provider": f"AWS ({best_aws})",
-                "cost": best_aws_data["total_cost"],
-                "type": "Cloud"
-            })
-    else:
-        aws_results = "<h3>AWS Compatible Instances</h3><p>No compatible AWS instances found for this model size.</p>"
-        best_aws = None
-        best_aws_cost = float('inf')
-    
-    # Generate HTML for GCP options
-    if compatible_gcp:
-        gcp_results = "<h3>Google Cloud Compatible Instances</h3>"
-        gcp_results += "<table width='100%'><tr><th>Instance</th><th>vCPUs</th><th>Memory</th><th>GPU</th><th>Hourly Rate</th><th>Monthly Cost</th></tr>"
-        
-        best_gcp = None
-        best_gcp_cost = float('inf')
-        
-        for instance in compatible_gcp:
-            cost_result = calculate_gcp_cost(instance, compute_hours, storage_gb, reserved_instances, spot_instances, multi_year_commitment)
-            total_cost = cost_result["total_cost"]
-            
-            if total_cost < best_gcp_cost:
-                best_gcp = instance
-                best_gcp_cost = total_cost
-            
-            gcp_results += f"<tr><td>{instance}</td><td>{compatible_gcp[instance]['vcpus']}</td><td>{compatible_gcp[instance]['memory']}GB</td><td>{compatible_gcp[instance]['gpu']}</td><td>${compatible_gcp[instance]['hourly_rate']:.3f}</td><td>${total_cost:.2f}</td></tr>"
-        
-        gcp_results += "</table>"
-        
-        if best_gcp:
-            best_gcp_data = calculate_gcp_cost(best_gcp, compute_hours, storage_gb, reserved_instances, spot_instances, multi_year_commitment)
-            results.append({
-                "provider": f"GCP ({best_gcp})",
-                "cost": best_gcp_data["total_cost"],
-                "type": "Cloud"
-            })
-    else:
-        gcp_results = "<h3>Google Cloud Compatible Instances</h3><p>No compatible Google Cloud instances found for this model size.</p>"
-        best_gcp = None
-        best_gcp_cost = float('inf')
-    
-    # Generate HTML for API options
-    api_results = "<h3>API Options</h3>"
-    api_results += "<table width='100%'><tr><th>Provider</th><th>Model</th><th>Input Cost</th><th>Output Cost</th><th>Total Cost</th><th>Context Length</th></tr>"
-    
-    api_costs = {}
-    
-    for provider in api_pricing:
-        for model in api_pricing[provider]:
-            cost_data = calculate_api_cost(provider, model, input_tokens, output_tokens, api_calls)
-            api_costs[(provider, model)] = cost_data
-            
-            api_results += f"<tr><td>{provider}</td><td>{model}</td><td>${cost_data['input_cost']:.2f}</td><td>${cost_data['output_cost']:.2f}</td><td>${cost_data['total_cost']:.2f}</td><td>{api_pricing[provider][model]['token_context']:,}</td></tr>"
-    
-    api_results += "</table>"
-    
-    # Find best API option
-    best_api = min(api_costs.keys(), key=lambda x: api_costs[x]["total_cost"])
-    best_api_cost = api_costs[best_api]
-    
-    results.append({
-        "provider": f"{best_api[0]} ({best_api[1]})",
-        "cost": best_api_cost["total_cost"],
-        "type": "API"
-    })
-    
-    # Create recommendation HTML
-    recommendation = "<h3>Recommendation</h3>"
-    
-    # Find the cheapest option
-    cheapest = min(results, key=lambda x: x["cost"])
-    
-    if cheapest["type"] == "API":
-        recommendation += f"<p>Based on your usage parameters, the <strong>{cheapest['provider']}</strong> API endpoint is the most cost-effective option at <strong>${cheapest['cost']:.2f}/month</strong>.</p>"
-        
-        # Calculate API vs cloud cost ratio
-        cheapest_cloud = None
-        for result in results:
-            if result["type"] == "Cloud":
-                if cheapest_cloud is None or result["cost"] < cheapest_cloud["cost"]:
-                    cheapest_cloud = result
-        
-        if cheapest_cloud:
-            ratio = cheapest_cloud["cost"] / cheapest["cost"]
-            recommendation += f"<p>This is <strong>{ratio:.1f}x cheaper</strong> than the most affordable cloud option ({cheapest_cloud['provider']}).</p>"
-    else:
-        recommendation += f"<p>Based on your usage parameters, <strong>{cheapest['provider']}</strong> is the most cost-effective option at <strong>${cheapest['cost']:.2f}/month</strong>.</p>"
-        
-        # Find cheapest API
-        cheapest_api = None
-        for result in results:
-            if result["type"] == "API":
-                if cheapest_api is None or result["cost"] < cheapest_api["cost"]:
-                    cheapest_api = result
-        
-        if cheapest_api:
-            ratio = cheapest_api["cost"] / cheapest["cost"]
-            if ratio > 1:
-                recommendation += f"<p>This is <strong>{1/ratio:.1f}x cheaper</strong> than the most affordable API option ({cheapest_api['provider']}).</p>"
-            else:
-                recommendation += f"<p>However, the API option ({cheapest_api['provider']}) is <strong>{ratio:.1f}x cheaper</strong>.</p>"
-    
-    # Additional recommendation text
-    if tokens_per_month > 100 and cheapest["type"] == "Cloud":
-        recommendation += "<p>With your high token volume, cloud hardware becomes more cost-effective despite the higher upfront costs.</p>"
-    elif compute_hours < 50 and cheapest["type"] == "API":
-        recommendation += "<p>With your low usage hours, API endpoints are more cost-effective as you only pay for what you use.</p>"
-    
-    # Create breakeven analysis HTML
-    breakeven = "<h3>Breakeven Analysis</h3>"
-    
-    if best_aws is not None and best_api_cost["total_cost"] > 0:
-        aws_hourly = aws_instances[best_aws]["hourly_rate"]
-        breakeven_hours = best_api_cost["total_cost"] / aws_hourly
-        
-        breakeven += f"<p>API vs AWS: <strong>{breakeven_hours:.1f} hours</strong> is the breakeven point.</p>"
-        
-        if compute_hours > breakeven_hours:
-            breakeven += "<p>You're past the breakeven point - AWS hardware is more cost-effective than API usage.</p>"
-        else:
-            breakeven += "<p>You're below the breakeven point - API usage is more cost-effective than AWS hardware.</p>"
-    
-    if best_gcp is not None and best_api_cost["total_cost"] > 0:
-        gcp_hourly = gcp_instances[best_gcp]["hourly_rate"]
-        breakeven_hours = best_api_cost["total_cost"] / gcp_hourly
-        
-        breakeven += f"<p>API vs GCP: <strong>{breakeven_hours:.1f} hours</strong> is the breakeven point.</p>"
-        
-        if compute_hours > breakeven_hours:
-            breakeven += "<p>You're past the breakeven point - GCP hardware is more cost-effective than API usage.</p>"
-        else:
-            breakeven += "<p>You're below the breakeven point - API usage is more cost-effective than GCP hardware.</p>"
-    
-    # Generate cost comparison chart
-    fig = px.bar(
-        pd.DataFrame(results),
-        x="provider",
-        y="cost",
-        color="type",
-        color_discrete_map={"Cloud": "#3B82F6", "API": "#8B5CF6"},
-        title="Monthly Cost Comparison",
-        labels={"provider": "Provider & Instance", "cost": "Monthly Cost ($)"}
-    )
-    
-    fig.update_layout(height=500)
-    
-    # Create HTML structure for the results
-    html_output = f"""
-    <div style="padding: 20px; font-family: Arial, sans-serif;">
-        <h2>Cost Comparison Results</h2>
-        
-        <div style="margin-bottom: 20px;">
-            {aws_results}
-        </div>
-        
-        <div style="margin-bottom: 20px;">
-            {gcp_results}
-        </div>
-        
-        <div style="margin-bottom: 20px;">
-            {api_results}
-        </div>
-        
-        <div style="margin-bottom: 20px;">
-            {recommendation}
-        </div>
-        
-        <div style="margin-bottom: 20px;">
-            {breakeven}
-        </div>
-        
-        <div style="margin-bottom: 20px;">
-            <h3>Additional Considerations</h3>
-            <div style="display: flex; gap: 20px;">
-                <div style="flex: 1; background-color: #F3F4F6; padding: 15px; border-radius: 8px;">
-                    <h4>Cloud Hardware Pros</h4>
-                    <ul>
-                        <li>Full control over infrastructure and customization</li>
-                        <li>Predictable costs for steady, high-volume workloads</li>
-                        <li>Can run multiple models simultaneously</li>
-                        <li>No token context limitations</li>
-                        <li>Data stays on your infrastructure</li>
-                    </ul>
-                </div>
-                <div style="flex: 1; background-color: #F3F4F6; padding: 15px; border-radius: 8px;">
-                    <h4>API Endpoints Pros</h4>
-                    <ul>
-                        <li>No infrastructure management overhead</li>
-                        <li>Pay-per-use model (ideal for sporadic usage)</li>
-                        <li>Instant scalability</li>
-                        <li>No upfront costs or commitment</li>
-                        <li>Automatic updates to newer model versions</li>
-                    </ul>
-                </div>
-            </div>
-        </div>
-        
-        <div style="background-color: #FEF3C7; padding: 15px; border-radius: 8px; margin-bottom: 20px;">
-            <p><strong>Note:</strong> These estimates are based on current pricing as of May 2025 and may vary based on regional pricing differences, discounts, and usage patterns.</p>
-        </div>
-    </div>
-    """
-    
-    return html_output, fig
-
-# Main app function
-def app_function(
-    compute_hours, 
-    tokens_per_month, 
-    input_ratio, 
-    api_calls, 
-    model_size, 
-    storage_gb, 
-    batch_size, 
-    reserved_instances, 
-    spot_instances, 
-    multi_year_commitment
-):
-    html_output, fig = generate_cost_comparison(
-        compute_hours, 
-        tokens_per_month, 
-        input_ratio, 
-        api_calls, 
-        model_size, 
-        storage_gb, 
-        reserved_instances, 
-        spot_instances, 
-        multi_year_commitment
-    )
-    
-    return html_output, fig
-
-# Define the Gradio interface
-with gr.Blocks(title="Cloud Cost Estimator", theme=gr.themes.Soft(primary_hue="indigo")) as demo:
-    gr.HTML("""
-    <div style="text-align: center; margin-bottom: 20px;">
-        <h1 style="color: #4F46E5; font-size: 2.5rem;">Cloud Cost Estimator</h1>
-        <p style="font-size: 1.2rem;">Compare costs between cloud hardware configurations and inference API endpoints</p>
-    </div>
-    """)
-    
-    with gr.Row():
-        with gr.Column(scale=1):
-            gr.HTML("<h3>Usage Parameters</h3>")
-            
-            compute_hours = gr.Slider(
-                label="Compute Hours per Month", 
-                minimum=1, 
-                maximum=730, 
-                value=100,
-                info="Number of hours you'll run the model per month"
-            )
-            
-            tokens_per_month = gr.Slider(
-                label="Tokens Processed per Month (millions)", 
-                minimum=1, 
-                maximum=1000, 
-                value=10,
-                info="Total number of tokens processed per month in millions"
-            )
-            
-            input_ratio = gr.Slider(
-                label="Input Token Ratio (%)", 
-                minimum=10, 
-                maximum=90, 
-                value=30,
-                info="Percentage of total tokens that are input tokens"
-            )
-            
-            api_calls = gr.Slider(
-                label="API Calls per Month", 
-                minimum=100, 
-                maximum=1000000, 
-                value=10000,
-                step=100,
-                info="Number of API calls made per month"
-            )
-            
-            model_size = gr.Dropdown(
-                label="Model Size",
-                choices=list(model_sizes.keys()),
-                value="Medium (13B parameters)",
-                info="Size of the language model you want to run"
-            )
-            
-            storage_gb = gr.Slider(
-                label="Storage Required (GB)", 
-                minimum=10, 
-                maximum=1000, 
-                value=100,
-                info="Amount of storage required for models and data"
-            )
-            
-            batch_size = gr.Slider(
-                label="Batch Size", 
-                minimum=1, 
-                maximum=64, 
-                value=4,
-                info="Batch size for inference (affects throughput)"
-            )
-            
-            gr.HTML("<h3>Advanced Options</h3>")
-            
-            reserved_instances = gr.Checkbox(
-                label="Use Reserved Instances", 
-                value=False,
-                info="Reserved instances offer significant discounts with 1-3 year commitments"
-            )
-            
-            spot_instances = gr.Checkbox(
-                label="Use Spot/Preemptible Instances", 
-                value=False,
-                info="Spot instances can be 70-90% cheaper but may be terminated with little notice"
-            )
-            
-            multi_year_commitment = gr.Radio(
-                label="Commitment Period (if using Reserved Instances)",
-                choices=[1, 3],
-                value=1,
-                info="Length of reserved instance commitment in years"
-            )
-            
-            submit_button = gr.Button("Calculate Costs", variant="primary")
-        
-        with gr.Column(scale=2):
-            results_html = gr.HTML(label="Results")
-            plot_output = gr.Plot(label="Cost Comparison")
-    
-    submit_button.click(
-        app_function,
-        inputs=[
-            compute_hours, 
-            tokens_per_month, 
-            input_ratio, 
-            api_calls, 
-            model_size, 
-            storage_gb, 
-            batch_size, 
-            reserved_instances, 
-            spot_instances, 
-            multi_year_commitment
-        ],
-        outputs=[results_html, plot_output]
-    )
-    
-    gr.HTML("""
-    <div style="margin-top: 30px; border-top: 1px solid #e5e7eb; padding-top: 20px;">
-        <h3>Help & Resources</h3>
-        <p><strong>Cloud Provider Documentation:</strong>
-            <a href="https://aws.amazon.com/ec2/pricing/" target="_blank">AWS EC2 Pricing</a> |
-            <a href="https://cloud.google.com/compute/pricing" target="_blank">GCP Compute Engine Pricing</a>
-        </p>
-        <p><strong>API Provider Documentation:</strong>
-            <a href="https://openai.com/pricing" target="_blank">OpenAI API Pricing</a> |
-            <a href="https://www.anthropic.com/api" target="_blank">Anthropic Claude API Pricing</a> |
-            <a href="https://www.together.ai/pricing" target="_blank">TogetherAI API Pricing</a>
-        </p>
-        <p>Made with ❤️ by Cloud Cost Estimator | Data last updated: May 2025</p>
-    </div>
-    """)
-
-demo.launch()
+if __name__ == "__main__":
+    demo.launch()