Spaces:
Running
Running
File size: 5,564 Bytes
aad220f |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 |
import time
import pandas as pd
import streamlit as st
import plotly.express as px
import utils
_ = """
Proteins folded (delta 24hr)
Current proteins folding (24hr)
Average time to fold trend
Refolded proteins (group by run id and pdb id and get unique)
Simulation duration distribution
"""
UPDATE_INTERVAL = 3600
st.title('Folding Subnet Dashboard')
st.markdown('<br>', unsafe_allow_html=True)
# reload data periodically
df = utils.build_data(time.time()//UPDATE_INTERVAL)
st.toast(f'Loaded {len(df)} runs')
# TODO: fix the factor for 24 hours ago
runs_alive_24h_ago = (df.last_event_at > pd.Timestamp.now() - pd.Timedelta('1d'))
df_24h = df.loc[runs_alive_24h_ago]
# correction factor to account for the fact that the data straddles the 24h boundary
# correction factor is based on the fraction of the run which occurred in the last 24h
# factor = (df_24h.last_event_at - pd.Timestamp.now() + pd.Timedelta('1d')) / pd.Timedelta('1d')
#### ------ PRODUCTIVITY ------
# Overview of productivity
st.subheader('Productivity overview')
st.info('Productivity metrics show how many proteins have been folded, which is the primary goal of the subnet. Metrics are estimated using weights and biases data combined with heuristics.')
productivity = utils.get_productivity(df)
productivity_24h = utils.get_productivity(df_24h)
m1, m2, m3 = st.columns(3)
m1.metric('Unique proteins folded', f'{productivity.get("unique_folded"):,.0f}', delta=f'{productivity_24h.get("unique_folded"):,.0f} (24h)')
m2.metric('Total proteins folded', f'{productivity.get("total_simulations"):,.0f}', delta=f'{productivity_24h.get("total_simulations"):,.0f} (24h)')
m3.metric('Total simulation steps', f'{productivity.get("total_md_steps"):,.0f}', delta=f'{productivity_24h.get("total_md_steps"):,.0f} (24h)')
st.markdown('<br>', unsafe_allow_html=True)
time_binned_data = df.set_index('last_event_at').groupby(pd.Grouper(freq='12h'))
PROD_CHOICES = {
'Unique proteins folded': 'unique_pdbs',
'Total simulations': 'total_pdbs',
'Total simulation steps': 'total_md_steps',
}
prod_choice_label = st.radio('Select productivity metric', list(PROD_CHOICES.keys()), index=0, horizontal=True)
prod_choice = PROD_CHOICES[prod_choice_label]
steps_running_total = time_binned_data[prod_choice].sum().cumsum()
st.plotly_chart(
# add fillgradient to make it easier to see the trend
px.area(steps_running_total, y=prod_choice,
labels={'last_event_at':'', prod_choice: prod_choice_label},
).update_traces(fill='tozeroy'),
use_container_width=True,
)
st.markdown('<br>', unsafe_allow_html=True)
#### ------ THROUGHPUT ------
st.subheader('Throughput overview')
st.info('Throughput metrics show the total amount of data sent and received by the validators. This is a measure of the network activity and the amount of data that is being processed by the subnet.')
MEM_UNIT = 'GB' #st.radio('Select memory unit', ['TB','GB', 'MB'], index=0, horizontal=True)
data_transferred = utils.get_data_transferred(df,unit=MEM_UNIT)
data_transferred_24h = utils.get_data_transferred(df_24h, unit=MEM_UNIT)
m1, m2, m3 = st.columns(3)
m1.metric(f'Total sent data ({MEM_UNIT})', f'{data_transferred.get("sent"):,.0f}', delta=f'{data_transferred_24h.get("sent"):,.0f} (24h)')
m2.metric(f'Total received data ({MEM_UNIT})', f'{data_transferred.get("received"):,.0f}', delta=f'{data_transferred_24h.get("received"):,.0f} (24h)')
m3.metric(f'Total transferred data ({MEM_UNIT})', f'{data_transferred.get("total"):,.0f}', delta=f'{data_transferred_24h.get("total"):,.0f} (24h)')
IO_CHOICES = {'total_data_sent':'Sent', 'total_data_received':'Received'}
io_running_total = time_binned_data[list(IO_CHOICES.keys())].sum().rename(columns=IO_CHOICES).cumsum().melt(ignore_index=False)
io_running_total['value'] = io_running_total['value'].apply(utils.convert_unit, args=(utils.BASE_UNITS, MEM_UNIT))
st.plotly_chart(
px.area(io_running_total, y='value', color='variable',
labels={'last_event_at':'', 'value': f'Data transferred ({MEM_UNIT})', 'variable':'Direction'},
),
use_container_width=True,
)
st.markdown('<br>', unsafe_allow_html=True)
#### ------ LEADERBOARD ------
st.subheader('Leaderboard')
st.info('The leaderboard shows the top miners by incentive.')
m1, m2 = st.columns(2)
ntop = m1.slider('Number of top miners to display', value=10, min_value=3, max_value=50, step=1)
entity_choice = m2.radio('Select entity', utils.ENTITY_CHOICES, index=0, horizontal=True)
df_m = utils.get_metagraph(time.time()//UPDATE_INTERVAL)
df_miners = utils.get_leaderboard(df_m, ntop=ntop, entity_choice=entity_choice)
# hide colorbar and don't show y axis
st.plotly_chart(
px.bar(df_miners, x='I', color='I', hover_name=entity_choice, text=entity_choice if ntop < 20 else None,
labels={'I':'Incentive', 'trust':'Trust', 'stake':'Stake', '_index':'Rank'},
).update_layout(coloraxis_showscale=False, yaxis_visible=False),
use_container_width=True,
)
with st.expander('Show raw metagraph data'):
st.dataframe(df_m)
st.markdown('<br>', unsafe_allow_html=True)
#### ------ LOGGED RUNS ------
st.subheader('Logged runs')
st.info('The timeline shows the creation and last event time of each run.')
st.plotly_chart(
px.timeline(df, x_start='created_at', x_end='last_event_at', y='username', color='state',
labels={'created_at':'Created at', 'last_event_at':'Last event at', 'username':''},
),
use_container_width=True
)
with st.expander('Show raw run data'):
st.dataframe(df) |