adding more graphs

app.py

@@ -9,7 +9,11 @@ from tabs.tokens_votes_dist import (
     get_based_tokens_distribution,
     get_based_votes_distribution,
 )
-from tabs.dist_gap import get_distribution_plot
+from tabs.dist_gap import (
+    get_distribution_plot,
+    get_correlation_map,
+    get_kde_with_trades,
+)
 
 
 def get_logger():
@@ -45,6 +49,10 @@ def prepare_data():
     df["sample_datetime"] = df["sample_timestamp"].apply(
         lambda x: datetime.fromtimestamp(x)
     )
+    df["opening_datetime"] = df["openingTimestamp"].apply(
+        lambda x: datetime.fromtimestamp(int(x))
+    )
+    df["days_to_resolution"] = (df["opening_datetime"] - df["sample_datetime"]).dt.days
     return df
 
 
@@ -74,16 +82,19 @@ with demo:
     with gr.Tabs():
         with gr.TabItem("💹 Probability distributions of live markets"):
             with gr.Row():
-                gr.Markdown("# Evolution of outcomes probability based on tokens")
-
-            with gr.Row():
-                gr.Markdown("Best case: a market with a low distribution gap metric")
+                gr.Markdown("Best case: a market with a low gap between distributions")
             with gr.Row():
                 gr.Markdown(f"Market id = {best_market_id}")
             with gr.Row():
-                best_market_tokens_dist = get_based_tokens_distribution(
-                    best_market_id, markets_data
-                )
+                with gr.Column(scale=1, min_width=300):
+                    # gr.Markdown("# Evolution of outcomes probability based on tokens")
+                    best_market_tokens_dist = get_based_tokens_distribution(
+                        best_market_id, markets_data
+                    )
+                with gr.Column(scale=2, min_width=300):
+                    best_market_votes_dist = get_based_votes_distribution(
+                        best_market_id, markets_data
+                    )
 
             with gr.Row():
                 gr.Markdown("Worst case: a market with a high distribution gap metric")
@@ -91,36 +102,36 @@ with demo:
                 gr.Markdown(f"Market id = {worst_market_id}")
 
             with gr.Row():
-                worst_market_tokens_dist = get_based_tokens_distribution(
-                    worst_market_id, markets_data
-                )
+                with gr.Column(scale=1, min_width=300):
+                    # gr.Markdown("# Evolution of outcomes probability based on tokens")
+                    worst_market_tokens_dist = get_based_tokens_distribution(
+                        worst_market_id, markets_data
+                    )
+                with gr.Column(scale=2, min_width=300):
+                    worst_market_votes_dist = get_based_votes_distribution(
+                        worst_market_id, markets_data
+                    )
 
+        with gr.TabItem("📏 Distribution gap metric"):
             with gr.Row():
-                gr.Markdown("# Evolution of outcomes probability based on votes")
-            with gr.Row():
-                gr.Markdown("Best case: a market with a low distribution gap metric")
-            with gr.Row():
-                gr.Markdown(f"Market id = {best_market_id}")
-            with gr.Row():
-                best_market_votes_dist = get_based_votes_distribution(
-                    best_market_id, markets_data
+                gr.Markdown(
+                    "This metric measures the difference between the probability distribution based on the tokens distribution and the one based on the votes distribution"
                 )
             with gr.Row():
-                gr.Markdown("Worst case: a market with a high distribution gap metric")
+                gr.Markdown("# Density distribution")
             with gr.Row():
-                gr.Markdown(f"Market id = {worst_market_id}")
+                kde_plot = get_distribution_plot(markets_data)
 
             with gr.Row():
-                worst_market_tokens_dist = get_based_votes_distribution(
-                    worst_market_id, markets_data
-                )
+                gr.Markdown("# Relationship with number of trades")
 
-        with gr.TabItem("📏 Distribution gap metric"):
             with gr.Row():
-                gr.Markdown(
-                    "This metric measures the difference between the probability distribution based on the tokens distribution and the one based on the votes distribution"
-                )
+                kde_trades_plot = get_kde_with_trades(markets_data)
 
             with gr.Row():
-                dist_plot = get_distribution_plot(markets_data)
+                gr.Markdown("# Correlation analysis between variables")
+
+            with gr.Row():
+                correlation_plot = get_correlation_map(markets_data)
+
     demo.queue(default_concurrency_limit=40).launch()

tabs/dist_gap.py

@@ -6,7 +6,7 @@ from seaborn import FacetGrid
 import plotly.express as px
 
 
-def plot_top_best_behaviour_markets(markets_data: pd.DataFrame):
+def get_top_best_behaviour_markets(markets_data: pd.DataFrame):
     """Function to paint the top markets with the lowest metric of distribution gap"""
     sorted_data = markets_data.sort_values(by="dist_gap_perc", ascending=False)
     top_best_markets = sorted_data[["title", "sample_datetime", "dist_gap_perc"]].head(
@@ -17,8 +17,56 @@ def plot_top_best_behaviour_markets(markets_data: pd.DataFrame):
 
 def get_distribution_plot(markets_data: pd.DataFrame):
     """Function to paint the density plot of the metric distribution gap percentage"""
+    # A kernel density estimate (KDE) plot is a method for visualizing the distribution of
+    # observations in a dataset, analogous to a histogram. KDE represents the data using a
+    # continuous probability density curve in one or more dimensions.
+    sns.set_theme(palette="viridis")
     plt.figure(figsize=(25, 10))
+
     plot = sns.kdeplot(markets_data, x="dist_gap_perc", fill=True)
     # TODO Add title and labels
     # Display the plot using gr.Plot
     return gr.Plot(value=plot.get_figure())
+
+
+def get_kde_with_trades(markets_data: pd.DataFrame):
+    """Function to paint the density plot of the metric in terms of the number of trades"""
+    plot = sns.kdeplot(markets_data, x="dist_gap_perc", y="total_trades", fill=True)
+
+    return gr.Plot(value=plot.get_figure())
+
+
+def get_correlation_map(markets_data: pd.DataFrame):
+    """Function to paint the correlation between different variables"""
+
+    columns_of_interest = ["total_trades", "dist_gap_perc", "days_to_resolution"]
+    data = markets_data[columns_of_interest]
+
+    # Compute the correlation matrix
+    correlation_matrix = data.corr()
+
+    # Create a figure and axis
+    plt.figure(figsize=(10, 8))
+
+    # Create the heatmap
+    heatmap = sns.heatmap(
+        correlation_matrix,
+        annot=True,  # Show the correlation values
+        cmap="coolwarm",  # Color scheme
+        vmin=-1,
+        vmax=1,  # Set the range of values
+        center=0,  # Center the colormap at 0
+        square=True,  # Make each cell square-shaped
+        linewidths=0.5,  # Add lines between cells
+        cbar_kws={"shrink": 0.8},
+    )  # Adjust the size of the colorbar
+
+    # Set the title
+    plt.title("Correlation Heatmap", fontsize=)
+
+    # Rotate the y-axis labels for better readability
+    plt.yticks(rotation=0)
+
+    # Show the plot
+    plt.tight_layout()
+    return gr.Plot(value=heatmap.get_figure())

tabs/tokens_votes_dist.py

@@ -9,7 +9,6 @@ import plotly.express as px
 def get_based_tokens_distribution(market_id: str, all_markets: pd.DataFrame):
     """Function to paint the evolution of the probability of the outcomes based on the tokens distributions over time"""
     sns.set_style("darkgrid")
-    sns.set_theme(palette="viridis")
     selected_market = all_markets.loc[all_markets["id"] == market_id]
     ax = selected_market.plot(
         x="sample_datetime",
@@ -19,9 +18,9 @@ def get_based_tokens_distribution(market_id: str, all_markets: pd.DataFrame):
         stacked=True,
     )
     # add overall title
-    plt.title(
-        "Outcomes probability over time based on tokens distributions", fontsize=8
-    )
+    # plt.title(
+    #     "Outcomes probability over time based on tokens distributions", fontsize=8
+    # )
 
     # add axis titles
     plt.xlabel("Sample date")
@@ -32,13 +31,13 @@ def get_based_tokens_distribution(market_id: str, all_markets: pd.DataFrame):
         loc="upper left",
         labels=[first_outcome, second_outcome],
     )
+    ax.title = "Outcomes probability over time based on tokens distributions"
     return gr.Plot(value=ax.figure)
 
 
 def get_based_votes_distribution(market_id: str, all_markets: pd.DataFrame):
     """Function to paint the evolution of the probability of the outcomes based on the votes distributions over time"""
     sns.set_style("darkgrid")
-    sns.set_theme(palette="viridis")
     selected_market = all_markets.loc[all_markets["id"] == market_id]
     ax = selected_market.plot(
         x="sample_datetime",
@@ -47,9 +46,8 @@ def get_based_votes_distribution(market_id: str, all_markets: pd.DataFrame):
         rot=0,
         stacked=True,
     )
-    plt.figure(figsize=(25, 10))
     # add overall title
-    plt.title("Outcomes probability over time based on votes distributions", fontsize=8)
+    # plt.title("Outcomes probability over time based on votes distributions", fontsize=8)
 
     # add axis titles
     plt.xlabel("Sample date")
@@ -60,4 +58,5 @@ def get_based_votes_distribution(market_id: str, all_markets: pd.DataFrame):
         loc="upper left",
         labels=[first_outcome, second_outcome],
     )
+    ax.title = "Outcomes probability over time based on votes distributions"
     return gr.Plot(value=ax.figure)