adding new weekly and daily graphs

app.py

@@ -7,19 +7,20 @@ import logging
 
 from scripts.metrics import (
     compute_weekly_metrics_by_market_creator,
-    compute_weekly_metrics_by_trader_type,
+    compute_daily_metrics_by_market_creator,
     compute_winning_metrics_by_trader,
 )
 from tabs.trader_plots import (
     plot_trader_metrics_by_market_creator,
+    plot_trader_daily_metrics_by_market_creator,
     default_trader_metric,
     trader_metric_choices,
     get_metrics_text,
     plot_winning_metric_per_trader,
     get_interpretation_text,
-    plot_median_roi_by_creation_date,
 )
 
+from scripts.utils import get_traders_family
 from tabs.market_plots import (
     plot_kl_div_per_market,
 )
@@ -86,8 +87,12 @@ def prepare_data():
     trader_agents_data = pd.merge(
         all_trades, volume_trades_per_trader_and_market, on=["trader_address", "title"]
     )
-    # right now all traders are of the same type: singlebet
-    trader_agents_data["trader_type"] = "singlebet"
+
+    # adding the trader family column
+    # trader_agents_data["trader_family"] = trader_agents_data.apply(
+    #     lambda x: get_traders_family(x), axis=1
+    # )
+    # print(trader_agents_data.trader_family.value_counts())
 
     trader_agents_data = trader_agents_data.sort_values(
         by="creation_timestamp", ascending=True
@@ -104,19 +109,25 @@ def prepare_data():
 
 
 trader_agents_data, closed_markets = prepare_data()
-print("trader agents data before computing metrics")
-print(trader_agents_data.head())
+# print("trader agents data before computing metrics")
+# print(trader_agents_data.head())
 demo = gr.Blocks()
 # get weekly metrics by market creator: qs, pearl or all.
 weekly_metrics_by_market_creator = compute_weekly_metrics_by_market_creator(
     trader_agents_data
 )
-print("weekly metrics by market creator")
-print(weekly_metrics_by_market_creator.head())
-# get weekly metrics by trader type: multibet, singlebet or all.
-weekly_metrics_by_trader_type = compute_weekly_metrics_by_trader_type(
+daily_metrics_by_market_creator = compute_daily_metrics_by_market_creator(
     trader_agents_data
 )
+weekly_agent_metrics_by_market_creator = compute_weekly_metrics_by_market_creator(
+    trader_agents_data, trader_filter="agent"
+)
+weekly_non_agent_metrics_by_market_creator = compute_weekly_metrics_by_market_creator(
+    trader_agents_data, trader_filter="non_agent"
+)
+# print("weekly metrics by market creator")
+# print(weekly_metrics_by_market_creator.head())
+
 weekly_winning_metrics = compute_winning_metrics_by_trader(
     trader_agents_data=trader_agents_data
 )
@@ -127,12 +138,12 @@ with demo:
     )
 
     with gr.Tabs():
-        with gr.TabItem("🔥Trader Agents Dashboard"):
+        with gr.TabItem("🔥 Weekly metrics"):
             with gr.Row():
-                gr.Markdown("# Weekly metrics of trader agents by market creator")
+                gr.Markdown("# Weekly metrics of all traders")
             with gr.Row():
                 trader_details_selector = gr.Dropdown(
-                    label="Select a trader metric",
+                    label="Select a weekly trader metric",
                     choices=trader_metric_choices,
                     value=default_trader_metric,
                 )
@@ -157,12 +168,99 @@ with demo:
                 inputs=trader_details_selector,
                 outputs=trader_markets_plot,
             )
-            # with gr.Row():
-            #     gr.Markdown("# Daily Median ROI by market creator")
-            # with gr.Row():
-            #     daily_median = plot_median_roi_by_creation_date(
-            #         traders_df=trader_agents_data
-            #     )
+            # Agentic traders graph
+            with gr.Row():
+                gr.Markdown("# Weekly metrics of trader Agents")
+            with gr.Row():
+                trader_a_details_selector = gr.Dropdown(
+                    label="Select a weekly trader metric",
+                    choices=trader_metric_choices,
+                    value=default_trader_metric,
+                )
+
+            with gr.Row():
+                with gr.Column(scale=3):
+                    a_trader_markets_plot = plot_trader_metrics_by_market_creator(
+                        metric_name=default_trader_metric,
+                        traders_df=weekly_agent_metrics_by_market_creator,
+                    )
+                with gr.Column(scale=1):
+                    trade_details_text = get_metrics_text()
+
+            def update_a_trader_details(trader_detail):
+                return plot_trader_metrics_by_market_creator(
+                    metric_name=trader_detail,
+                    traders_df=weekly_agent_metrics_by_market_creator,
+                )
+
+            trader_a_details_selector.change(
+                update_a_trader_details,
+                inputs=trader_a_details_selector,
+                outputs=a_trader_markets_plot,
+            )
+
+            # Non-agentic traders graph
+            with gr.Row():
+                gr.Markdown("# Weekly metrics of Non-agent traders")
+            with gr.Row():
+                trader_na_details_selector = gr.Dropdown(
+                    label="Select a weekly trader metric",
+                    choices=trader_metric_choices,
+                    value=default_trader_metric,
+                )
+
+            with gr.Row():
+                with gr.Column(scale=3):
+                    na_trader_markets_plot = plot_trader_metrics_by_market_creator(
+                        metric_name=default_trader_metric,
+                        traders_df=weekly_non_agent_metrics_by_market_creator,
+                    )
+                with gr.Column(scale=1):
+                    trade_details_text = get_metrics_text()
+
+            def update_na_trader_details(trader_detail):
+                return plot_trader_metrics_by_market_creator(
+                    metric_name=trader_detail,
+                    traders_df=weekly_non_agent_metrics_by_market_creator,
+                )
+
+            trader_na_details_selector.change(
+                update_na_trader_details,
+                inputs=trader_na_details_selector,
+                outputs=na_trader_markets_plot,
+            )
+        with gr.TabItem("🔥 Daily metrics"):
+            with gr.Row():
+                gr.Markdown("# Daily metrics of last week of all traders")
+            with gr.Row():
+                trader_daily_details_selector = gr.Dropdown(
+                    label="Select a daily trader metric",
+                    choices=trader_metric_choices,
+                    value=default_trader_metric,
+                )
+
+            with gr.Row():
+                with gr.Column(scale=3):
+                    trader_daily_markets_plot = (
+                        plot_trader_daily_metrics_by_market_creator(
+                            metric_name=default_trader_metric,
+                            traders_df=daily_metrics_by_market_creator,
+                        )
+                    )
+                with gr.Column(scale=1):
+                    trade_details_text = get_metrics_text()
+
+            def update_trader_daily_details(trader_detail):
+                return plot_trader_daily_metrics_by_market_creator(
+                    metric_name=trader_detail,
+                    traders_df=daily_metrics_by_market_creator,
+                )
+
+            trader_daily_details_selector.change(
+                update_trader_daily_details,
+                inputs=trader_daily_details_selector,
+                outputs=trader_daily_markets_plot,
+            )
 
         with gr.TabItem("📉Closed Markets Kullback–Leibler divergence"):
             with gr.Row():

scripts/metrics.py

@@ -7,76 +7,79 @@ DEFAULT_MECH_FEE = 0.01  # xDAI
 def compute_metrics(trader_address: str, trader_data: pd.DataFrame) -> dict:
 
     if len(trader_data) == 0:
-        print("No data to compute metrics")
+        # print("No data to compute metrics")
         return {}
 
-    weekly_metrics = {}
-    weekly_metrics["trader_address"] = trader_address
+    agg_metrics = {}
+    agg_metrics["trader_address"] = trader_address
     total_net_earnings = trader_data.net_earnings.sum()
     total_bet_amounts = trader_data.collateral_amount.sum()
     total_num_mech_calls = trader_data.num_mech_calls.sum()
-    weekly_metrics["net_earnings"] = total_net_earnings
-    weekly_metrics["earnings"] = trader_data.earnings.sum()
-    weekly_metrics["bet_amount"] = total_bet_amounts
-    weekly_metrics["nr_mech_calls"] = total_num_mech_calls
+    agg_metrics["net_earnings"] = total_net_earnings
+    agg_metrics["earnings"] = trader_data.earnings.sum()
+    agg_metrics["bet_amount"] = total_bet_amounts
+    agg_metrics["nr_mech_calls"] = total_num_mech_calls
+    agg_metrics["nr_trades"] = len(trader_data)
     total_fee_amounts = trader_data.mech_fee_amount.sum()
     total_costs = (
         total_bet_amounts
         + total_fee_amounts
         + (total_num_mech_calls * DEFAULT_MECH_FEE)
     )
-    weekly_metrics["roi"] = total_net_earnings / total_costs
-    return weekly_metrics
+    agg_metrics["roi"] = total_net_earnings / total_costs
+    return agg_metrics
 
 
-def compute_trader_metrics_by_trader_type(
-    trader_address: str, week_traders_data: pd.DataFrame, trader_type: str = "all"
-) -> pd.DataFrame:
-    """This function computes for a specific week the different metrics: roi, net_earnings, earnings, bet_amount, nr_mech_calls.
-    The global roi of the trader agent by computing the individual net profit and the indivicual costs values
+def compute_trader_metrics_by_market_creator(
+    trader_address: str, traders_data: pd.DataFrame, market_creator: str = "all"
+) -> dict:
+    """This function computes for a specific time window (week or day) the different metrics:
+    roi, net_earnings, earnings, bet_amount, nr_mech_calls and nr_trades.
+    The global roi of the trader agent by computing the individual net profit and the individual costs values
     achieved per market and dividing both.
-    It is possible to filter by trader type: multibet, singlebet, all"""
-    assert "trader_type" in week_traders_data.columns
-    filtered_traders_data = week_traders_data.loc[
-        week_traders_data["trader_address"] == trader_address
+    It is possible to filter by market creator: quickstart, pearl, all"""
+    assert "market_creator" in traders_data.columns
+    filtered_traders_data = traders_data.loc[
+        traders_data["trader_address"] == trader_address
     ]
-
-    if trader_type != "all":  # compute only for the specific type
+    if market_creator != "all":  # compute only for the specific market creator
         filtered_traders_data = filtered_traders_data.loc[
-            filtered_traders_data["trader_type"] == trader_type
+            filtered_traders_data["market_creator"] == market_creator
         ]
         if len(filtered_traders_data) == 0:
-            return pd.DataFrame()  # No Data
+            # tqdm.write(f"No data. Skipping market creator {market_creator}")
+            return {}  # No Data
 
-    return compute_metrics(trader_address, filtered_traders_data)
+    metrics = compute_metrics(trader_address, filtered_traders_data)
+    return metrics
 
 
-def compute_trader_metrics_by_market_creator(
-    trader_address: str, week_traders_data: pd.DataFrame, market_creator: str = "all"
+def compute_trader_metrics_by_trader_family(
+    trader_address: str, traders_data: pd.DataFrame, trader_family: str = "all"
 ) -> dict:
-    """This function computes for a specific week the different metrics: roi, net_earnings, earnings, bet_amount, nr_mech_calls.
-    The global roi of the trader agent by computing the individual net profit and the indivicual costs values
+    """This function computes for a specific time window (week or day) the different metrics:
+    roi, net_earnings, earnings, bet_amount, nr_mech_calls and nr_trades.
+    The global roi of the trader agent by computing the individual net profit and the individual costs values
     achieved per market and dividing both.
-    It is possible to filter by market creator: quickstart, pearl, all"""
-    assert "market_creator" in week_traders_data.columns
-    filtered_traders_data = week_traders_data.loc[
-        week_traders_data["trader_address"] == trader_address
+    It is possible to filter by trader family: quickstart_agent, pearl_agent, non_agent, all
+    """
+    assert "trader_family" in traders_data.columns
+    filtered_traders_data = traders_data.loc[
+        traders_data["trader_address"] == trader_address
     ]
-    if market_creator != "all":  # compute only for the specific market creator
+    if trader_family != "all":  # compute only for the specific trader family
         filtered_traders_data = filtered_traders_data.loc[
-            filtered_traders_data["market_creator"] == market_creator
+            filtered_traders_data["trader_family"] == trader_family
         ]
         if len(filtered_traders_data) == 0:
-            tqdm.write(f"No data. Skipping market creator {market_creator}")
+            # tqdm.write(f"No data. Skipping trader family {trader_family}")
             return {}  # No Data
-    # tqdm.write(
-    #     f"Volume of data for trader {trader_address} and market creator {market_creator} = {len(filtered_traders_data)}"
-    # )
+
     metrics = compute_metrics(trader_address, filtered_traders_data)
     return metrics
 
 
-def merge_trader_metrics(
+def merge_trader_weekly_metrics(
     trader: str, weekly_data: pd.DataFrame, week: str
 ) -> pd.DataFrame:
     trader_metrics = []
@@ -105,41 +108,38 @@ def merge_trader_metrics(
         weekly_metrics_pearl["market_creator"] = "pearl"
         trader_metrics.append(weekly_metrics_pearl)
     result = pd.DataFrame.from_dict(trader_metrics, orient="columns")
-    # tqdm.write(f"Total length of all trader metrics for this week = {len(result)}")
     return result
 
 
-def merge_trader_metrics_by_type(
-    trader: str, weekly_data: pd.DataFrame, week: str
+def merge_trader_daily_metrics(
+    trader: str, daily_data: pd.DataFrame, day: str
 ) -> pd.DataFrame:
     trader_metrics = []
-    # computation as specification 1 for all types of traders
-    weekly_metrics_all = compute_trader_metrics_by_trader_type(
-        trader, weekly_data, trader_type="all"
+    # computation as specification 1 for all types of markets
+    daily_metrics_all = compute_trader_metrics_by_market_creator(
+        trader, daily_data, market_creator="all"
     )
-    weekly_metrics_all["month_year_week"] = week
-    weekly_metrics_all["trader_type"] = "all"
-    trader_metrics.append(weekly_metrics_all)
+    daily_metrics_all["creation_date"] = day
+    daily_metrics_all["market_creator"] = "all"
+    trader_metrics.append(daily_metrics_all)
 
-    # computation as specification 1 for multibet traders
-    weekly_metrics_mb = compute_trader_metrics_by_trader_type(
-        trader, weekly_data, trader_type="multibet"
+    # computation as specification 1 for quickstart markets
+    daily_metrics_qs = compute_trader_metrics_by_market_creator(
+        trader, daily_data, market_creator="quickstart"
     )
-    if len(weekly_metrics_mb) > 0:
-        weekly_metrics_mb["month_year_week"] = week
-        weekly_metrics_mb["trader_type"] = "multibet"
-        trader_metrics.append(weekly_metrics_mb)
-
-    # computation as specification 1 for singlebet traders
-    weekly_metrics_sb = compute_trader_metrics_by_trader_type(
-        trader, weekly_data, trader_type="singlebet"
+    if len(daily_metrics_qs) > 0:
+        daily_metrics_qs["creation_date"] = day
+        daily_metrics_qs["market_creator"] = "quickstart"
+        trader_metrics.append(daily_metrics_qs)
+    # computation as specification 1 for pearl markets
+    daily_metrics_pearl = compute_trader_metrics_by_market_creator(
+        trader, daily_data, market_creator="pearl"
     )
-    if len(weekly_metrics_sb) > 0:
-        weekly_metrics_sb["month_year_week"] = week
-        weekly_metrics_sb["trader_type"] = "singlebet"
-        trader_metrics.append(weekly_metrics_sb)
+    if len(daily_metrics_pearl) > 0:
+        daily_metrics_pearl["creation_date"] = day
+        daily_metrics_pearl["market_creator"] = "pearl"
+        trader_metrics.append(daily_metrics_pearl)
     result = pd.DataFrame.from_dict(trader_metrics, orient="columns")
-    # tqdm.write(f"Total length of all trader metrics for this week = {len(result)}")
     return result
 
 
@@ -161,9 +161,10 @@ def win_metrics_trader_level(weekly_data):
 
 
 def compute_weekly_metrics_by_market_creator(
-    trader_agents_data: pd.DataFrame,
+    trader_agents_data: pd.DataFrame, trader_filter: str = None
 ) -> pd.DataFrame:
-    """Function to compute the metrics at the trader level per week and with different categories by market creator"""
+    """Function to compute the metrics at the trader level per week
+    and with different categories by market creator"""
     contents = []
     all_weeks = list(trader_agents_data.month_year_week.unique())
     for week in all_weeks:
@@ -174,27 +175,51 @@ def compute_weekly_metrics_by_market_creator(
         # traverse each trader agent
         traders = list(weekly_data.trader_address.unique())
         for trader in tqdm(traders, desc=f"Trader' metrics", unit="metrics"):
-            contents.append(merge_trader_metrics(trader, weekly_data, week))
+            if trader_filter is None:
+                contents.append(merge_trader_weekly_metrics(trader, weekly_data, week))
+            elif trader_filter == "agent":
+                filtered_data = weekly_data.loc[weekly_data["staking"] != "non_agent"]
+                contents.append(
+                    merge_trader_weekly_metrics(trader, filtered_data, week)
+                )
+            else:  # non_agent traders
+                filtered_data = weekly_data.loc[weekly_data["staking"] == "non_agent"]
+                contents.append(
+                    merge_trader_weekly_metrics(trader, filtered_data, week)
+                )
+
     print("End computing all weekly metrics by market creator")
     return pd.concat(contents, ignore_index=True)
 
 
-def compute_weekly_metrics_by_trader_type(
-    trader_agents_data: pd.DataFrame,
+def compute_daily_metrics_by_market_creator(
+    trader_agents_data: pd.DataFrame, trader_filter: str = None
 ) -> pd.DataFrame:
-    """Function to compute the metrics at the trader level per week and with different types of traders"""
+    """Function to compute the metrics at the trader level per day
+    and with different categories by market creator"""
     contents = []
-    all_weeks = list(trader_agents_data.month_year_week.unique())
-    for week in all_weeks:
-        weekly_data = trader_agents_data.loc[
-            trader_agents_data["month_year_week"] == week
-        ]
-        print(f"Computing weekly metrics for week ={week} by trader type")
+    # trader_agents_data is already sorted by timestamp, so last item is last week
+    last_week = trader_agents_data.iloc[-1].month_year_week
+    print(f"Computing daily metrics for week ={last_week} by market creator")
+    last_week_data = trader_agents_data.loc[
+        trader_agents_data["month_year_week"] == last_week
+    ]
+    all_days = list(last_week_data.creation_date.unique())
+    for day in all_days:
+        daily_data = last_week_data.loc[last_week_data["creation_date"] == day]
+        print(f"Computing daily metrics for {day}")
         # traverse each trader agent
-        traders = list(weekly_data.trader_address.unique())
-        for trader in tqdm(traders, desc=f"Trader' metrics", unit="metrics"):
-            contents.append(merge_trader_metrics_by_type(trader, weekly_data, week))
-    print("End computing all weekly metrics by trader types")
+        traders = list(daily_data.trader_address.unique())
+        for trader in tqdm(traders, desc=f"Trader' daily metrics", unit="metrics"):
+            if trader_filter is None:
+                contents.append(merge_trader_daily_metrics(trader, daily_data, day))
+            elif trader_filter == "agentic":
+                filtered_data = daily_data.loc[daily_data["staking"] != "non_agent"]
+                contents.append(merge_trader_daily_metrics(trader, filtered_data, day))
+            else:  # non_agent traders
+                filtered_data = daily_data.loc[daily_data["staking"] == "non_agent"]
+                contents.append(merge_trader_daily_metrics(trader, filtered_data, day))
+    print("End computing all daily metrics by market creator")
     return pd.concat(contents, ignore_index=True)
 
 

scripts/utils.py

@@ -0,0 +1,10 @@
+import pandas as pd
+
+
+def get_traders_family(row: pd.DataFrame) -> str:
+    if row.staking == "non_agent":
+        return "non_agent"
+    elif row.market_creator == "pearl":
+        return "pearl_agent"
+    # quickstart
+    return "quickstart_agent"

tabs/trader_plots.py

@@ -8,6 +8,7 @@ trader_metric_choices = [
     "earnings",
     "net earnings",
     "ROI",
+    "nr_trades",
 ]
 default_trader_metric = "ROI"
 
@@ -63,6 +64,9 @@ def plot_trader_metrics_by_market_creator(
         metric_name = "net_earnings"
         column_name = metric_name
         yaxis_title = "Total net profit per trader (xDAI)"
+    elif metric_name == "nr_trades":
+        column_name = metric_name
+        yaxis_title = "Total nr of trades per trader"
     else:  # earnings
         column_name = metric_name
         yaxis_title = "Total gross profit per trader (xDAI)"
@@ -90,6 +94,56 @@ def plot_trader_metrics_by_market_creator(
     )
 
 
+def plot_trader_daily_metrics_by_market_creator(
+    metric_name: str, traders_df: pd.DataFrame
+) -> gr.Plot:
+    """Plots the daily trader metrics."""
+
+    if metric_name == "mech calls":
+        metric_name = "mech_calls"
+        column_name = "nr_mech_calls"
+        yaxis_title = "Total nr of mech calls per trader"
+    elif metric_name == "ROI":
+        column_name = "roi"
+        yaxis_title = "Total ROI (net profit/cost)"
+    elif metric_name == "bet amount":
+        metric_name = "bet_amount"
+        column_name = metric_name
+        yaxis_title = "Total bet amount per trader (xDAI)"
+    elif metric_name == "net earnings":
+        metric_name = "net_earnings"
+        column_name = metric_name
+        yaxis_title = "Total net profit per trader (xDAI)"
+    elif metric_name == "nr_trades":
+        column_name = metric_name
+        yaxis_title = "Total nr of trades per trader"
+    else:  # earnings
+        column_name = metric_name
+        yaxis_title = "Total gross profit per trader (xDAI)"
+
+    traders_filtered = traders_df[["creation_date", "market_creator", column_name]]
+
+    fig = px.box(
+        traders_filtered,
+        x="creation_date",
+        y=column_name,
+        color="market_creator",
+        color_discrete_sequence=["purple", "goldenrod", "darkgreen"],
+        category_orders={"market_creator": ["pearl", "quickstart", "all"]},
+    )
+    fig.update_traces(boxmean=True)
+    fig.update_layout(
+        xaxis_title="Day",
+        yaxis_title=yaxis_title,
+        legend=dict(yanchor="top", y=0.5),
+    )
+    fig.update_xaxes(tickformat="%b %d\n%Y")
+
+    return gr.Plot(
+        value=fig,
+    )
+
+
 def plot_median_roi_by_creation_date(traders_df: pd.DataFrame) -> gr.Plot:
     traders_df["creation_date"] = traders_df["creation_timestamp"].dt.date