code separation from numerai model repo

dash/numerdash_app.py

@@ -0,0 +1,1023 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import os
+import sys
+sys.path.append(os.path.dirname(os.getcwd()))
+from project_tools import project_utils, project_config, numerapi_utils
+import warnings
+import plotly.express as px
+import json
+warnings.filterwarnings("ignore")
+from PIL import Image
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+from streamlit import caching
+import time
+import traceback
+import datetime
+
+st.set_page_config(layout='wide')
+
+def sidebar_data_picker():
+    st.sidebar.subheader('Model Data Picker')
+    top_lb = st.sidebar.checkbox('top LB by corr', value=True)
+    top_tp3m = st.sidebar.checkbox('most profitable 3 month', value=True)
+    top_tp1y = st.sidebar.checkbox('most profitable 1 year', value=True)
+    special_list = st.sidebar.checkbox('model from specific users', value=True)
+    return top_lb, top_tp3m, top_tp1y, special_list
+
+def model_data_picker(values = None):
+    if values is None:
+        values = [True, True, True, True, True, True]
+    model_dict = {}
+    st.sidebar.subheader('Model Data Picker')
+    # top_lb = st.sidebar.checkbox('top LB by corr', value=values[0])
+    # top_tp3m = st.sidebar.checkbox('most profitable 3 month', value=values[1])
+    top_tp1y = st.sidebar.checkbox('most profitable 1 year', value=values[2])
+    special_list = st.sidebar.checkbox('model from specific users', value=values[3])
+    benchmark_list = st.sidebar.checkbox('benchmark models', value=values[4])
+    default_list = st.sidebar.checkbox('default models', value=values[5])
+    # if top_lb:
+    #     model_dict['top_corr'] = project_config.TOP_LB
+    # if top_tp3m:
+        # model_dict['top_3m'] = project_config.TP3M
+    if top_tp1y:
+        model_dict['top_1y'] = project_config.TP1Y
+    if benchmark_list:
+        model_dict['benchmark'] = project_config.BENCHMARK_MODELS
+    if special_list:
+        model_dict['iaai'] = project_config.IAAI_MODELS
+        # model_dict['arbitrage'] = project_config.ARBITRAGE_MODELS
+        # model_dict['mm'] = project_config.MM_MODELS
+        # model_dict['restrade'] = project_config.RESTRADE_MODELS
+
+    if default_list:
+        model_dict['yx'] = project_config.MODEL_NAMES + project_config.NEW_MODEL_NAMES
+        model_dict['mcv'] = project_config.MCV_MODELS + project_config.MCV_NEW_MODELS
+    return model_dict
+
+def model_fast_picker(models):
+    text_content = '''
+                    fast model picker by CSV string.
+                    example: "model1, model2, model3" 
+                   '''
+    text = st.sidebar.text_area(text_content)
+    result_models = []
+    if len(text)>0:
+        csv_parts = text.split(',')
+        for s in csv_parts:
+            m = s.strip()
+            if m in models:
+                result_models.append(m)
+    return list(dict.fromkeys(result_models))
+
+
+
+def generate_round_table(data, row_cts, c, r, sortcol='corrmmc'):
+    # rounds = data
+    # row_cts[c].write(2*r+c)
+    latest_round = int(data['roundNumber'].max())
+    earliest_round =  int(data['roundNumber'].min())
+    suggest_round = int(latest_round - (2*r+c))
+    select_round = row_cts[c].slider('select a round', earliest_round, latest_round, suggest_round, 1)
+    # row_cts[c].write(select_round)
+    round_data = data[data['roundNumber']==select_round].sort_values(by=sortcol, ascending=False).reset_index(drop=True)
+    # round_data = round_data[round_data['model'].isin(models)].reset_index(drop=True)
+    latest_date = round_data['date'].values[0]
+    row_cts[c].write(f'round: {select_round}, date: {latest_date}')
+    row_cts[c].dataframe(round_data.drop(['roundNumber', 'date'], axis=1), height=max_table_height-100)
+
+
+
+
+
+
+def generate_dailyscore_metrics(data, row_cts, c, r):
+    # row_cts[c].write([r, c, 2*r+c])
+    select_metric = row_cts[c].selectbox("", list(id_metric_opt.keys()), index=2*r+c, format_func=lambda x: id_metric_opt[x])
+    latest_round = int(data['roundNumber'].max())
+    earliest_round = int(data['roundNumber'].min())
+    score = id_metric_score_dic[select_metric]
+    df = project_utils.calculate_rounddailysharpe_dashboard(data, latest_round, earliest_round, score).sort_values(by='sos', ascending=False)
+    row_cts[c].dataframe(df, height=max_table_height-100)
+    pass
+
+def get_roundmetric_data(data):
+    numfeats1 = ['corr', 'mmc', 'corrmmc', 'corr2mmc']
+    stat1 = ['sum', 'mean', 'count',
+             {'sharpe': project_utils.get_array_sharpe}]  # {'ptp':np.ptp}]#{'sharp':project_utils.get_array_sharpe}]
+    numfeats2 = ['corr_pct', 'mmc_pct', 'cmavg_pct', 'c2mavg_pct']
+    stat2 = ['mean']#, {'sharp': project_utils.get_array_sharpe}]
+
+    roundmetric_agg_rcp = [
+        [['model'], numfeats1, stat1],
+        [['model'], numfeats2, stat2]
+    ]
+
+    res = project_utils.groupby_agg_execution(roundmetric_agg_rcp, data)['model']
+    rename_dict = {}
+    for c in res.columns.tolist():
+        if c != 'model':
+            rename_dict[c] = c[6:] # remove 'model_' in column name
+    res.rename(columns = rename_dict, inplace=True)
+    return res
+
+
+def generate_round_metrics(data, row_cts, c, r):
+    select_metric = row_cts[c].selectbox("", list(roundmetric_opt.keys()), index=2*r+c, format_func=lambda x: roundmetric_opt[x])
+    cols = ['model']
+    # st.write(select_metric)
+    # st.write(data.columns.tolist())
+    for col in data.columns.tolist():
+        if select_metric =='corrmmc':
+            if (f'{select_metric}_' in col) or ('cmavg_' in col):
+                cols += [col]
+        elif select_metric =='corr2mmc':
+            if (f'{select_metric}_' in col) or ('c2mavg_' in col):
+                cols += [col]
+        else:
+            if (f'{select_metric}_' in col) and (not('corrmmc' in col)) and (not('corr2mmc' in col)):
+                cols+= [col]
+
+    if select_metric != 'pct':
+        sort_col = select_metric+'_sharpe'
+    else:
+        sort_col = 'cmavg_pct_mean'
+    view_data = data[cols].sort_values(by=sort_col, ascending=False)
+    row_cts[c].dataframe(view_data)
+    pass
+
+
+def dailyscore_chart(data, row_cts, c, r, select_metric):
+    latest_round = int(data['roundNumber'].max())
+    earliest_round =  int(data['roundNumber'].min())
+    suggest_round = int(latest_round - (2*r+c))
+    select_round = row_cts[c].slider('select a round', earliest_round, latest_round, suggest_round, 1)
+    data = data[data['roundNumber']==select_round]
+    if len(data)>0:
+        fig = chart_pxline(data, 'date', y=select_metric, color='model', hover_data=list(histtrend_opt.keys()))
+        row_cts[c].plotly_chart(fig, use_container_width=True)
+    else:
+        row_cts[c].info('no data was found for the selected round')
+    pass
+
+
+def generate_live_round_stake(data, row_cts, c, r):
+    latest_round = int(data['roundNumber'].max())
+    select_round = int(latest_round - (2*r+c))
+    select_data = data[data['roundNumber']==select_round].reset_index(drop=True)
+    if len(select_data)>0:
+        payout_sum = select_data['payout'].sum().round(3)
+        stake_sum = select_data['stake'].sum().round(3)
+        if payout_sum >= 0:
+            payout_color = 'green'
+        else:
+            payout_color = 'red'
+
+        space = ' '*5
+        content_str = f'#### Round: {select_round}{space}Stake: {stake_sum}{space}Payout: <span style="color:{payout_color}">{payout_sum}</span> NMR'
+        row_cts[c].markdown(content_str, unsafe_allow_html=True)
+        select_data = select_data.drop(['roundNumber'], axis=1).sort_values(by='payout', ascending=False)
+        row_cts[c].dataframe(select_data, height=max_table_height-100)
+
+
+
+def round_view(data, select_perview, select_metric=None):
+    num_cols = 2
+    num_rows = 2
+    for r in range(num_rows):
+        row_cts = st.columns(num_cols)
+        for c in range(num_cols):
+            if select_perview=='round_result':
+                generate_round_table(data, row_cts, c, r)
+            if select_perview=='dailyscore_metric':
+                generate_dailyscore_metrics(data, row_cts, c, r)
+            if select_perview=='round_metric':
+                generate_round_metrics(data, row_cts, c, r)
+            if select_perview=='dailyscore_chart':
+                dailyscore_chart(data, row_cts, c, r, select_metric)
+            if select_perview=='live_round_stake':
+                 generate_live_round_stake(data, row_cts, c, r)
+
+
+def performance_overview():
+    models = []
+    st.sidebar.subheader('Choose a Table View')
+    select_perview = st.sidebar.selectbox("", list(tbl_opt.keys()), index=0, format_func=lambda x: tbl_opt[x])
+    model_dict = model_data_picker(values=[False, False, False, False, True, True])
+    data = []
+    for k in model_dict.keys():
+        models += model_dict[k]
+    if os.path.isfile(project_config.DASHBOARD_MODEL_RESULT_FILE) and len(models)>0:
+        data = project_utils.load_data(project_config.DASHBOARD_MODEL_RESULT_FILE)
+        if select_perview=='round_result':
+            data = data.drop(['fnc', 'fnc_pct'], axis=1)
+            data = data.drop_duplicates(['model', 'roundNumber'], keep='first')
+            data = data[data['model'].isin(models)].reset_index(drop=True)
+            round_view(data, select_perview)
+        if select_perview=='dailyscore_metric':
+            st.sidebar.subheader('Select Round Data')
+            latest_round = int(data['roundNumber'].max())
+            earliest_round = int(data['roundNumber'].min())
+            if (latest_round - earliest_round) > 10:
+                # suggest_round = int(latest_round - (latest_round - earliest_round) / 2)
+                suggest_round = 263
+            else:
+                suggest_round = earliest_round
+            select_rounds = st.sidebar.slider('select a round', earliest_round, latest_round, (suggest_round, latest_round - 1), 1)
+            data = data[(data['model'].isin(models))]
+            data = data[(data['roundNumber']>=select_rounds[0]) & (data['roundNumber']<=select_rounds[1])]
+            # st.write(data.shape, latest_round, earliest_round, suggest_round, select_rounds)
+            st.write(f'Key columns: sos - Sharpe raito of daily score sharpe, avg_sharpe - Average of daily score sharpe')
+            round_view(data, select_perview)
+            # round_view(models, )
+        if select_perview=='round_metric':
+            st.sidebar.subheader('Select Round Data')
+            latest_round = int(data['roundNumber'].max())
+            earliest_round = int(data['roundNumber'].min())
+            if (latest_round - earliest_round) > 10:
+                # suggest_round = int(latest_round - (latest_round - earliest_round) / 2)
+                suggest_round = 263
+            else:
+                suggest_round = earliest_round
+            select_rounds = st.sidebar.slider('select a round', earliest_round, latest_round, (suggest_round, latest_round - 1), 1)
+            
+            data = data.drop(['fnc', 'fnc_pct'], axis=1)
+            data = data.drop_duplicates(['model', 'roundNumber'], keep='first')
+            data = data[(data['roundNumber']>=select_rounds[0]) & (data['roundNumber']<=select_rounds[1])]
+            data = data[data['model'].isin(models)].reset_index(drop=True)
+
+            roundmetrics_data = get_roundmetric_data(data)
+            min_count = int(roundmetrics_data['count'].min())
+            max_count = int(roundmetrics_data['count'].max())
+            if min_count<max_count:
+                select_minround = st.sidebar.slider('miminum number of rounds', min_count, max_count, min_count, 1)
+            else:
+                select_minround = min_count
+            roundmetrics_data = roundmetrics_data[roundmetrics_data['count']>=select_minround].reset_index(drop=True)
+            # st.write(roundmetrics_data.shape)
+            round_view(roundmetrics_data, select_perview)
+            # st.write(roundmetrics_data)
+    else:
+        st.info('model result data file missing, or no model is selected')
+
+
+
+
+def data_operation():
+    # top_lb, top_tp3m, top_tp1y, special_list = sidebar_data_picker()
+    latest_round = project_utils.latest_round
+    models = []
+    model_dict = model_data_picker()
+    for k in model_dict.keys():
+        models += model_dict[k]
+    suggest_min_round = 182 #latest_round-50
+    min_round, max_round = st.slider('select tournament rounds', 200, latest_round, (suggest_min_round, latest_round), 1)
+    roundlist = [i for i in range(max_round, min_round-1, -1)]
+    download = st.button('download data of tracked models')
+    st.sidebar.subheader('configuration')
+    show_info=st.sidebar.checkbox('show background data', value=False)
+    update_numeraiti_data = st.sidebar.checkbox('update numerati data', value=True)
+    update_model_data = st.sidebar.checkbox('update model data', value=True)
+
+
+    model_df = []
+    if download and len(models)>0:
+        if update_numeraiti_data:
+            if show_info:
+                st.info('updating numerati data')
+            project_utils.update_numerati_data()
+
+        if update_model_data:
+            model_dfs = []
+            my_bar = st.progress(0.0)
+            my_bar.progress(0.0)
+            percent_complete = 0.0
+            # models = models[0:5]
+            for i in range(len(models)):
+                message = ''
+                try:
+                    model_res = numerapi_utils.daily_submissions_performances(models[i])
+                    if len(model_res) > 0:
+                        cols = ['model'] + list(model_res[0].keys())
+                        model_df = pd.DataFrame(model_res)
+                        model_df['model'] = models[i]
+                        model_df = model_df[cols]
+                        model_dfs.append(model_df)
+                    else:
+                        message = f'no result found for model {models[i]}'
+                except Exception:
+                    # if show_info:
+                    #     st.write(f'error while getting result for {models[i]}')
+                    except_msg = traceback.format_exc()
+                    message = f'error while getting result for {models[i]}: {except_msg}'
+                if show_info and len(message)>0:
+                    st.info(message)
+                percent_complete += 1/len(models)
+                if i == len(models)-1:
+                    percent_complete = 1.0
+                time.sleep(0.1)
+                my_bar.progress(percent_complete)
+            model_df = pd.concat(model_dfs, axis=0).sort_values(by=['roundNumber','date'], ascending=False).reset_index(drop=True)
+            model_df = model_df[model_df['roundNumber'].isin(roundlist)].reset_index(drop=True)
+            model_df['date'] = model_df['date'].dt.date
+            model_df['group'] = model_df['model'].apply(lambda x: project_utils.get_model_group(x))
+
+    prjreload = st.sidebar.button('reload config')
+    if prjreload:
+        project_utils.reload_project()
+    if len(model_df)>0:
+        rename_dict = {'corrPercentile': 'corr_pct', 'correlation':'corr', 'correlationWithMetamodel':'corr_meta', 'mmcPercentile':'mmc_pct', 'fncPercentile':'fnc_pct'}
+        model_df.rename(columns=rename_dict, inplace=True)
+        model_df['corrmmc'] = model_df['corr'] + model_df['mmc']
+        model_df['corr2mmc'] = model_df['corr'] + 2*model_df['mmc']
+        model_df['cmavg_pct'] = (model_df['corr_pct'] + model_df['mmc_pct'])/2
+        model_df['c2mavg_pct'] = (model_df['corr_pct'] + 2*model_df['mmc_pct'])/3
+        ord_cols = ['model','corr', 'corr_pct', 'mmc', 'mmc_pct', 'corrmmc', 'cmavg_pct', 'corr_meta','group', 'corr2mmc','c2mavg_pct', 'date', 'roundNumber', 'fnc', 'fnc_pct']
+        model_df = model_df[ord_cols]
+        project_utils.pickle_data(project_config.DASHBOARD_MODEL_RESULT_FILE, model_df)
+    if show_info:
+        st.text('list of models being tracked')
+        st.write(model_dict)
+        # st.write(models)
+        try:
+            st.write(model_df.head(5))
+        except:
+            st.write('model data was not retrieved')
+    st.sidebar.subheader('data info')
+    dbd_tstr, nmtd_str = project_utils.get_dashboard_data_status()
+    st.sidebar.text(f'dashboard timestamp: {dbd_tstr}')
+    st.sidebar.text(f'numerati timestamp: {nmtd_str}')
+    return None
+
+
+def chart_pxline(data, x, y, color, hover_data=None, x_range=None):
+    fig = px.line(data, x=x, y=y, color=color, hover_data=hover_data)
+    fig.update_layout(plot_bgcolor='black', paper_bgcolor='black', font_color='white', height = max_height, margin=dict(l=0, r=10, t=20, b=20))
+    fig.update_xaxes(showgrid=False, range=x_range)
+    fig.update_yaxes(gridcolor='grey')
+    return fig
+
+
+def roundresult_chart(data, model_selection):
+
+    round_data = data[data['model'].isin(model_selection)].drop_duplicates(['model', 'roundNumber'],                                                                           keep='first').reset_index(drop=True)
+    min_round = int(round_data['roundNumber'].min())
+    max_round = int(round_data['roundNumber'].max())
+    suggest_min_round = max_round - 20
+    if min_round == max_round:
+        min_round = max_round - 20
+
+    min_selectround, max_selectround = st.slider('select plotting round range', min_round, max_round,
+                                                 (suggest_min_round, max_round), 1)
+
+    # min_selectround, max_selectround = placeholder.slider('select plotting round range', min_round, max_round,
+    #                                              (suggest_min_round, max_round), 1)
+
+    select_metric = st.selectbox('Choose a metric', list(histtrend_opt.keys()), index=0,
+                                 format_func=lambda x: histtrend_opt[x])
+    round_range = [min_selectround, max_selectround]
+    round_list = [r for r in range(min_selectround, max_selectround + 1)]
+    round_data = round_data[round_data['roundNumber'].isin(round_list)]
+    mean_df = round_data.groupby(['model'])[select_metric].agg('mean').reset_index()
+    mean_df[f'model avg.'] = mean_df['model'] + ': ' + mean_df[select_metric].round(5).astype(str)
+    mean_df['mean'] = mean_df[select_metric]
+    merge_cols = ['model', 'model avg.', 'mean']
+    round_data = round_data.merge(right=mean_df[merge_cols], on='model', how='left').sort_values(by=['mean','model', 'roundNumber'], ascending=False)
+    fig = chart_pxline(round_data, 'roundNumber', y=select_metric, color='model avg.', hover_data=list(histtrend_opt.keys())+['date'],x_range=round_range)
+
+    if fig is not None:
+        st.plotly_chart(fig, use_container_width=True)
+        dailyscore_data = data[(data['model'].isin(model_selection)) & data['roundNumber'].isin(round_list)].reset_index(drop=True)
+        dailyscore_data = dailyscore_data.merge(right=mean_df[merge_cols], on='model', how='left').sort_values(
+            by=['mean', 'model', 'roundNumber'], ascending=False)
+        round_view(dailyscore_data, 'dailyscore_chart', select_metric)
+
+    else:
+        st.text(f'No data available for models: {models}')
+
+
+
+
+def histtrend():
+    # default_models = ['yxbot']
+    # models = default_models.copy()
+    models = []
+    model_selection = []
+    model_dict = model_data_picker(values=[False, False, False, False, True, True])
+    for k in model_dict.keys():
+        if model_dict[k] not in models:
+            models += model_dict[k]
+
+    default_models = model_fast_picker(models)
+    if len(models)>0:
+        if len(default_models)==0:
+            default_models = [models[0]]
+        model_selection = st.sidebar.multiselect('select models for chart', models, default=default_models)
+
+
+    if os.path.isfile(project_config.DASHBOARD_MODEL_RESULT_FILE) and len(model_selection)>0:
+        data = project_utils.load_data(project_config.DASHBOARD_MODEL_RESULT_FILE)
+        roundresult_chart(data, model_selection)
+
+        # fig = px.line(df, x='roundNumber', y='corr', color='model', hover_data=['corr_pct'])
+        # st.write(model_selection)
+    else:
+        if len(model_selection)==0:
+            st.info('please select some models from the dropdown list')
+        else:
+            st.info('model result data file missing, or no model is selected')
+
+    # st.write(models)
+
+
+
+def model_evaluation():
+    models = []
+    model_selection = []
+    model_dict = model_data_picker(values=[True, True, True, True, True, True])
+    mean_scale = [-0.05, 0.1]
+    count_scale = [1, 50]
+    sharpe_scale = [-0.2, 3]
+    pct_scale = [0, 1]
+    radar_scale = [0, 5]
+
+    for k in model_dict.keys():
+        if model_dict[k] not in models:
+            models += model_dict[k]
+
+    default_models = model_fast_picker(models)
+    if len(models)>0:
+        if len(default_models)==0:
+            if 'integration_test' in models:
+                default_models = 'integration_test'
+            else:
+                default_models = [models[0]]
+
+        model_selection = st.sidebar.multiselect('select models for chart', models, default=default_models)
+
+    if os.path.isfile(project_config.DASHBOARD_MODEL_RESULT_FILE) and len(model_selection)>0:
+        data = project_utils.load_data(project_config.DASHBOARD_MODEL_RESULT_FILE)
+        round_data = data[data['model'].isin(model_selection)].drop_duplicates(['model', 'roundNumber'],keep='first').reset_index(drop=True)
+        min_round = int(round_data['roundNumber'].min())
+        max_round = int(round_data['roundNumber'].max())
+        suggest_min_round = max_round - 20
+        if min_round == max_round:
+            min_round = max_round - 20
+
+        min_selectround, max_selectround = st.slider('select plotting round range', min_round, max_round,
+                                                     (suggest_min_round, max_round), 1)
+        round_list = [r for r in range(min_selectround, max_selectround+1)]
+        defaultlist = ['corr_sharpe', 'mmc_sharpe',  'corr2mmc_sharpe','corr_mean', 'mmc_mean', 'corr2mmc_mean', 'count']
+
+        select_metrics = st.multiselect('Metric Selection', list(model_eval_opt.keys()),
+                                     format_func=lambda x: model_eval_opt[x], default=defaultlist)
+
+        use_dailymetrics = ('id_corr_sharpe' in select_metrics) or (('id_mmc_sharpe' in select_metrics)) or ('id_corrmmc_sharpe' in select_metrics)
+        if use_dailymetrics:
+            st.write('use daily metrics')
+
+        round_data = round_data[round_data['roundNumber'].isin(round_list)].reset_index(drop=True)
+        #'need normalised radar chart + tabular view here
+        roundmetric_df = get_roundmetric_data(round_data).sort_values(by='corrmmc_sharpe', ascending=False).reset_index(drop=True)
+
+        radarmetric_df = roundmetric_df.copy(deep=True)
+        for col in select_metrics:
+            if 'mean' in col:
+                use_scale = mean_scale
+            if 'sharpe' in col:
+                use_scale = sharpe_scale
+            if 'pct' in col:
+                use_scale = pct_scale
+            if 'count' in col:
+                use_scale = count_scale
+            radarmetric_df[col] = radarmetric_df[col].apply(lambda x: project_utils.rescale(x, use_scale, radar_scale))
+        select_metrics_name = [model_eval_opt[i] for i in select_metrics]
+        radarmetric_df.rename(columns=model_eval_opt, inplace=True)
+        roundmetric_df.rename(columns=model_eval_opt, inplace=True)
+
+        fig = go.Figure()
+        for i in range(len(radarmetric_df)):
+            fig.add_trace(go.Scatterpolar(
+                r=radarmetric_df.loc[i, select_metrics_name].values,
+                theta=select_metrics_name,
+                fill='toself',
+                name=radarmetric_df['model'].values[i]
+            ))
+
+        fig.update_polars(
+            radialaxis=dict(visible=True, autorange=False, #type='linear',
+                            range=[0,5])
+        )
+
+        fig.update_layout(plot_bgcolor='black', paper_bgcolor='black', font_color='aliceblue',
+                          height=max_height+100,
+                          margin=dict(l=0, r=10, t=20, b=20), showlegend=True)
+
+        st.plotly_chart(fig, use_container_width=True)
+        st.text('Calculated Metrics')
+        st.dataframe(roundmetric_df[['model'] + select_metrics_name], height=max_table_height)
+        st.text('Rescaled Metrics on Chart')
+        st.dataframe(radarmetric_df[['model'] + select_metrics_name], height=max_table_height)
+
+        # st.write(select_metrics)
+
+
+def get_portfolio_overview(models, onlylatest=True):
+    res_df = []
+    my_bar = st.progress(0.0)
+    my_bar.progress(0.0)
+    percent_complete = 0.0
+    for i in range(len(models)):
+        m = models[i]
+        try:
+            if onlylatest:
+                # mdf = numerapi_utils.get_model_history(m).loc[0:0]
+                mdf = numerapi_utils.get_model_history_v3(m).loc[0:0]
+            else:
+                # mdf = numerapi_utils.get_model_history(m)
+                mdf = numerapi_utils.get_model_history_v3(m)
+            res_df.append(mdf)
+        except:
+            # st.info(f'no information for model {m} is available')
+            pass
+        percent_complete += 1 / len(models)
+        if i == len(models) - 1:
+            percent_complete = 1.0
+        time.sleep(0.1)
+        my_bar.progress(percent_complete)
+    try:
+        res_df = pd.concat(res_df, axis=0)
+        res_df['profitability'] = res_df['realised_pl']/(res_df['current_stake']-res_df['realised_pl'])
+        cols = ['model', 'date', 'current_stake', 'floating_stake', 'floating_pl', 'realised_pl', 'profitability']
+
+        # res_df['date'] = res_df['date'].dt.date
+        if onlylatest:
+            res_df = res_df.sort_values(by='floating_pl', ascending=False).reset_index(drop=True)
+            return res_df[cols]
+        else:
+            return res_df[cols]
+    except:
+        return []
+
+
+def get_stake_type(corr, mmc):
+    if mmc>0:
+        res = str(int(corr)) + 'xCORR ' + str(int(mmc)) +'xMMC'
+    else:
+        res = '1xCORR'
+    return res
+
+
+@st.cache(suppress_st_warning=True)
+def get_stake_by_liverounds(models):
+    latest_round_id = int(project_utils.get_latest_round_id())
+    roundlist = [i for i in range(latest_round_id, latest_round_id - 5, -1)]
+    res = []
+    my_bar = st.progress(0.0)
+    my_bar.progress(0.0)
+    percent_complete = 0.0
+    percent_part = 0
+    for r in roundlist:
+        for m in models:
+            percent_complete += 1 / (len(models)*len(roundlist))
+            try:
+                data = numerapi_utils.get_round_model_performance(r, m)
+                # print(f'successfuly extract for model {m} in round {r}')
+                res.append(data)
+            except:
+                pass
+                # print(f'no result found for model {m} in round {r}')
+            if percent_part == (len(models)*len(roundlist)) - 1:
+                percent_complete = 1.0
+            time.sleep(0.1)
+            my_bar.progress(percent_complete)
+            percent_part +=1
+    res_df = pd.DataFrame.from_dict(res).fillna(0)
+    res_df['payoutPending'] = res_df['payoutPending'].astype(np.float64)
+    res_df['selectedStakeValue'] = res_df['selectedStakeValue'].astype(np.float64)
+    res_df['stake_type'] = res_df.apply(lambda x: get_stake_type(x['corrMultiplier'], x['mmcMultiplier']),axis=1)
+    rename_dict = {'selectedStakeValue': 'stake', 'payoutPending': 'payout', 'correlation':'corr'}
+    res_df = res_df.rename(columns=rename_dict)
+    col_ord = ['model', 'roundNumber', 'stake', 'payout', 'stake_type',  'corr', 'mmc']
+    return res_df[col_ord]
+
+
+
+def get_stake_graph(data):
+    numfeats = ['current_stake', 'floating_stake', 'floating_pl', 'realised_pl']
+    stat1 = ['sum']
+    agg_rcp = [[['date'], numfeats, stat1]]
+
+    select_opt = st.selectbox('Select Time Span', list(stakeoverview_plot_opt.keys()), index=1, format_func=lambda x: stakeoverview_plot_opt[x])
+
+    res = project_utils.groupby_agg_execution(agg_rcp, data)['date']
+    w5delta = datetime.timedelta(weeks=5)
+    w13delta = datetime.timedelta(weeks=13)
+    date_w5delta = res['date'].max() - w5delta
+    date_w13delta = res['date'].max() - w13delta
+    y1delta = datetime.timedelta(weeks=52)
+    date_y1delta = res['date'].max() - y1delta
+
+    rename_dict = {'date_current_stake_sum': 'total_stake', 'date_floating_stake_sum': 'floating_stake',
+                   'date_floating_pl_sum': 'floating_pl', 'date_realised_pl_sum': 'realised_pl'}
+    res = res.rename(columns=rename_dict)
+    if select_opt == '1month':
+        res = res[res['date']>date_w5delta]
+    elif select_opt=='3month':
+        res = res[res['date']>date_w13delta]
+    elif select_opt=='1year':
+        res = res[res['date']>date_y1delta]
+    else:
+        pass
+
+    fig = make_subplots(specs=[[{"secondary_y": True}]])
+    fig.add_trace( go.Scatter(x=res['date'], y=res['floating_stake'], name="floating_stake"), secondary_y=False,)
+
+    fig.add_trace(go.Scatter(x=res['date'], y=res['total_stake'], name="total_stake"),secondary_y=False,)
+
+    fig.add_trace(go.Scatter(x=res['date'], y=res['realised_pl'], name="realised_pl"),secondary_y=True,)
+    fig.update_layout(plot_bgcolor='black', paper_bgcolor='black', font_color='white')
+    fig.update_xaxes(showgrid=False, range=None, nticks=30)
+    fig.update_yaxes(gridcolor='grey', title_text="total stake/floating stake/realised PL", secondary_y=False)
+    fig.update_yaxes(showgrid=False, title_text="realised PL", zeroline=False,secondary_y=True)
+    st.plotly_chart(fig, use_container_width=True)
+
+#
+# def live_round_stakeview(data):
+#     models = data
+#     latest_round_id = int(project_utils.get_latest_round_id())
+#     roundlist = [i for i in range(latest_round_id, latest_round_id-4, -1]
+
+
+def check_session_state(key, data, init=False):
+    # st.write(data)
+    portsel_list = ['portfolio_left', 'portfolio_right']
+    if key in portsel_list:
+        if ('last_opt' not in st.session_state) & (~init):
+            st.session_state['last_opt'] = key
+        if key not in st.session_state:
+            st.session_state[key] = data
+            # st.session_state['last_opt'] = key
+        else:
+            # st.write(key, st.session_state['last_opt'],len(st.session_state[key]))
+            if st.session_state[key] is None:
+                st.session_state[key] = []
+                # st.session_state['last_opt'] = key
+            if data is None:
+                return st.session_state[key]
+            elif (set(data)!=set(st.session_state[key])) & (len(data)>0 & (~init)):
+                # if st.session_state['last_opt'] == key:
+                if(st.session_state['last_opt']==key):
+                    st.session_state[key] = data
+                else:
+                    if len(st.session_state[key]) ==0:
+                        st.session_state[key] = data
+                    st.session_state['last_opt'] = key
+
+        return st.session_state[key]
+    else:
+        return None
+
+
+def stake_overview():
+    models = []
+    model_selection = []
+    model_dict = model_data_picker(values=[True, True, True, True, True, True])
+    for k in model_dict.keys():
+        if model_dict[k] not in models:
+            models += model_dict[k]
+
+    default_models = model_fast_picker(models)
+    if len(models)>0:
+        model_selection = st.sidebar.multiselect('select models for chart', models, default=default_models)
+    redownload_data = False
+    if len(model_selection) > 0:
+        if 'stake_df' not in st.session_state:
+            redownload_data = True
+        else:
+            if set(model_selection)!=st.session_state['stake_overview_models']:
+                redownload_data = True
+            else:
+                ovdf = st.session_state['stake_df']
+        if redownload_data:
+            ovdf = get_portfolio_overview(model_selection, onlylatest=False)
+            print(ovdf.shape)
+            st.session_state['stake_df'] = ovdf
+            st.session_state['stake_overview_models'] = set(ovdf['model'].unique().tolist())
+
+        chartdf = ovdf.copy(deep=True)
+        ovdf = ovdf.drop_duplicates('model', keep='first')
+        ovdf = ovdf.sort_values(by='floating_pl', ascending=False).reset_index(drop=True)
+        if len(ovdf)>0:
+            numerai_date = str(ovdf['date'].values[0])[0:10]
+            ovdf.drop(['date'], axis=1, inplace=True)
+            stake_cts = st.columns(2)
+            pl_cts = st.columns(2)
+            date_label = st.empty()
+            get_stake_graph(chartdf)
+            ovdf_exp = st.expander('', expanded=True)
+            with ovdf_exp:
+                st.dataframe(ovdf, height=max_table_height)
+            total_current_stake = round(ovdf['current_stake'].sum(), 3)
+            total_floating_stake = round(ovdf['floating_stake'].sum(), 3)
+            rpl = round(ovdf['realised_pl'].sum(), 3)
+            fpl = round(ovdf['floating_pl'].sum(), 3)
+            current_stake_str = f'### Stake Balance: {total_current_stake:0.3f} NMR'
+            float_stake_str =  f'### Floating Balance: {total_floating_stake:0.3f} NMR'
+            if rpl>=0:
+                real_pl_color = 'green'
+            else:
+                real_pl_color = 'red'
+            if fpl>=0:
+                float_pl_color = 'green'
+            else:
+                float_pl_color = 'red'
+            real_pl_str = f'### Realised P/L: <span style="color:{real_pl_color}">{rpl}</span> NMR'
+            float_pl_str = f'### Floating P/L: <span style="color:{float_pl_color}">{fpl}</span> NMR'
+            stake_cts[0].markdown(current_stake_str, unsafe_allow_html=True)
+            stake_cts[1].markdown(float_stake_str, unsafe_allow_html=True)
+            pl_cts[0].markdown(real_pl_str, unsafe_allow_html=True)
+            pl_cts[1].markdown(float_pl_str, unsafe_allow_html=True)
+            date_label.subheader(f'Date: {numerai_date}')
+            if st.button('show breakdown by live rounds'):
+                liveround_exp = st.expander('',expanded=True)
+                with liveround_exp:
+                    stake_models = ovdf['model'].tolist()
+                    liveround_stake_df = get_stake_by_liverounds(stake_models)
+                    # st.write(liveround_stake_df)
+                    round_view(liveround_stake_df,'live_round_stake')
+
+
+def set_portolio_control(ct, models ,data):
+    roundmodels = data['model'].unique().tolist()
+    use_models = [m for m in models if m in roundmodels]
+    ct.write(use_models)
+
+
+# def portfolio_model_selector(models):
+#     st.sidebar.subheader('Portfolio Model Shortlist')
+#     # placeholder = st.sidebar.empty()
+#     text_content = '''
+#                     fast model picker by CSV string.
+#                     example: "model1, model2, model3"
+#                    '''
+#     # port_model_exp = st.sidebar.expander('portfolio model selector', expanded=True)
+#     # with port_model_exp:
+#     # text = placeholder.text_input(label=text_content, key='1')
+#     text = st.sidebar.text_area(label=text_content)
+#     result_models = []
+#     if len(text)>0:
+#         csv_parts = text.split(',')
+#         for s in csv_parts:
+#             m = s.strip()
+#             if m in models:
+#                 result_models.append(m)
+#     default_models = list(dict.fromkeys(result_models))
+#     port_model_selection = st.sidebar.multiselect('select models for portfolio shortlist', models, default=default_models)
+#     # selection_opt = st.sidebar.radio('select models for', list(port_model_selection_opt.keys()), index=0, format_func=lambda x: port_model_selection_opt[x])
+#     return port_model_selection
+
+
+def portfolio_model_selector(models):
+    # placeholder = st.sidebar.empty()
+    selection_opt = st.sidebar.radio('select models for', list(port_model_selection_opt.keys()), index=0, format_func=lambda x: port_model_selection_opt[x], key='pmsel_mulsel')
+
+    text_content = '''
+                    fast model picker by CSV string.
+                    example: "model1, model2, model3" 
+                   '''
+    # port_model_exp = st.sidebar.expander('portfolio model selector', expanded=True)
+    # with port_model_exp:
+    # text = placeholder.text_input(label=text_content, key='1')
+    text = st.sidebar.text_area(label=text_content, key='pmsel_txt')
+    result_models = []
+    if len(text)>0:
+        csv_parts = text.split(',')
+        for s in csv_parts:
+            m = s.strip()
+            if m in models:
+                result_models.append(m)
+    default_models = list(dict.fromkeys(result_models))
+    # st.write(default_models)
+    port_model_selection = st.sidebar.multiselect('select models for portfolio shortlist', models, default=default_models)
+    return port_model_selection, selection_opt
+
+
+
+def portfolio_mgmt():
+    models = []
+    model_selection = []
+    # model_dict = model_data_picker(values=[True, True, True, True, True, True])
+    model_dict = model_data_picker(values=[True, True, True, True, True, True])
+
+    for k in model_dict.keys():
+        if model_dict[k] not in models:
+            models += model_dict[k]
+    # overview_models = models
+    port_models_left = check_session_state('portfolio_left', [], init=True)
+    port_models_right = check_session_state('portfolio_right', [], init=True)
+
+    if os.path.isfile(project_config.DASHBOARD_MODEL_RESULT_FILE) and len(models)>0:
+        port_cts = st.columns(2)
+        # port_models_shortlist  = portfolio_model_selector(models)
+
+        # elif port_model_opt=='overview':
+        # if len(port_models_shortlist)==0:
+        #
+        #     port_models_shortlist = models
+        # else:
+        #     return None
+        data = project_utils.load_data(project_config.DASHBOARD_MODEL_RESULT_FILE)
+        round_data = data[data['model'].isin(models)].drop_duplicates(['model', 'roundNumber'],keep='first').reset_index(drop=True)
+        min_round = int(round_data['roundNumber'].min())
+        max_round = int(round_data['roundNumber'].max())
+        suggest_min_round = max_round - 20
+        if min_round == max_round:
+            min_round = max_round - 20
+
+        round_exp = st.expander('Round Selection', expanded=True)
+        metric_exp = st.expander('Metric Selection', expanded=True)
+        # portmodel_select_exp = st.expander('Portfolio Model Selection', expanded=True)
+        models_overview_exp =st.expander('Portfolio Model Shortlist', expanded=True)
+        with round_exp:
+            min_selectround, max_selectround = st.slider('', min_round, max_round,
+                                                         (suggest_min_round, max_round), 1)
+            round_list = [r for r in range(min_selectround, max_selectround+1)]
+        with metric_exp:
+            defaultlist = ['corr_sharpe', 'mmc_sharpe',  'corr2mmc_sharpe','corr_mean', 'mmc_mean', 'corr2mmc_mean', 'count']
+            select_metrics = st.multiselect('', list(model_eval_opt.keys()),
+                                         format_func=lambda x: model_eval_opt[x], default=defaultlist)
+
+            round_data = round_data[round_data['roundNumber'].isin(round_list)].reset_index(drop=True)
+        roundmetric_df = get_roundmetric_data(round_data).sort_values(by='corrmmc_sharpe', ascending=False).reset_index(drop=True)
+        roundmodels = roundmetric_df['model'].unique().tolist()
+
+        # with portmodel_select_exp:
+        #     port_sel = st.columns(2)
+            # pl = port_sel[0].multiselect('', port_models_shortlist, default=[])
+        port_models_selection, port_opt = portfolio_model_selector(roundmodels)
+        if port_opt=='left':
+            port_models_left = check_session_state('portfolio_left',port_models_selection)
+        elif port_opt=='right':
+            port_models_right = check_session_state('portfolio_right',port_models_selection)
+
+            # port_models_right = portfolio_model_selector_ct(port_sel, roundmodels, c=1)
+
+            # port_models_right = portfolio_model_selector_ct(port_sel[1], port_models_shortlist, '2')
+
+
+
+        # with port_exp = st.expander('Portfolio Comparison ')
+        set_portolio_control(port_cts[0], port_models_left, roundmetric_df)
+        set_portolio_control(port_cts[1], port_models_right, roundmetric_df)
+
+        with models_overview_exp:
+            cols = ['model'] + select_metrics
+            st.subheader(f'{len(roundmetric_df)} models are available for portfolio selection')
+            st.dataframe(roundmetric_df[cols], height=max_table_height)
+
+    # default_models = model_fast_picker(models)
+    #     model_selection = st.sidebar.multiselect('select models for chart', models, default=default_models)
+
+
+
+    pass
+
+
+
+def show_content():
+    st.sidebar.header('Dashboard Selection')
+    select_app = st.sidebar.selectbox("", list(app_opt.keys()), index=3, format_func=lambda x: app_opt[x])
+    if select_app=='performance_overview':
+        performance_overview()
+    if select_app=='historic_trend':
+        histtrend()
+    if select_app=='data_op':
+        data_operation()
+    if select_app=='model_evaluation':
+        model_evaluation()
+    if select_app=='stake_overview':
+        stake_overview()
+    if select_app=='portfolio_mgmt':
+        portfolio_mgmt()
+
+
+
+
+# main body
+# various configuration setting
+app_opt = {
+           'performance_overview' : 'Performance Overview',
+           'historic_trend':'Historic Trend',
+           'model_evaluation' : 'Model Evaluation',
+           'stake_overview': 'Stake Overview',
+           'portfolio_mgmt': 'Portfolio_Management',
+           'data_op':'Data Operation'
+           }
+
+tbl_opt = {
+            'round_result':'Round Results',
+            'dailyscore_metric':'Daily Score Metrics',
+            'round_metric' : 'Round Metrics'
+}
+
+id_metric_opt = {
+                'id_corr_sharpe':'Daily Score corr sharpe',
+                'id_mmc_sharpe': 'Daily Score mmc sharpe',
+                'id_corrmmc_sharpe': 'Daily Score corrmmc sharpe',
+                'id_corr2mmc_sharpe': 'Daily Score corr2mmc sharpe',
+                'id_corrmmcpct_sharpe': 'Daily Score corrmmc avg pct sharpe',
+                'id_corr2mmcpct_sharpe': 'Daily Score corr2mmc avg pct sharpe',
+                'id_corrpct_sharpe':'Daily Score corr pct sharpe',
+                'id_mmcpct_sharpe': 'Daily Score mmc pct sharpe',
+}
+
+
+id_metric_score_dic = {
+                'id_corr_sharpe':'corr',
+                'id_mmc_sharpe': 'mmc',
+                'id_corrmmc_sharpe': 'corrmmc',
+                'id_corr2mmc_sharpe': 'corr2mmc',
+                'id_corrmmcpct_sharpe': 'cmavg_pct',
+                'id_corr2mmcpct_sharpe': 'c2mavg_pct',
+                'id_corrpct_sharpe':'corr_pct',
+                'id_mmcpct_sharpe': 'mmc_pct'
+}
+
+
+roundmetric_opt ={'corr':'Corr metrics',
+                  'mmc' : 'MMC metrics',
+                  'corrmmc' : 'CorrMMC metrics',
+                  'corr2mmc' : 'Corr2MMC metrics',
+                  'pct' : 'Pecentage metrics'
+
+}
+
+
+histtrend_opt = {
+                'corr':'Correlation',
+                'mmc': 'MMC',
+                'corrmmc': 'Correlation+MMC',
+                'corr2mmc': 'Correlation+2*MMC',
+                'corr_pct': 'Correlation Percentile',
+                'mmc_pct':'MMC Percentile',
+                'cmavg_pct': 'Correlation+MMC Average Percentile',
+                'c2mavg_pct': 'Correlation+2*MMC Average Percentile',
+
+}
+
+
+model_eval_opt = {
+        'corr_sharpe' : 'Correlation Sharpe',
+        'mmc_sharpe' : 'MMC Sharpe',
+        'corrmmc_sharpe' : 'Correlation+MMC Sharpe',
+        'corr2mmc_sharpe': 'Correlation+2*MMC Sharpe',
+        'corr_mean':'Avg. Correlation',
+        'mmc_mean':'Avg. MMC',
+        'count': 'Number of Rounds',
+        'corrmmc_mean': 'Avg. Correlation+MMC',
+        'corr2mmc_mean': 'Avg. Correlation+2*MMC',
+        'corr_pct_mean': 'Avg. Correlation Percentile',
+        'mmc_pct_mean': 'Avg. MMC Percentile',
+        'cmavg_pct_mean': 'Avg. Correlation+MMC Percentile',
+        'c2mavg_pct_mean': 'Avg. Correlation+2*MMC Percentile',
+        'id_corr_sharpe': 'Daily Score corr sharpe',
+        'id_mmc_sharpe': 'Daily Score mmc sharpe',
+        'id_corrmmc_sharpe': 'Daily Score corrmmc sharpe',
+}
+
+stakeoverview_plot_opt = {
+    '1month':'1 Month',
+    '3month':'3 Months',
+    '1year':'1 Year',
+    'all':'Display all available data'
+}
+
+
+port_model_selection_opt = {
+    'left':'Left Portfolio',
+    'right':'Right Portfolio'
+    # 'overview':'Model Overview'
+}
+
+
+
+
+project_utils.reload_project()
+
+height_exp = st.sidebar.expander('Plots and tables setting', expanded=False)
+with height_exp:
+    max_height = st.slider('Please choose the height for plots', 100, 1000, 400, 50)
+    max_table_height = st.slider('Please choose the height for tables', 100, 1000, 500, 50)
+
+st.title('Numerai Dashboard')
+
+# trying out multi columns
+# col1, col2 = st.columns(2)
+# col1.header('col1')
+# col2.header('col2')
+
+show_content()

project_tools/numerapi_utils.py

@@ -0,0 +1,359 @@
+import numerapi
+from numerapi import utils
+from project_tools import project_config, project_utils
+from typing import List, Dict
+import pandas as pd
+import numpy as np
+
+napi = numerapi.NumerAPI()
+
+
+# def get_round
+
+
+def get_model_history(model):
+    res = napi.daily_user_performances(model)
+    res = pd.DataFrame.from_dict(res)
+    res['payoutPending'] = res['payoutPending'].astype(np.float64)
+    res['payoutSettled'] = res['payoutSettled'].astype(np.float64)
+    res['stakeValue'] = res['stakeValue'].astype(np.float64)
+    res['deltaRatio'] = res['payoutPending'] / res['stakeValue']
+    res['realised_pl'] = project_utils.series_reverse_cumsum(res['payoutSettled'])
+    res['floating_pl'] = project_utils.series_reverse_cumsum(res['payoutPending']) - res['realised_pl']
+    res['current_stake'] = res['stakeValue'] - res['floating_pl']
+    rename_dict = {'stakeValue':'floating_stake'}
+    res = res.rename(columns=rename_dict)
+    # res['equity'] = res['stakeValue'] + res['floating_pl']
+    # cols = res.columns.tolist()
+    # res = res[['model'] + cols]
+
+    res['model'] = model
+    cols = ['model', 'date', 'current_stake', 'floating_stake', 'payoutPending', 'floating_pl', 'realised_pl']
+    res = res[cols]
+    return res
+
+
+def get_portfolio_overview(models, onlylatest=True):
+    res_df = []
+    for m in models:
+        try:
+            print(f'extracting information for model {m}')
+            if onlylatest:
+                mdf = get_model_history(m).loc[0:0]
+            else:
+                mdf = get_model_history(m)
+            res_df.append(mdf)
+        except:
+            print(f'no information for model {m} is available')
+    if len(res_df)>0:
+        res_df = pd.concat(res_df, axis=0)
+        res_df['date'] = res_df['date'].dt.date
+        if onlylatest:
+            return res_df.sort_values(by='floating_pl', ascending=False).reset_index(drop=True)
+        else:
+            return res_df.reset_index(drop=True)
+    else:
+        return None
+
+
+
+
+
+
+def get_competitions(tournament=8):
+    """Retrieves information about all competitions
+    Args:
+        tournament (int, optional): ID of the tournament, defaults to 8
+            -- DEPRECATED there is only one tournament nowadays
+    Returns:
+        list of dicts: list of rounds
+        Each round's dict contains the following items:
+            * datasetId (`str`)
+            * number (`int`)
+            * openTime (`datetime`)
+            * resolveTime (`datetime`)
+            * participants (`int`): number of participants
+            * prizePoolNmr (`decimal.Decimal`)
+            * prizePoolUsd (`decimal.Decimal`)
+            * resolvedGeneral (`bool`)
+            * resolvedStaking (`bool`)
+            * ruleset (`string`)
+    Example:
+        >>> NumerAPI().get_competitions()
+        [
+         {'datasetId': '59a70840ca11173c8b2906ac',
+          'number': 71,
+          'openTime': datetime.datetime(2017, 8, 31, 0, 0),
+          'resolveTime': datetime.datetime(2017, 9, 27, 21, 0),
+          'participants': 1287,
+          'prizePoolNmr': Decimal('0.00'),
+          'prizePoolUsd': Decimal('6000.00'),
+          'resolvedGeneral': True,
+          'resolvedStaking': True,
+          'ruleset': 'p_auction'
+         },
+          ..
+        ]
+    """
+    # self.logger.info("getting rounds...")
+
+    query = '''
+        query($tournament: Int!) {
+          rounds(tournament: $tournament) {
+            number
+            resolveTime
+            openTime
+            resolvedGeneral
+            resolvedStaking
+          }
+        }
+    '''
+    arguments = {'tournament': tournament}
+    result = napi.raw_query(query, arguments)
+    rounds = result['data']['rounds']
+    # convert datetime strings to datetime.datetime objects
+    for r in rounds:
+        utils.replace(r, "openTime", utils.parse_datetime_string)
+        utils.replace(r, "resolveTime", utils.parse_datetime_string)
+        utils.replace(r, "prizePoolNmr", utils.parse_float_string)
+        utils.replace(r, "prizePoolUsd", utils.parse_float_string)
+    return rounds
+
+
+def daily_submissions_performances(username: str) -> List[Dict]:
+    """Fetch daily performance of a user's submissions.
+    Args:
+        username (str)
+    Returns:
+        list of dicts: list of daily submission performance entries
+        For each entry in the list, there is a dict with the following
+        content:
+            * date (`datetime`)
+            * correlation (`float`)
+            * roundNumber (`int`)
+            * mmc (`float`): metamodel contribution
+            * fnc (`float`): feature neutral correlation
+            * correlationWithMetamodel (`float`)
+    Example:
+        >>> api = NumerAPI()
+        >>> api.daily_user_performances("uuazed")
+        [{'roundNumber': 181,
+          'correlation': -0.011765912,
+          'date': datetime.datetime(2019, 10, 16, 0, 0),
+          'mmc': 0.3,
+          'fnc': 0.1,
+          'correlationWithMetamodel': 0.87},
+          ...
+        ]
+    """
+    query = """
+              query($username: String!) {
+                v2UserProfile(username: $username) {
+                  dailySubmissionPerformances {
+                    date
+                    correlation
+                    corrPercentile
+                    roundNumber
+                    mmc
+                    mmcPercentile
+                    fnc
+                    fncPercentile
+                    correlationWithMetamodel
+                  }
+                }
+              }
+            """
+    arguments = {'username': username}
+    data = napi.raw_query(query, arguments)['data']['v2UserProfile']
+    performances = data['dailySubmissionPerformances']
+    # convert strings to python objects
+    for perf in performances:
+        utils.replace(perf, "date", utils.parse_datetime_string)
+    # remove useless items
+    performances = [p for p in performances
+                    if any([p['correlation'], p['fnc'], p['mmc']])]
+    return performances
+
+
+
+
+
+def get_round_model_performance(roundNumber: int, model: str):
+    query = """
+              query($roundNumber: Int!, $username: String!) {
+                  roundSubmissionPerformance(roundNumber: $roundNumber, username: $username) {
+                      corrMultiplier
+                      mmcMultiplier                      
+                      roundDailyPerformances{
+                          correlation
+                          mmc
+                          corrPercentile
+                          mmcPercentile
+                          payoutPending
+                       }
+                       selectedStakeValue
+                   }
+              }
+            """
+    arguments = {'roundNumber': roundNumber,'username': model}
+    data = napi.raw_query(query, arguments)['data']['roundSubmissionPerformance']
+    latest_performance = data['roundDailyPerformances'][-1] #[-1] ### issue with order
+    res = {}
+    res['model'] = model
+    res['roundNumber'] = roundNumber
+    res['corrMultiplier'] = data['corrMultiplier']
+    res['mmcMultiplier'] = data['mmcMultiplier']
+    res['selectedStakeValue'] = data['selectedStakeValue']
+    for key in latest_performance.keys():
+        res[key] = latest_performance[key]
+    return res
+
+
+
+
+def get_user_profile(username: str) -> List[Dict]:
+    """Fetch daily performance of a user's submissions.
+    Args:
+        username (str)
+    Returns:
+        list of dicts: list of daily submission performance entries
+        For each entry in the list, there is a dict with the following
+        content:
+            * date (`datetime`)
+            * correlation (`float`)
+            * roundNumber (`int`)
+            * mmc (`float`): metamodel contribution
+            * fnc (`float`): feature neutral correlation
+            * correlationWithMetamodel (`float`)
+    Example:
+        >>> api = NumerAPI()
+        >>> api.daily_user_performances("uuazed")
+        [{'roundNumber': 181,
+          'correlation': -0.011765912,
+          'date': datetime.datetime(2019, 10, 16, 0, 0),
+          'mmc': 0.3,
+          'fnc': 0.1,
+          'correlationWithMetamodel': 0.87},
+          ...
+        ]
+    """
+    query = """
+              query($username: String!) {
+                v2UserProfile(username: $username) {
+                  dailySubmissionPerformances {
+                    date
+                    correlation
+                    corrPercentile
+                    roundNumber
+                    mmc
+                    mmcPercentile
+                    fnc
+                    fncPercentile
+                    correlationWithMetamodel
+                  }
+                }
+              }
+            """
+    arguments = {'username': username}
+    data = napi.raw_query(query, arguments)['data']#['v2UserProfile']
+    # performances = data['dailySubmissionPerformances']
+    # # convert strings to python objects
+    # for perf in performances:
+    #     utils.replace(perf, "date", utils.parse_datetime_string)
+    # # remove useless items
+    # performances = [p for p in performances
+    #                 if any([p['correlation'], p['fnc'], p['mmc']])]
+    return data
+
+
+def download_dataset(filename: str, dest_path: str = None,
+                     round_num: int = None) -> None:
+    """ Download specified file for the current active round.
+
+    Args:
+        filename (str): file to be downloaded
+        dest_path (str, optional): complate path where the file should be
+            stored, defaults to the same name as the source file
+        round_num (int, optional): tournament round you are interested in.
+            defaults to the current round
+        tournament (int, optional): ID of the tournament, defaults to 8
+
+    Example:
+        >>> filenames = NumerAPI().list_datasets()
+        >>> NumerAPI().download_dataset(filenames[0]}")
+    """
+    if dest_path is None:
+        dest_path = filename
+
+    query = """
+    query ($filename: String!
+           $round: Int) {
+        dataset(filename: $filename
+                round: $round)
+    }
+    """
+    args = {'filename': filename, "round": round_num}
+
+    dataset_url = napi.raw_query(query, args)['data']['dataset']
+    utils.download_file(dataset_url, dest_path, show_progress_bars=True)
+    
+    
+    
+# function using V3UserProfile
+
+def model_payout_history(model):
+    napi = numerapi.NumerAPI()
+    query = """
+              query($model: String!) {
+                  v3UserProfile(modelName: $model) {
+                        roundModelPerformances{
+                            payout
+                            roundNumber
+                            roundResolved
+                            roundResolveTime
+                            corrMultiplier
+                            mmcMultiplier
+                            selectedStakeValue
+                        }
+                        stakeValue
+                        nmrStaked
+                   }
+              }
+            """
+    arguments = {'model': model}
+    payout_info = napi.raw_query(query, arguments)['data']['v3UserProfile']['roundModelPerformances']
+    payout_info = pd.DataFrame.from_dict(payout_info)
+    payout_info = payout_info[~pd.isnull(payout_info['payout'])].reset_index(drop=True)
+    return payout_info
+
+
+def get_model_history_v3(model):
+    res = model_payout_history(model)
+    res = pd.DataFrame.from_dict(res)
+    res['payout'] = res['payout'].astype(np.float64)
+    res['current_stake'] = res['selectedStakeValue'].astype(np.float64)
+    res['payout_cumsum'] = project_utils.series_reverse_cumsum(res['payout'])
+    res['date'] = pd.to_datetime(res['roundResolveTime']).dt.date
+
+    res['realised_pl'] = res['payout_cumsum']
+    latest_realised_pl = res[res['roundResolved'] == True]['payout_cumsum'].max()
+    res.loc[res['roundResolved'] == False, 'realised_pl'] = latest_realised_pl
+
+    res['floating_pl'] = 0
+    payoutPending_values = res[res['roundResolved'] == False]['payout'].values
+    payoutPending_cumsum = payoutPending_values[::-1].cumsum()[::-1]
+    res.loc[res['roundResolved'] == False, 'floating_pl'] = payoutPending_cumsum
+
+    res['model'] = model
+    #     res['floating_pl'] = res['current_stake'] + res['payoutPending']
+    res['floating_stake'] = res['current_stake'] + res['floating_pl']
+    cols = ['model', 'date', 'current_stake', 'floating_stake', 'payout', 'floating_pl', 'realised_pl', 'roundResolved',
+            'roundNumber']
+    res = res[cols]
+    return res
+
+
+
+
+
+

project_tools/project_config.py

@@ -5,3 +5,39 @@ sys.path.append(os.path.dirname(os.getcwd()))
 DATETIME_FORMAT1 = '%Y%m%d%H%M'
 DATETIME_FORMAT2 = '%Y/%m/%d %H:%M'
 DATETIME_FORMAT3 = '%Y-%m-%d'
+
+MODEL_NAMES = ['yxbot', 'yxbot2', 'sforest_baihu', 'stree_qinlong', 'flyingbus_mcv6', 'starry_night','fish_and_chips', 'rogue_planet', 'three_body_problem', 'grinning_cat', 'schrodingers_cat', 'omega_weapon', 'ifirit','dark_bahamut', 'wen_score',  'qinlong', 'baihu','marlboro', 'hell_cerberus', 'fuxi', 'roci_fuxi', 'kupo_mcv7', 'yxbot_mcv2', 'yxbot_mcv10']
+
+
+NEW_MODEL_NAMES = ['yxbot3_m15', 'yxbot4_m23', 'yxbot5', 'yxbot6_m16', 'yxbot7_m17', 'yxbot_a10b8', 'yxbot9_m24', 'yxbot_a10', 'yxbot_a10xu', 'yxbot_a10bk','yxbot_a11', 'yxbot_a12', 'yxbot_ultima_weapon', 'yxbot_valkyrie', 'yxbot_bearmate', 'yxbot_dracula','yxbot_a13', 'yxbot_a14', 'yxbot15_zhuque', 'yxbot_redhare', 'yxbot_a15', 'yxbot18_m25', 'yxbot11_x302']
+
+# flyingbus
+
+TOP_LB = ['mdl3', 'nescience', 'sapphirescipionyx','quantaquetzalcoatlus', 'anna13', 'mercuryai', 'uuazed6', 'rosetta', 'sinookas']
+
+
+TP3M = ['ageonsen', 'davebaty', 'wallingford_nut', 'filipstefano2', 'davat6', 'lions', 'wsw', 'lottery_of_babylon', 'kup_choy_n', 'pinky_and_the_brain']
+
+
+TP1Y = ['hiryuu', 'victoria', 'benben11', 'usigma7', 'crystal_sphere', 'era__mix__2000', 'rgb_alpha', 'smokh', 'shoukaku', 'stables', 'deepnum', 'botarai', 'zuikaku', 'kond']
+
+
+ARBITRAGE_MODELS = ['arbitrage', 'arbitrage2', 'arbitrage3', 'arbitrage4', 'leverage', 'leverage2', 'leverage3', 'culebracapital', 'culebracapital2', 'culebracapital3']
+
+
+IAAI_MODELS = ['ia_ai',  'the_aijoe4','i_like_the_coin_08', 'i_like_the_coin_09', 'i_like_the_coin_10']
+
+
+RESTRADE_MODELS = ['restrading', 'restrading2', 'restrading3', 'restrading4', 'restrading5', 'restrading6', 'restrading7', 'restrading8', 'restrading9']
+
+
+BENCHMARK_MODELS = ['integration_test', 'i_like_the_coin_01'] #'budbot_7'] #'integration_test_7'
+MCV_MODELS = ['mcv', 'mcv2', 'mcv3', 'mcv4', 'mcv5','mcv6','mcv7','mcv8','mcv9','mcv10','mcv11','mcv12','mcv13']
+
+MCV_NEW_MODELS = ['mcv14', 'mcv15', 'mcv16', 'mcv17', 'mcv18', 'mcv19', 'mcv20', 'mcv21', 'mcv22', 'mcv23', 'mcv24', 'mcv25', 'mcv26', 'mcv27', 'mcv28', 'mcv29', 'mcv30', 'mcv31', 'mcv32', 'mcv33', 'mcv34', 'mcv35', 'mcv36', 'mcv37', 'mcv38', 'mcv39', 'mcv40', 'mcv41', 'mcv42', 'mcv43', 'mcv44', 'mcv45', 'mcv46', 'mcv47', 'mcv48', 'mcv49', 'mcv50']
+
+
+DASHBOARD_MODEL_RESULT_FILE = '../feature_data/dashboard_model_result.pkl'
+NUMERATI_URL = 'https://raw.githubusercontent.com/woobe/numerati/master/data.csv'
+NUMERATI_FILE = '../feature_data/numerati_data.pkl'
+FEATURE_PATH = '../feature_data/'

project_tools/project_utils.py

@@ -1,31 +1,39 @@
 import numpy as np
 import pandas as pd
-import random
 import os
-from os import listdir
-from os.path import isfile, join, isdir
-import cv2
 import pickle
-import sys
 import time
 from contextlib import contextmanager
 from importlib import reload
-# from datetime import datetime
-from shutil import copyfile, move
 import re
-from pathlib import Path
-
-from project_tools import project_config, project_utils
-
-from shutil import copyfile, move
-import gc
+from project_tools import project_config, project_utils, numerapi_utils
 import glob
-from multiprocessing import Pool
-from functools import partial
 import matplotlib.pyplot as plt
-import traceback
-import json
+import seaborn as sns
+from random import randint, random
+import itertools
+import scipy
+from scipy.stats import ks_2samp
+from sklearn.metrics import log_loss, roc_auc_score, accuracy_score, mean_squared_error
+from sklearn.preprocessing import MinMaxScaler, StandardScaler
+from sklearn.pipeline import make_pipeline
+from sklearn import linear_model
 import datetime
+import json
+from collections import OrderedDict
+from os import listdir
+from os.path import isfile, join, isdir
+import glob
+import numerapi
+import itertools
+import io
+import requests
+from pathlib import Path
+from scipy.stats.mstats import gmean
+from typing import List, Dict
+
+
+napi = numerapi.NumerAPI() #verbosity="info")
 
 
 def get_time_string():
@@ -46,8 +54,7 @@ def reload_project():
     """
     reload(project_config)
     reload(project_utils)
-    reload(project_class)
-
+    reload(numerapi_utils)
 
 @contextmanager
 def timer(name):
@@ -234,6 +241,16 @@ def empty_folder(path):
         os.remove(f)
 
 
+def rescale(n, range1, range2):
+    if n>range1[1]: #or n<range1[0]:
+        n=range1[1]
+    if n<range1[0]:
+        n=range1[0]
+    delta1 = range1[1] - range1[0]
+    delta2 = range2[1] - range2[0]
+    return (delta2 * (n - range1[0]) / delta1) + range2[0]
+
+
 
 def rmse(y_true, y_pred):
     """
@@ -639,6 +656,151 @@ def try_divide(x, y, val=0.0):
     return val
 
 
+def series_reverse_cumsum(a):
+    return a.fillna(0).values[::-1].cumsum()[::-1]
+
+
+
+#### NumerDash specific functions ###
+
+def calculate_rounddailysharpe_dashboard(df, lastround, earliest_round, score='corr'):
+    if score=='corr':
+        target = 'corr_sharpe'
+    elif score == 'corr_pct':
+        target = 'corr_pct_sharpe'
+    elif score=='mmc':
+        target = 'mmc_sharpe'
+    elif score=='mmc_pct':
+        target = 'mmc_pct_sharpe'
+    elif score=='corrmmc':
+        target = 'corrmmc_sharpe'
+    elif score=='corr2mmc':
+        target = 'corr2mmc_sharpe'
+    elif score=='cmavg_pct':
+        target = 'cmavgpct_sharpe'
+    elif score=='c2mavg_pct':
+        target = 'c2mavcpct_sharpe'
+
+    mean_feat = 'avg_sharpe'
+    sos_feat = 'sos'
+    df = df[(df['roundNumber'] >= earliest_round) & (df['roundNumber'] <= lastround)]
+    res = df.groupby(['model', 'roundNumber', 'group'])[score].apply(
+        lambda x: get_array_sharpe(x)).reset_index(drop=False)
+    res = res.rename(columns={score: target}).sort_values('roundNumber', ascending=False)
+    res = res.pivot(index=['model', 'group'], columns='roundNumber', values=target)
+    res.columns.name = ''
+    cols = [i for i in res.columns[::-1]]
+    res = res[cols]
+    res[mean_feat] = res[cols].mean(axis=1)
+    res[sos_feat] = res[cols].apply(lambda x: get_array_sharpe(x), axis=1)
+    res = res.drop_duplicates(keep='first').sort_values(by=sos_feat, ascending=False)
+    res.reset_index(drop=False, inplace=True)
+    return res[['model', 'group', sos_feat, mean_feat]+cols]
+
+
+
+def groupby_agg_execution(agg_recipies, df, verbose=True):
+    result_dfs = dict()
+    for groupby_cols, features, aggs in agg_recipies:
+        group_object = df.groupby(groupby_cols)
+        groupby_key = '_'.join(groupby_cols)
+        if groupby_key not in list(result_dfs.keys()):
+            result_dfs[groupby_key] = pd.DataFrame()
+        for feature in features:
+            rename_col = feature
+            for agg in aggs:
+                if isinstance(agg, dict):
+                    agg_name = list(agg.keys())[0]
+                    agg_func = agg[agg_name]
+                else:
+                    agg_name = agg
+                    agg_func = agg
+                if agg_name=='count':
+                    groupby_aggregate_name = '{}_{}'.format(groupby_key, agg_name)
+                else:
+                    groupby_aggregate_name = '{}_{}_{}'.format(groupby_key, feature, agg_name)
+                verbose and print(f'generating statistic {groupby_aggregate_name}')
+                groupby_res_df = group_object[feature].agg(agg_func).reset_index(drop=False)
+                groupby_res_df = groupby_res_df.rename(columns={rename_col: groupby_aggregate_name})
+                if len(result_dfs[groupby_key]) == 0:
+                    result_dfs[groupby_key] = groupby_res_df
+                else:
+                    result_dfs[groupby_key][groupby_aggregate_name] = groupby_res_df[groupby_aggregate_name]
+    return result_dfs
+
+
+def get_latest_round_id():
+    try:
+        all_competitions = numerapi_utils.get_competitions()
+        latest_comp_id = all_competitions[0]['number']
+    except:
+        print('calling api unsuccessulf, using downloaded data to get the latest round')
+        local_data = load_data(project_config.DASHBOARD_MODEL_RESULT_FILE)
+        latest_comp_id = local_data['roundNumber'].max()
+    return int(latest_comp_id)
+#     except:
+
+latest_round = get_latest_round_id()
+
+
+
+
+def update_numerati_data(url=project_config.NUMERATI_URL, save_path=project_config.FEATURE_PATH):
+    content = requests.get(url).content
+    data = pd.read_csv(io.StringIO(content.decode('utf-8')))
+    save_file = os.path.join(save_path, 'numerati_data.pkl')
+    pickle_data(save_file, data)
+    return data
+
+
+
+
+def get_model_group(model_name):
+    cat_name = 'other'
+    if model_name in project_config.MODEL_NAMES+project_config.NEW_MODEL_NAMES:
+        cat_name = 'yx'
+    elif model_name in project_config.TOP_LB:
+        cat_name = 'top_corr'
+    elif model_name in project_config.IAAI_MODELS:
+        cat_name = 'iaai'
+    elif model_name in project_config.ARBITRAGE_MODELS:
+        cat_name = 'arbitrage'
+    elif model_name in project_config.MCV_MODELS:
+        cat_name = 'mcv'
+    # elif model_name in project_config.MM_MODELS:
+    #     cat_name = 'mm'
+    elif model_name in project_config.BENCHMARK_MODELS:
+        cat_name = 'benchmark'
+    elif model_name in project_config.TP3M:
+        cat_name = 'top_3m'
+    elif model_name in project_config.TP1Y:
+        cat_name = 'top_1y'
+    return cat_name
+
+
+def get_dashboard_data_status():
+    dashboard_data_tstr = 'NA'
+    nmtd_tstr = 'NA'
+    try:
+        dashboard_data_t = datetime.datetime.utcfromtimestamp(os.path.getctime(project_config.DASHBOARD_MODEL_RESULT_FILE))
+        dashboard_data_tstr = dashboard_data_t.strftime(project_config.DATETIME_FORMAT2)
+    except Exception as e:
+        print(e)
+        pass
+    try:
+        nmtd_t = datetime.datetime.utcfromtimestamp(os.path.getctime(project_config.NUMERATI_FILE))
+        nmtd_tstr = nmtd_t.strftime(project_config.DATETIME_FORMAT2)
+    except Exception as e:
+        print(e)
+        pass
+    return dashboard_data_tstr, nmtd_tstr
+
+
+
+
+
+
+
 
 
 

x302_dev

@@ -0,0 +1 @@
+../x302_sp/numerdash/