improve stake overview UI, and integrate FNCV3

dash/numerdash_app.py

@@ -98,7 +98,7 @@ def default_model_picker():
     return picked_models
 
 
-def model_fast_picker(models):
+def model_fast_picker(model_list):
     text_content = '''
                     fast model picker by CSV string.
                     example: "model1, model2, model3" 
@@ -109,7 +109,7 @@ def model_fast_picker(models):
         csv_parts = text.split(',')
         for s in csv_parts:
             m = s.strip()
-            if m not in models:
+            if (m  in model_list): #and (m not in preselected_models):
                 result_models.append(m)
     return list(dict.fromkeys(result_models))
 
@@ -127,10 +127,11 @@ def generate_round_table(data, row_cts, c, r, sortcol='corrmmc'):
     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_resolved_time = round_data['roundResolveTime'][0]
     # 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)
+    # latest_date = round_data['date'].values[0]
+    row_cts[c].write(f'round: {select_round}  resolved time: {round_resolved_time}')
+    row_cts[c].dataframe(round_data.drop(['roundNumber', 'roundResolveTime'], axis=1), height=max_table_height-100)
 
 
 
@@ -148,10 +149,10 @@ def generate_dailyscore_metrics(data, row_cts, c, r):
     pass
 
 def get_roundmetric_data(data):
-    numfeats1 = ['corr', 'mmc', 'corrmmc', 'corr2mmc']
+    numfeats1 = ['corr', 'mmc', 'tc', 'corrmmc', 'corrtc', 'fncV3', 'fncV3_pct']
     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']
+    numfeats2 = ['corr_pct', 'mmc_pct', 'tc_pct','corrtc_avg_pct', 'corrmmc_avg_pct']
     stat2 = ['mean']#, {'sharp': project_utils.get_array_sharpe}]
 
     roundmetric_agg_rcp = [
@@ -175,19 +176,20 @@ def generate_round_metrics(data, row_cts, c, r):
     # 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):
+            if (f'{select_metric}_' in col) or ('corrmmc_avg_' in col):
                 cols += [col]
-        elif select_metric =='corr2mmc':
-            if (f'{select_metric}_' in col) or ('c2mavg_' in col):
+        elif select_metric =='corrtc':
+            if (f'{select_metric}_' in col) or ('corrtc_avg_' in col):
                 cols += [col]
         else:
-            if (f'{select_metric}_' in col) and (not('corrmmc' in col)) and (not('corr2mmc' in col)):
+            # if (f'{select_metric}_' in col) and (not('corrmmc' in col)) and (not('corrtc' in col)):
+            if (f'{select_metric}_' in col):
                 cols+= [col]
 
     if select_metric != 'pct':
         sort_col = select_metric+'_sharpe'
     else:
-        sort_col = 'cmavg_pct_mean'
+        sort_col = 'corr_pct_mean'
     view_data = data[cols].sort_values(by=sort_col, ascending=False)
     row_cts[c].dataframe(view_data)
     pass
@@ -237,7 +239,7 @@ def round_view(data, select_perview, select_metric=None):
                 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':
+            if select_perview=='metric_view':
                 generate_round_metrics(data, row_cts, c, r)
             if select_perview=='dailyscore_chart':
                 dailyscore_chart(data, row_cts, c, r, select_metric)
@@ -246,26 +248,50 @@ def round_view(data, select_perview, select_metric=None):
 
 
 def score_overview():
-    models = []
-    data = []
-    benchmark_opt = st.sidebar.checkbox('download default models', value=True)
-
-    model_selection = st.empty()
-    if benchmark_opt:
-        model_dict = default_model_picker()
-        for k in model_dict.keys():
-            models += model_dict[k]
-    models = models + model_fast_picker(models)
-    # if len(models)>0:
-        # model_selection = st.sidebar.multiselect('select models', models, default=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])
-    if len(models)>0:
-        model_selection.multiselect('selected models', models, default=models)
+    if 'model_data' in st.session_state:
+        data = st.session_state['model_data'].copy()
+        data = data.drop_duplicates(['model', 'roundNumber'], keep='first')
+        roundview =  st.expander('round performance overview', expanded=True)
+        with roundview:
+            round_view(data, 'round_result')
+    else:
+        st.write('model data missing, please go to the Dowanload Score Data section to download model data first')
+
+def metric_overview():
+    if 'model_data' in st.session_state:
+        data = st.session_state['model_data'].copy()
+        st.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 = 280
+        else:
+            suggest_round = earliest_round
+        select_rounds = st.slider('select a round', earliest_round, latest_round, (suggest_round, latest_round - 1), 1)
+        data=data.drop_duplicates(['model', 'roundNumber'], keep='first')
+        data = data[(data['roundNumber'] >= select_rounds[0]) & (data['roundNumber'] <= select_rounds[1])].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)
+        metricview_exp = st.expander('metric overview', expanded=True)
+        dataview_exp = st.expander('full data view', expanded=False)
+        with metricview_exp:
+            round_view(roundmetrics_data, 'metric_view')
+        with dataview_exp:
+            st.write(roundmetrics_data)
+    else:
+        st.write('model data missing, please go to the Dowanload Score Data section to download model data first')
 
 
 def data_operation():
     # top_lb, top_tp3m, top_tp1y, special_list = sidebar_data_picker()
+    full_model_list = st.session_state['models']
     latest_round = project_utils.latest_round
     models = []
     benchmark_opt = st.sidebar.checkbox('download default models', value=True)
@@ -273,9 +299,9 @@ def data_operation():
         model_dict = default_model_picker()
         for k in model_dict.keys():
             models += model_dict[k]
-    models = models + model_fast_picker(models)
+    models = models + model_fast_picker(full_model_list)
     if len(models)>0:
-        model_selection = st.multiselect('select models', models, default=models)
+        model_selection = st.multiselect('select models', st.session_state['models'], default=models)
     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)]
@@ -297,13 +323,16 @@ def data_operation():
     if prjreload:
         project_utils.reload_project()
     if len(model_df)>0:
-        rename_dict = {'corrPercentile': 'corr_pct', 'correlation':'corr', 'corrWMetamodel':'corr_meta', 'mmcPercentile':'mmc_pct', 'tcPercentile':'tc_pct'}
+        rename_dict = {'corrPercentile': 'corr_pct', 'correlation':'corr', 'corrWMetamodel':'corr_meta', 'mmcPercentile':'mmc_pct', 'tcPercentile':'tc_pct', 'fncV3Percentile':'fncV3_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', 'tc', 'tc_pct', 'corr2mmc','c2mavg_pct', 'roundNumber']
+        model_df['corrmmc_avg_pct'] = (model_df['corr_pct'] + model_df['mmc_pct'])/2
+        model_df['corrtc'] = model_df['corr'] + model_df['tc']
+        model_df['corrtc_avg_pct'] = (model_df['corr_pct'] + model_df['tc_pct'])/2
+        # st.write(model_df.head(5))
+        # ord_cols = ['model','corr', 'mmc', 'tc', 'corrmmc', 'corrtc', 'corr_pct', 'tc_pct',  'corrtc_avg_pct','corr_meta', 'mmc_pct', 'corrmmc_avg_pct', 'roundNumber', 'roundResolveTime']
+        ord_cols = ['model','corr', 'tc',  'corrtc', 'corr_pct', 'tc_pct',  'corrtc_avg_pct','corr_meta',  'fncV3', 'fncV3_pct','corrmmc_avg_pct', 'roundNumber', 'roundResolveTime', 'mmc', 'corrmmc','mmc_pct']
+
         model_df = model_df[ord_cols]
         if project_config.SAVE_LOCAL_COPY:
             project_utils.pickle_data(project_config.MODEL_ROUND_RESULT_FILE, model_df)
@@ -313,8 +342,9 @@ def data_operation():
         st.text('list of models being tracked')
         st.write(model_dict)
         try:
-            st.write(st.session_state['model_data'].shape)
-            st.write(model_df.head(5))
+            dshape = st.session_state['model_data'].shape
+            st.write(f'downloaded model result data shape is {dshape}')
+            st.write(model_df)
         except:
             st.write('model data was not retrieved')
 
@@ -373,6 +403,8 @@ def download_model_round_result(models, roundlist, show_info):
         time.sleep(0.1)
         my_bar.progress(percent_complete)
         model_df = pd.concat(model_dfs, axis=0).sort_values(by=['roundNumber'], ascending=False).reset_index(drop=True)
+        model_df['roundResolveTime'] = pd.to_datetime(model_df['roundResolveTime'])
+        model_df['roundResolveTime'] = model_df['roundResolveTime'].dt.strftime(project_config.DATETIME_FORMAT3)
         model_df = model_df[model_df['roundNumber'].isin(roundlist)].reset_index(drop=True)
     return model_df
 
@@ -396,9 +428,6 @@ def roundresult_chart(data, model_selection):
     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]
@@ -409,17 +438,11 @@ def roundresult_chart(data, model_selection):
     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)
-
+    fig = chart_pxline(round_data, 'roundNumber', y=select_metric, color='model avg.', hover_data=list(histtrend_opt.keys())+['roundResolveTime'],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}')
+
 
 
 
@@ -427,22 +450,16 @@ def roundresult_chart(data, model_selection):
 def histtrend():
     # default_models = ['yxbot']
     # models = default_models.copy()
-    models = []
+    data = st.session_state['model_data'].copy()
+    models = data['model'].unique().tolist()
     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)
+    if len(model_selection)>0:
         roundresult_chart(data, model_selection)
 
         # fig = px.line(df, x='roundNumber', y='corr', color='model', hover_data=['corr_pct'])
@@ -458,31 +475,22 @@ def histtrend():
 
 
 def model_evaluation():
-    models = []
+    data = st.session_state['model_data'].copy()
+    models = data['model'].unique().tolist()
     model_selection = []
-    model_dict = model_data_picker_bak(values=[True, True, True, True, True, True])
+    default_models = model_fast_picker(models)
     mean_scale = [-0.05, 0.1]
     count_scale = [1, 50]
-    sharpe_scale = [-0.2, 3]
+    sharpe_scale = [-0.2, 2]
     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]]
-
+            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)
+    if len(model_selection)>0:
         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())
@@ -493,18 +501,17 @@ def model_evaluation():
         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']
+        # defaultlist = ['corr_sharpe', 'tc_sharpe',  'corrtc_sharpe','corr_mean', 'tc_mean' 'corrtc_mean', 'corrtc_avg_pct','count']
+
+        defaultlist = ['corr_sharpe', 'tc_sharpe',  'corrtc_sharpe', 'corr_mean', 'tc_mean', 'corrtc_mean', 'corrtc_avg_pct_mean']
 
         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)
+        roundmetric_df = get_roundmetric_data(round_data).sort_values(by='corrtc_sharpe', ascending=False).reset_index(drop=True)
 
         radarmetric_df = roundmetric_df.copy(deep=True)
         for col in select_metrics:
@@ -574,7 +581,7 @@ def get_portfolio_overview(models, onlylatest=True):
     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']
+        cols = ['model', 'date', 'current_stake', 'floating_stake', 'floating_pl', 'realised_pl', 'profitability', 'roundNumber', 'roundResolved', 'payout']
 
         # res_df['date'] = res_df['date'].dt.date
         if onlylatest:
@@ -684,17 +691,23 @@ def check_session_state(key):
 
 
 def stake_overview():
-    models = []
+    # data = st.session_state['models'].copy()
+    models = st.session_state['models'].copy()
     model_selection = []
-    model_dict = model_data_picker_bak(values=[True, True, True, True, True, True])
+    baseline_models = []
+    model_dict = default_model_picker()
     for k in model_dict.keys():
-        if model_dict[k] not in models:
-            models += model_dict[k]
+        baseline_models += model_dict[k]
 
     default_models = model_fast_picker(models)
+
     if len(models)>0:
+        # if len(default_models)==0:
+        #     default_models = baseline_models[0]
         model_selection = st.sidebar.multiselect('select models for chart', models, default=default_models)
+
     redownload_data = False
+    # download = st.sidebar.button('download stake data')
     if len(model_selection) > 0:
         if 'stake_df' not in st.session_state:
             redownload_data = True
@@ -705,34 +718,34 @@ def stake_overview():
                 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]
+        if len(ovdf) > 0:
+            overview_cols = ['model', 'current_stake', 'floating_stake', 'floating_pl', 'realised_pl']
+            date_text = datetime.datetime.now().strftime(project_config.DATETIME_FORMAT3)
             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)
+            ovdf_exp = st.expander('stake data overview', expanded=True)
             with ovdf_exp:
-                st.dataframe(ovdf, height=max_table_height)
+                st.dataframe(ovdf[overview_cols], 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:
+            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:
+            if fpl >= 0:
                 float_pl_color = 'green'
             else:
                 float_pl_color = 'red'
@@ -742,15 +755,36 @@ def stake_overview():
             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)
+            date_label.subheader(f'Date: {date_text}')
+        if st.sidebar.checkbox('show breakdown by live rounds', value=False):
+            liveround_exp = st.expander('show breakdown by live rounds (requires extra data downloading)',expanded=True)
+            with liveround_exp:
+                stake_models = ovdf['model'].tolist()
+                liveround_stake_df = get_stake_by_liverounds(stake_models)
+                round_view(liveround_stake_df,'live_round_stake')
+        if st.sidebar.checkbox('show resolved round summary', value=False):
+            resolvedround_exp = st.expander('show resolved rounds summary for selected model group', expanded=True)
+            with resolvedround_exp:
+                get_roundresolve_history(chartdf)
+                # st.write(chartdf)
+
+
+def get_roundresolve_history(data):
+    resolved_rounds = data[data['roundResolved'] == True]['roundNumber'].unique().tolist()
+    rsdf = data[data['roundResolved'] == True].reset_index(drop=True)
+    rs_date = rsdf[['date', 'roundNumber']].drop_duplicates('roundNumber').reset_index(drop=True)
+    numfeats = ['current_stake', 'payout']
+    stat1 = ['sum']
+    agg_rcp = [[['roundNumber'], numfeats, stat1]]
+    res = project_utils.groupby_agg_execution(agg_rcp, rsdf)['roundNumber'].sort_values(by='roundNumber',
+                                                                                        ascending=False)
+    res = res.merge(right=rs_date, on='roundNumber')
+
+    rename_dict = {'roundNumber': 'Round', 'roundNumber_current_stake_sum': 'Total Stake',
+                   'roundNumber_payout_sum': 'Round P/L', 'date': 'Resolved Date'}
+    res.rename(columns=rename_dict, inplace=True)
+    st.write(res)
 
-                    round_view(liveround_stake_df,'live_round_stake')
 
 
 
@@ -766,12 +800,14 @@ def app_setting():
 
 
 def performance_overview():
+    # st.sidebar.subheader('Choose a Table View')
     select_app = st.sidebar.selectbox("", list(pfm_opt.keys()), index=0, format_func=lambda x: pfm_opt[x])
     if select_app=='data_op':
         data_operation()
-
-    if select_app=='performance_overview':
-        performance_overview()
+    if select_app=='liveround_view':
+        score_overview()
+    if select_app=='metric_view':
+        metric_overview()
     if select_app=='historic_trend':
         histtrend()
     if select_app=='model_evaluation':
@@ -795,13 +831,14 @@ def show_content():
 app_opt = {
            'performance_overview' : 'Performance Overview',
            'stake_overview': 'Stake Overview',
-           'app_setting':''
+           # 'app_setting':''
            }
 
 
 pfm_opt = {
     'data_op': 'Download Score Data',
-    'liveround_view': 'Live Round Overview',
+    'liveround_view': 'Round Overview',
+    'metric_view':'Metric Overview',
     'historic_trend': 'Historic Trend',
     'model_evaluation': 'Model Evaluation',
 }
@@ -839,23 +876,26 @@ id_metric_score_dic = {
 
 
 roundmetric_opt ={'corr':'Corr metrics',
-                  'mmc' : 'MMC metrics',
+                  'tc': 'TC metrics',
+                  'corrtc': 'CorrTC metrics',
+                  'fncV3': 'FNCV3 metrics',
+                  'pct': 'Pecentage metrics',
                   'corrmmc' : 'CorrMMC metrics',
-                  'corr2mmc' : 'Corr2MMC metrics',
-                  'pct' : 'Pecentage metrics'
-
+                  'mmc': 'MMC metrics'
 }
 
 
 histtrend_opt = {
                 'corr':'Correlation',
                 'mmc': 'MMC',
-                'corrmmc': 'Correlation+MMC',
-                'corr2mmc': 'Correlation+2*MMC',
+                'tc' : 'TC',
                 'corr_pct': 'Correlation Percentile',
+                'tc_pct' : 'TC Percentile',
                 'mmc_pct':'MMC Percentile',
-                'cmavg_pct': 'Correlation+MMC Average Percentile',
-                'c2mavg_pct': 'Correlation+2*MMC Average Percentile',
+                'corrmmc': 'Correlation+MMC',
+                'corrtc': 'Correlation+TC',
+                'corrtc_avg_pct': 'Correlation+TC Average Percentile',
+                'corrmmc_avg_pct': 'Correlation+MMC Average Percentile',
 
 }
 
@@ -863,20 +903,19 @@ histtrend_opt = {
 model_eval_opt = {
         'corr_sharpe' : 'Correlation Sharpe',
         'mmc_sharpe' : 'MMC Sharpe',
+        'tc_sharpe' : 'TC Sharpe',
+        'corrtc_sharpe': 'Correlation+TC Sharpe',
         'corrmmc_sharpe' : 'Correlation+MMC Sharpe',
-        'corr2mmc_sharpe': 'Correlation+2*MMC Sharpe',
         'corr_mean':'Avg. Correlation',
-        'mmc_mean':'Avg. MMC',
+        'tc_mean': 'Avg. TC',
         'count': 'Number of Rounds',
+        'mmc_mean':'Avg. MMC',
+        'corrtc_mean': 'Avg. Correlation+TC',
         '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',
+        'corrmmc_avg_pct_mean': 'Avg. Correlation+MMC Percentile',
+        'corrtc_avg_pct_mean': 'Avg. Correlation+TC Percentile',
 }
 
 stakeoverview_plot_opt = {
@@ -889,10 +928,16 @@ stakeoverview_plot_opt = {
 def show_session_status_info():
     # 'raw_performance_data'
     key1 = 'model_data'
+    key2 = 'models'
     if check_session_state(key1) is None:
         st.write(f'{key1} is None')
     else:
         st.write(f'{key1} shape is {st.session_state[key1].shape}')
+
+    if check_session_state(key2) is None:
+        st.write(f'{key2} is None')
+    else:
+        st.write(f'{key2} list has {len(st.session_state[key2])} models')
     pass
 
 
@@ -904,8 +949,8 @@ 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')
 
+st.title('Numerai Dashboard')
 # key = 'pfm_default_model'
 # if check_session_state('pfm_default_model') is None:
 #     st.write('set value')
@@ -916,6 +961,11 @@ st.title('Numerai Dashboard')
 # st.write(st.session_state)
 
 df = get_saved_data()
+
+if check_session_state('models') is None:
+    with st.spinner('updating model list'):
+        st.session_state['models'] = numerapi_utils.get_lb_models()
+
 show_session_status_info()
 # st.write(f'{key} is {chkval}')
 

project_tools/numerapi_utils.py

@@ -11,43 +11,44 @@ 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
+# depreciated
+# 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')
+        # try:
+        print(f'extracting information for model {m}')
+        if onlylatest:
+            mdf = get_model_history_v3(m).loc[0:0]
+        else:
+            mdf = get_model_history_v3(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
+        # 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:
@@ -189,6 +190,9 @@ def daily_submissions_performances_V3(modelname: str) -> List[Dict]:
                         mmcPercentile
                         tc
                         tcPercentile
+                        tcMultiplier
+                        fncV3
+                        fncV3Percentile
                         corrWMetamodel
                         payout
                         roundResolved
@@ -214,8 +218,18 @@ def daily_submissions_performances_V3(modelname: str) -> List[Dict]:
     return performances
 
 
-
-
+def get_lb_models(limit=20000, offset=0):
+    query = """
+           query($limit: Int, $offset: Int){
+               v2Leaderboard(limit:$limit, offset:$offset){
+                   username
+               }           
+           }
+           """
+    arguments = {'limit':limit, 'offset':offset}
+    data = napi.raw_query(query, arguments)['data']['v2Leaderboard']
+    model_list = [i['username'] for i in data]
+    return model_list
 
 
 
@@ -377,7 +391,7 @@ def get_model_history_v3(model):
     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()
+    latest_realised_pl = res[res['roundResolved'] == True]['payout_cumsum'].values[0]
     res.loc[res['roundResolved'] == False, 'realised_pl'] = latest_realised_pl
 
     res['floating_pl'] = 0