Update capex numbers; Fix and revamp champs

app.py

@@ -1,173 +1,87 @@
 import json
-import pickle
 from datetime import datetime, date
 
 import gradio as gr
-import pandas as pd
 import plotly.graph_objects as go
 
 
-def create_big_five_capex_plot():
-    # Capex in Millions of USD per Quarter of Microsoft, Google, Meta, Apple, Amazon
-    big_five_capex = []
-    with open("big_five_capex.jsonl", 'r') as file:
-        for line in file:
-            big_five_capex.append(json.loads(line))
+def create_big_five_capex_plot() -> go.Figure:
+    # Read data from the JSON Lines file.
+    with open("big_five_capex.jsonl", "r") as file:
+        data = [json.loads(line) for line in file if line.strip()]
 
-    df = pd.DataFrame(big_five_capex)
-    
-    fig = go.Figure()
-    
+    quarters: list[str] = [entry["Quarter"] for entry in data]
     companies = ['Microsoft', 'Google', 'Meta', 'Apple', 'Amazon']
     colors = ['#80bb00', '#ee161f', '#0065e3', '#000000', '#ff6200']
-    
-    for company, color in zip(companies, colors):
-        fig.add_trace(go.Bar(
-            x=df['Quarter'],
-            y=df[company],
-            name=company,
-            marker_color=color
-        ))
-
-    fig.add_vline(
-        x=df.index[df['Quarter'] == "2023 Q1"].tolist()[0] + 0.5,
-        line_width=1,
-        line_dash="dash",
-        line_color="black",
-        annotation_text="AI arms race begins",
-        annotation_position="top right",
-        annotation_font_size=12,
-        annotation_font_color="black"
-    )
-
-    fig.update_layout(
-        title='Capital Expenditure of the Big Five Tech Companies in Millions of U.S. Dollars per Quarter',
-        xaxis_title='Quarter',
-        yaxis_title='Capex (Millions of U.S. Dollars)',
-        barmode='stack',
-        legend_title='Companies',
-        height=800
-    )
-
-    return fig
-
-
-def create_chip_designers_data_center_revenue_plot():
-    # Data Center Revenue in Millions of USD per Quarter of NVIDIA, AMD and Intel
-    data_center_revenue_by_company = []
-    with open("chip_designers_data_center_revenue.jsonl", 'r') as file:
-        for line in file:
-            data_center_revenue_by_company.append(json.loads(line))
-
-    df = pd.DataFrame(data_center_revenue_by_company)
-
-    fig = go.Figure()
 
-    companies = ['NVIDIA', 'AMD', 'Intel']
-    colors = ['#80bb00', '#ee161f', '#0065e3']  # TODO
+    x_positions = list(range(len(quarters)))
 
+    traces = []
     for company, color in zip(companies, colors):
-        fig.add_trace(go.Bar(
-            x=df['Quarter'],
-            y=df[company],
+        y_data = [entry[company] for entry in data]
+        traces.append(go.Bar(
             name=company,
+            x=x_positions,
+            y=y_data,
             marker_color=color
         ))
 
+    fig = go.Figure(data=traces)
     fig.update_layout(
-        title='Data Center Revenue of NVIDIA, AMD and Intel in Millions of U.S. Dollars per Quarter',
-        xaxis_title='Quarter',
-        yaxis_title='Data Center Revenue (Millions of U.S. Dollars)',
-        barmode='stack',
-        legend_title='Companies',
-        height=800
+        barmode="stack",
+        title="Capital Expenditures of the Big Five Tech Companies in Millions of USD per Quarter",
+        xaxis_title="Quarter",
+        yaxis_title="Capital Expenditures (Millions USD)",
+        xaxis=dict(
+            tickmode='array',
+            tickvals=x_positions,
+            ticktext=quarters
+        ),
+        height=600
     )
 
-    return fig
-
-
-def create_size_for_performance_plot(category_to_display: str,
-                                     parameter_type_to_display: str,
-                                     model_to_compare: str) -> (go.Figure, gr.Dropdown, gr.Dropdown):
-    with open('elo_results_20240915.pkl', 'rb') as file:
-        elo_results = pickle.load(file)
-    categories: list[str] = list(elo_results["text"].keys())
-    if category_to_display not in categories:
-        raise gr.Error(message=f"Category '{category_to_display}' not found.")
-    elo_ratings_for_category: dict = dict(elo_results["text"][category_to_display]["elo_rating_final"])
-
-    models: list[dict] = []
-    with open("models.jsonl", 'r') as file:
-        for line in file:
-            models.append(json.loads(line))
-
-    size_for_performance_data: list[dict] = []
-    for model_name, model_elo_rating in elo_ratings_for_category.items():
-        model_entries_found = [model for model in models if model["Name"] == model_name]
-        if model_entries_found:
-            size_for_performance_data.append({
-                "Name": model_name,
-                "Release Date": model_entries_found[0]["Release Date"],
-                "ELO Rating": model_elo_rating,
-                parameter_type_to_display: model_entries_found[0][parameter_type_to_display]
-            })
-        else:
-            print(f"[WARNING] Model '{model_name}' not found in models.jsonl")
-
-    comparison_model_elo_score = elo_ratings_for_category[model_to_compare]
-    filtered_models = [model for model in size_for_performance_data
-                       if model[parameter_type_to_display] > 0 and
-                       model['ELO Rating'] >= comparison_model_elo_score]
-
-    filtered_models.sort(key=lambda x: datetime.strptime(x['Release Date'], "%Y-%m-%d"))
-
-    x_dates = [datetime.strptime(model['Release Date'], "%Y-%m-%d") for model in filtered_models]
-    y_params = []
-    min_param = float('inf')
-    for model in filtered_models:
-        param = model[parameter_type_to_display]
-        if param <= min_param:
-            min_param = param
-        y_params.append(min_param)
-
-    fig = go.Figure()
-
-    fig.add_trace(go.Scatter(
-        x=x_dates,
-        y=y_params,
-        mode='lines',
-        line=dict(shape='hv', width=2),
-        name='Model Parameters'
-    ))
+    # Calculate the x position for the vertical dotted line.
+    # We want the line drawn between "2023 Q1" and "2023 Q2".
+    try:
+        idx_q1 = quarters.index("2023 Q1")
+        idx_q2 = quarters.index("2023 Q2")
+        vline_x = (idx_q1 + idx_q2) / 2  # position midway between the two quarters
+    except ValueError:
+        # Fall back if quarters not found.
+        vline_x = 0
+
+    # Add a vertical dotted line spanning the full height
+    fig.add_shape(
+        type="line",
+        xref="x",
+        yref="paper",
+        x0=vline_x,
+        y0=0,
+        x1=vline_x,
+        y1=1,
+        line=dict(
+            color="black",
+            dash="dot",
+            width=2
+        )
+    )
 
-    fig.update_layout(
-        title=f'Model Size Progression for Open-Weights Models Reaching Performance of "{model_to_compare}" in "{category_to_display}" Category',
-        xaxis_title='Release Date',
-        yaxis_title=parameter_type_to_display,
-        yaxis_type='log',
-        hovermode='x unified',
-        xaxis=dict(
-            range=[date(2023, 2, 27), date(2024, 9, 15)],
-            type='date'
+    # Add an annotation label above the vertical line.
+    fig.add_annotation(
+        x=vline_x,
+        y=1.05,  # place just above the top of the plotting area
+        xref="x",
+        yref="paper",
+        text="AI arms race begins",
+        showarrow=False,
+        font=dict(
+            color="black",
+            size=12
         ),
-        height=800
+        align="center"
     )
 
-    for i, model in enumerate(filtered_models):
-        if i == 0 or y_params[i] < y_params[i - 1]:
-            fig.add_trace(go.Scatter(
-                x=[x_dates[i]],
-                y=[y_params[i]],
-                mode='markers+text',
-                marker=dict(size=10),
-                text=[model['Name']],
-                textposition="top center",
-                name=model['Name']
-            ))
-
-    return (fig,
-            gr.Dropdown(choices=categories, value=category_to_display, interactive=True),
-            gr.Dropdown(choices=list(elo_ratings_for_category.keys()), value=model_to_compare, interactive=True))
+    return fig
 
 
 def create_simple_plot(data_path: str,
@@ -246,34 +160,6 @@ def create_simple_plot(data_path: str,
 
 
 with gr.Blocks() as demo:
-    with gr.Tab("Finance"):
-        with gr.Tab("Big Five Capex") as big_five_capex_tab:
-            big_five_capex_plot: gr.Plot = gr.Plot()
-        with gr.Tab("Chip Designers Data Center Revenue") as chip_designers_data_center_revenue_tab:
-            chip_designers_data_center_revenue_plot: gr.Plot = gr.Plot()
-    with gr.Tab("Model Efficiency Over Time"):
-        with gr.Tab("Parameters Necessary for Specific Performance Level") as size_for_performance_tab:
-            with gr.Row():
-                size_for_performance_category_dropdown: gr.Dropdown = gr.Dropdown(label="Category",
-                                                                                  value="full",
-                                                                                  choices=["full"],
-                                                                                  interactive=False)
-                size_for_performance_parameter_number_dropdown: gr.Dropdown = gr.Dropdown(label="Parameter Number",
-                                                                                          choices=["Total Parameters",
-                                                                                                   "Active Parameters"],
-                                                                                          value="Total Parameters",
-                                                                                          interactive=True)
-                size_for_performance_comparison_model_dropdown: gr.Dropdown = gr.Dropdown(label="Model for Comparison",
-                                                                                          value="gpt-4-0314",
-                                                                                          choices=["gpt-4-0314"],
-                                                                                          interactive=False)
-            size_for_performance_plot: gr.Plot = gr.Plot()
-            size_for_performance_button: gr.Button = gr.Button("Show")
-            size_for_performance_markdown: gr.Markdown = gr.Markdown(
-                value="""Model performance as reported on [LMSYS Chatbot Arena Leaderboard](https://lmarena.ai/?leaderboard)."""
-            )
-        with gr.Tab("API Cost for Specific Performance Level", interactive=False):
-            api_cost_for_performance_plot: gr.Plot = gr.Plot()
     with gr.Tab("System Performance Over Time"):
         with gr.Tab("ARC-AGI-Pub") as arc_agi_tab:
             arc_agi_plot: gr.Plot = gr.Plot()
@@ -307,21 +193,13 @@ with gr.Blocks() as demo:
             webarena_plot: gr.Plot = gr.Plot()
         with gr.Tab("ZeroEval", interactive=False):
             zeroeval_plot: gr.Plot = gr.Plot()
-    with gr.Tab("Frontier Language Model Training Runs", interactive=False):
-        with gr.Tab("Street Price of GPUs Used"):
-            gpu_street_price_plot: gr.Plot = gr.Plot()
-        with gr.Tab("TDP of GPUs Used"):
-            tdp_gpus_plot: gr.Plot = gr.Plot()
+    with gr.Tab("Finance") as finance_tab:
+        with gr.Tab("Big Five Capex") as big_five_capex_tab:
+            big_five_capex_plot: gr.Plot = gr.Plot()
+        with gr.Tab("NVIDIA Revenue", interactive=False) as nvidia_revenue:
+            nvidia_revenue_plot: gr.Plot = gr.Plot()
     big_five_capex_tab.select(fn=create_big_five_capex_plot, outputs=big_five_capex_plot)
-    chip_designers_data_center_revenue_tab.select(fn=create_chip_designers_data_center_revenue_plot,
-                                                  outputs=chip_designers_data_center_revenue_plot)
-    size_for_performance_button.click(fn=create_size_for_performance_plot,
-                                      inputs=[size_for_performance_category_dropdown,
-                                              size_for_performance_parameter_number_dropdown,
-                                              size_for_performance_comparison_model_dropdown],
-                                      outputs=[size_for_performance_plot,
-                                               size_for_performance_category_dropdown,
-                                               size_for_performance_comparison_model_dropdown])
+    finance_tab.select(fn=create_big_five_capex_plot, outputs=big_five_capex_plot)
     arc_agi_tab.select(fn=create_simple_plot,
                        inputs=[gr.State("arc_agi_leaderboard.jsonl"), gr.State("ARC-AGI-Pub (Public Eval) Score"),
                                gr.State(date(2024, 5, 13)), gr.State(date(2024, 12, 20))],

big_five_capex.jsonl

@@ -1,4 +1,3 @@
-{"Quarter": "2014 Q4", "Microsoft": 1490, "Google": 3606, "Meta": 517, "Apple": 3217, "Amazon": 1145}
 {"Quarter": "2015 Q1", "Microsoft": 1391, "Google": 2927, "Meta": 502, "Apple": 2369, "Amazon": 871}
 {"Quarter": "2015 Q2", "Microsoft": 1781, "Google": 2515, "Meta": 549, "Apple": 2043, "Amazon": 1213}
 {"Quarter": "2015 Q3", "Microsoft": 1356, "Google": 2406, "Meta": 780, "Apple": 3618, "Amazon": 1195}
@@ -38,4 +37,4 @@
 {"Quarter": "2024 Q1", "Microsoft": 10952, "Google": 12012, "Meta": 6400, "Apple": 1996, "Amazon": 14925}
 {"Quarter": "2024 Q2", "Microsoft": 13873, "Google": 13186, "Meta": 8173, "Apple": 2151, "Amazon": 17620}
 {"Quarter": "2024 Q3", "Microsoft": 14923, "Google": 13016, "Meta": 8258, "Apple": 0, "Amazon": 22620}
-{"Quarter": "2024 Q4", "Microsoft": 0, "Google": 0, "Meta": 14425, "Apple": 0, "Amazon": 0}
+{"Quarter": "2024 Q4", "Microsoft": 15804, "Google": 14276, "Meta": 14425, "Apple": 0, "Amazon": 27834}

elo_results_20240915.pkl

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:bdce5fbf7a50d53ce549fd2c6c230627397856c4b62807b0e97a7f2c8554045e
-size 3707205