def app():
#define price & minutes sliders
price1 = st.slider(label='Choose minimum price!',
min_value=3.5,
max_value=13.0,
step=0.1,
format='%s')
min = st.slider(label='Choose minimum minutes!',
min_value=0,
max_value=1620,
step=1)
string_list = [
'web_name', 'first_name', 'second_name', 'team_code', 'status', 'name',
'team_name', 'element_type'
]
post = st.selectbox('Select Post!', ['GK', 'DF', 'MF', 'FW'])
form = st.checkbox('Show Regression!') #checkbox to show regression
df = posts_eval(post)
new_df = df[(df['now_cost'] >= price1 * 10) &
(df['minutes'] >= min)] #change dataframe by sliders
#gk.drop(string_list,axis=1,inplace=True)
menu = [x for x in df.columns
if x not in string_list] #remove columns which are not numeric
#select parameters to compare
xa = st.selectbox('Select x-axis parameter!', menu)
ya = st.selectbox('Select y-axis parameter!', menu)
if len(new_df) == 0: #when choose nothing
fig = px.scatter(new_df, x=xa, y=ya)
else:
if form: #choose regression mode
fig = px.scatter(new_df, x=xa, y=ya, trendline='ols')
else:
fig = px.scatter(new_df, x=xa, y=ya, color='web_name')
st.write(fig) #Draw scatterplot by conditions
def test_violin_plot(self):
tips = px.data.tips()
px.scatter(tips,
x="total_bill",
y="tip",
color="smoker",
trendline="ols",
marginal_x="violin",
marginal_y="box")
def make_figure_subset(selectedPoints, antibody_selection, g):
if selectedPoints == None:
return None, None, None
# customdata
index_list = [x['customdata'][0] for x in selectedPoints['points']]
print(len(index_list), index_list[0])
tmp = df.copy()
tmp['gene_exp'] = get_exp_gene(g)
tmp = tmp.loc[index_list]
AB1 = antibody_selection[0]
AB2 = antibody_selection[1]
tmp[AB1] = antibody_df.loc[AB1]
tmp[AB2] = antibody_df.loc[AB2]
title = "(Selected) Number of cells<br> %s" % (str(
tmp["Channel"].value_counts().to_json()).replace(",", "<br>"))
print(title)
fig3 = px.scatter(
tmp,
x=AB1,
y=AB2,
color='gene_exp',
symbol="Channel",
hover_data=['barcodekey', 'n_genes', 'n_counts', 'louvain_labels'],
opacity=0.5,
size_max=3,
template="simple_white",
title=title)
fig3.update_layout(coloraxis_colorbar=dict(
yanchor="top", y=0.5, x=1, ticks="outside", len=0.5))
fig4 = px.scatter(
tmp,
x="UMAP1",
y="UMAP2",
color='gene_exp',
symbol="Channel",
hover_data=['barcodekey', 'n_genes', 'n_counts', 'louvain_labels'],
opacity=0.5,
size_max=3,
template="simple_white",
title=title)
fig4.update_layout(coloraxis_colorbar=dict(
yanchor="top", y=0.5, x=1, ticks="outside", len=0.5))
# print (fig3)
# print (fig4)
joypy.joyplot(tmp, by="Channel", ylim='own', column="gene_exp")
plt.savefig("test2.png", bbox_inches='tight')
s2 = base64.b64encode(open("test2.png",
"rb").read()).decode("utf-8").replace("\n", "")
return fig3, fig4
def draft_scatter(year, df):
d = redraft_data(year, df)
good = d.loc[d.Pick_Analysis == 'Good Pick'].index.size
bad = d.loc[d.Pick_Analysis == 'Bad Pick'].index.size
WSPS = round(d.WSPS.sum(), 1)
fig = px.scatter(d,
x='Pk',
y='Redraft',
hover_data=['Player', 'Tm', 'College', 'WS', 'WSPS'],
color='Pick_Analysis',
title='Redraft for NBA Draft - Year ' + str(year) +
' <br>' + str(good) + ' Good Picks - ' + str(bad) +
' Bad Picks <br>' + str(WSPS) + ' Total WSPS for Draft')
fig.update_traces(mode='markers',
marker=dict(size=12,
line=dict(width=1, color='DarkSlateGrey')))
fig.update_layout(title={
'y': 0.9,
'x': 0.5,
'xanchor': 'center',
'yanchor': 'top'
})
fig.data[0]['marker'].update(color='#00CC99') #Good Pick
fig.data[1]['marker'].update(color='#CC0000') #Bad Pick
st.plotly_chart(fig)
def update_figure(selected, clickData):
def size(text):
if text == "fire_size":
return 60
elif text == "fire_count":
return 20
else:
return 20
def chart_title(text):
if text == "fire_size":
return "Acres Burned"
elif text == "fire_count":
return "Wildfire Count"
else:
return "FIRE"
def title(text):
if text == "fire_size" and clickData:
return 'Wildfire Acres Burned at ' + state_selected
elif text == "fire_count" and clickData:
return 'Wildfire Count at ' + state_selected
else:
return 'Wildfire ' + chart_title(selected)
state_df = df.groupby(['state', 'stat_cause_descr',
'fire_year']).sum().reset_index()
# state_selected = 'CA'
if clickData:
state_selected = clickData['points'][0]['text']
cause_data = state_df[state_df['state'] == state_selected]
else:
cause_data = df.groupby(['stat_cause_descr',
'fire_year']).sum().reset_index()[[
'fire_size', 'fire_year',
'stat_cause_descr', 'fire_count'
]]
if selected is None:
selected = 'fire_size'
fig = px.scatter(cause_data,
x="fire_year",
y="stat_cause_descr",
color="stat_cause_descr",
size=selected,
size_max=size(selected),
labels=dict(stat_cause_descr='', fire_year=''),
range_x=[1991, 2018],
title={
'text': title(selected),
'yanchor': 'top',
'x': 0.5,
'y': 0.9
},
template='plotly_white',
color_discrete_sequence=G10).for_each_trace(
lambda t: t.update(name=''))
return (fig)
def make_figure(x_selected, color_selected):
fig1 = px.scatter(
df,
x=x_selected,
y="SRR",
trendline="ols",
hover_name="FacilityInfo",
# height=1000,
opacity=1,
color=color_selected)
fig2 = px.histogram(
df,
# orientation="h",
x=color_selected,
y="SRR",
histfunc="avg",
color=color_selected,
hover_name="FacilityInfo"
# height=1000
).update_xaxes(categoryorder="mean ascending")
fig3 = px.histogram(
df,
# orientation="h",
x=color_selected,
y=x_selected,
histfunc="avg",
color=color_selected,
hover_name="FacilityInfo"
# height=1000
).update_xaxes(categoryorder="mean ascending")
return fig1, fig2, fig3
def plot_kmeans(nclust, weekrange, flagtypes, coronatopic, subr20):
filtered = df_subm.copy()
filtered = filtered[(filtered['week'].between(*weekrange))]
filtered['ISFLAG'] = filtered[flagtypes].copy().sum(axis=1)
filtered = filtered[filtered['ISFLAG']>0]
if coronatopic=="yes":
filtered = filtered[filtered['subm_covid']]
if subr20 is not None:
filtered = filtered[filtered.subreddit.str.contains('|'.join(subr20))]
### Run cluster analysis
if nclust>1:
X = filtered[['PC01', 'PC02', 'PC03', 'PC04', 'PC05']]
cluster = MiniBatchKMeans(n_clusters=nclust, batch_size=1000)
cluster.fit(X)
filtered['cluster'] = (cluster.predict(X)+1).astype(str)
### Build plot
fig = px.scatter(
filtered,
x='PC01', y='PC02',
color='cluster',
hover_data=['subm_title'],
opacity=0.75)
fig.update_traces(marker=dict(size=5))
### Keyword table
cw=[]
for cl in range(1,nclust+1):
SCL = filtered.subm_title[filtered.cluster==str(cl)]
cw.append({'cluster':cl, 'submissions':SCL.shape[0],'kewywords': str(cluster_commonwords(SCL,20)) })
return fig, generate_table(pd.DataFrame(cw))
def plot_trades_length_overview(df_trades, x='trade_len', y='gross_returns'):
''' Plot visual insight for labels on x variable (default "trade_len"):
1) histogram with count of x
2) histogram with x vs average y (default "gross_returns")
3) individual trades x vs y
Takes as an input df_trades from stratgy pnl, with x and y being columns of df_trades
'''
max_trade_length = int(df_trades['trade_len'].max())
hist_trade_length = px.histogram(df_trades, x=x, color='labels', title=f'<b>{x}</b>')
avg = df_trades['trade_len'].mean() # average trade length
hist_trade_length.add_shape(type="line", yref='paper',
x0=avg, y0=0, x1=avg, y1=1,
line=dict(color="rgba(0, 0, 0, 0.5)",width=2, dash="dashdot")
)
hist_trade_length.show()
# Plot net returns (by length and average returns)
hist_ret_len = px.histogram(df_trades, x=x, y=y, histfunc='avg', color='labels', nbins=max_trade_length, title=f'<b>{y} by {x}</b>')
hist_ret_len.update_layout(yaxis=dict(tickformat=',.3%'))
hist_ret_len.show()
# Plot individual trades vs trade length
avg_net_by_length = df_trades.groupby('trade_len')['gross_returns'].mean()
ret_len_scatter = px.scatter(df_trades, x=x, y=y, color=df_trades['labels'].astype('str'), opacity=0.3, title=f'<b>{y} single trades</b>')
ret_len_scatter.add_trace(go.Scatter(x=avg_net_by_length.index, y=avg_net_by_length.values, mode='lines', name='Average'))
ret_len_scatter.update_layout(yaxis=dict(tickformat=',.3%'))
ret_len_scatter.show()
def make_scatter(ScatY, ScatX, Size):
# new_df = df[['Indicator'] + Province_Select]
# print(new_df.loc[new_df['Indicator'] == str(ScatY)][Province_Select])
print(ScatX, ScatY, Size)
plotx = df.loc[df['Indicator'] == ScatX][provinces].values
ploty = df.loc[df['Indicator'] == ScatY][provinces].values
plotsize = df.loc[df['Indicator'] == Size][provinces].values
print(plotx[0], ploty[0], plotsize[0])
fig = px.scatter(
x=plotx[0].tolist(
), #df.loc[df['Indicator'] == ScatX][provinces].values,
y=ploty[0].tolist(
), #df.loc[df['Indicator'] == ScatY][provinces].values,
color=provinces,
size=plotsize[0])
fig.update_layout(
title=ScatX + ' by ' + ScatY,
xaxis_title=ScatX,
yaxis_title=ScatY,
xaxis_tickangle=-45,
)
return fig
def visualize_tsne(model_path, out_dir, data='guardian', data_slice=None, perplexity=30, n_iter=1000, verbose=0):
model_name = model_path.split('/')[-1]
model_path = os.path.expanduser(model_path)
vocab, X = get_X(model_path)
X = X[:data_slice]
vocab = vocab[:data_slice]
X_embedded = get_embedded_X(X, perplexity, n_iter, verbose)
df = pd.DataFrame(X_embedded, index=vocab[:data_slice], columns=['x', 'y'])
df_user_categories = pd.read_csv('~/jp-data-analysis/data/user_categories/user_most_commented_category.csv')
df['author_id'] = df.index
df.author_id = df.author_id.astype('int64')
df_visualize = df.merge(df_user_categories, on='author_id', how='left')
filename = model_name.replace('.txt', '').replace('.', '-') + '_visualization_'
# make seaborn visualization
sns.set_palette("pastel")
ax = sns.scatterplot(x="x", y="y", hue="category", data=df_visualize, alpha=0.6)
plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)
path_to_file = os.path.join(out_dir, filename + 'seaborn.pdf')
save_to_pdf(os.path.expanduser(path_to_file), ax)
print('PDF Visualization can be found here: ', path_to_file)
# make plotly visualization
figure = px.scatter(df_visualize, x="x", y="y", color="category")
path_to_file = os.path.join(out_dir, filename + 'plotly.html')
plotly.offline.plot(figure, filename=os.path.expanduser(path_to_file))
print('Interactive Visualization can be found here: ', path_to_file)
def run_model(n_click, reward_figure, epsilon_value, init_q_value, algo_type):
print("Running run_model task")
epochs = 1000
if n_click <= 0:
data = {'epoch': [], 'avg_reward': []}
df = pd.DataFrame(data)
else:
#result = k_arm_bandit.delay(hdf_file_path, reward_figure, epochs, epsilon_value,init_q_value,algo_type)
dset, avg_reward, q_values, count_values = run_e_greedy_bandit(
reward_figure, epochs, epsilon_value, init_q_value, algo_type)
x = [i for i in range(len(dset))]
data = {'epoch': x, 'avg_reward': dset}
df = pd.DataFrame(data)
#fig = px.scatter(df,x='epoch',y='avg_reward')
return px.scatter(df, x='epoch', y='avg_reward', height=700)
print('')
print("Done running model")
def make_figure(ns, nb, antibody_selection, g):
tmp = df.copy()
tmp['gene_exp'] = get_exp_gene(g)
AB1 = antibody_selection[0]
AB2 = antibody_selection[1]
tmp[AB1] = antibody_df.loc[AB1]
tmp[AB2] = antibody_df.loc[AB2]
title = "Number of cells<br> %s" % (str(
tmp["Channel"].value_counts().to_json()).replace(",", "<br>"))
fig1 = px.scatter(
tmp,
x=AB1,
y=AB2,
color='gene_exp',
symbol="Channel",
hover_data=['barcodekey', 'n_genes', 'n_counts', 'louvain_labels'],
opacity=0.5,
size_max=3,
template="simple_white",
title=title)
fig1.update_layout(coloraxis_colorbar=dict(
yanchor="top", y=0.5, x=1, ticks="outside", len=0.5))
fig2 = px.scatter(
tmp,
x="UMAP1",
y="UMAP2",
color='gene_exp',
symbol="Channel",
hover_data=['barcodekey', 'n_genes', 'n_counts', 'louvain_labels'],
opacity=0.5,
size_max=3,
template="simple_white",
title=title)
fig2.update_layout(coloraxis_colorbar=dict(
yanchor="top", y=0.5, x=1, ticks="outside", len=0.5))
joypy.joyplot(tmp, by="Channel", ylim='own', column="gene_exp")
plt.savefig("test.png", bbox_inches='tight')
s2 = base64.b64encode(open("test.png",
"rb").read()).decode("utf-8").replace("\n", "")
return fig1, fig2, [
html.Img(id="plot", src="data:image/png;base64,%s" % (s2))
]
def make_figure(x, y, color, facet_col, facet_row, type_transfer, xaxis_type,
yaxis_type, filter_estate, filter_state, price_slider,
area_slider, marginal_y, marginal_x):
# filter transfer type - Buy, Rent
filtered_df = df
if type_transfer:
filtered_df = filtered_df[filtered_df['type_transferType'].isin(
type_transfer)]
# filter estate type - Apartment, Office, House
if filter_estate:
filtered_df = filtered_df[filtered_df['type_estateType'].isin(
filter_estate)]
# filter state - Bundesland
if filter_state:
filtered_df = filtered_df[
filtered_df['localization_address_state'].isin(filter_state)]
if price_slider:
filtered_df = filtered_df[
(filtered_df['priceInformation_primaryPrice'] >= price_slider[0]) &
(filtered_df['priceInformation_primaryPrice'] <= price_slider[1])]
if area_slider:
filtered_df = filtered_df[
(filtered_df['area_areaRangeFrom'] >= area_slider[0])
& (filtered_df['area_areaRangeFrom'] <= area_slider[1])]
# Log Axis
if xaxis_type == "Linear":
log_x = False
else:
log_x = True
if yaxis_type == "Linear":
log_y = False
else:
log_y = True
output_price = 'Price from {} to {}'.format(price_slider[0],
price_slider[1])
output_area = 'Area from {} to {}'.format(area_slider[0], area_slider[1])
chart1 = px.scatter(
filtered_df,
x=x,
y=y,
color=color,
facet_col=facet_col,
facet_row=facet_row,
log_x=log_x,
log_y=log_y,
marginal_y=marginal_y,
marginal_x=marginal_x,
height=700,
)
result = [chart1, output_price, output_area]
return result
def make_figure(x, y, color):
return px.scatter(
tourneyGames,
x=x,
y=y,
color=color,
height=700,
)
def test_complex_scatter_plot(self):
gapminder = px.data.gapminder()
gapminder2007 = gapminder.query("year == 2007")
px.scatter(gapminder,
x="gdpPercap",
y="lifeExp",
size="pop",
size_max=60,
color="continent",
hover_name="country",
animation_frame="year",
animation_group="country",
log_x=True,
range_x=[100, 100000],
range_y=[25, 90],
labels=dict(pop="Population",
gdpPercap="GDP per Capita",
lifeExp="Life Expectancy"))
def generate_scatter(x_grade, y_grade):
"""Generate a scatter component."""
return dcc.Graph(id='scatter',
figure=px.scatter(
RECORDS,
x=x_grade,
y=y_grade,
color='academic_degree',
))
def make_figure(x, y, color, facet_col, facet_row):
return px.scatter(
df,
x=x,
y=y,
color=color,
facet_col=facet_col,
facet_row=facet_row,
height=700)
def page_2(year_select):
fig_vent_temp = px.scatter(tempe_climat,
title='Vitesse du vent maximale/Temperature',
x='Température_Moy_(°C)',
y="Vitesse maximale du vent",
color="Region",
size='nb_catnat',
animation_frame="Année",
hover_name="Region",
log_x=True,
size_max=55,
range_x=[10, 20],
range_y=[90, 160])
fig_precip_temp = px.scatter(
tempe_climat,
title='Hauteur de précipitation (en mm)/Temperature',
x='Température_Moy_(°C)',
y="Hauteur des precipitations",
color="Region",
size='nb_catnat',
animation_frame="Année",
hover_name="Region",
log_x=True,
size_max=55,
range_x=[10, 20],
range_y=[370, 1250])
fig_soleil_temp = px.scatter(
tempe_climat,
title='Ensoleillement (en heures)/Temperature',
x='Température_Moy_(°C)',
y="Heures d'ensoleillement",
color="Region",
size='nb_catnat',
animation_frame="Année",
hover_name="Region",
log_x=True,
size_max=55,
range_x=[10, 20],
range_y=[900, 3700])
return fig_vent_temp, fig_precip_temp, fig_soleil_temp
def make_figure(x, y, color, facet_col, facet_row):
return px.scatter(
tips,
x=x,
y=y,
color=color,
facet_col=facet_col,
facet_row=facet_row,
height=700,
)
def bigpictureplot(df, timescale=1000000):
df = df[['function', 'packet', 'llc', 'anomalous', 'time', 'board']]
df.drop_duplicates(subset=['llc', 'anomalous'], inplace=True)
df.reset_index(drop=True, inplace=True)
df.loc[:, 'colours'] = np.where(df['anomalous'] == 0, 'blue', 'red')
df.loc[:, 'timescale'] = timescale
df.loc[:, 'time'] = df['time'] / df['timescale']
title = df['board'].astype('str').unique()[0]
fig = px.scatter(df, x='time', y='function', color='colours', hover_data=['llc'], title=title)
return fig
def make_figure(x, y, color, size, facet_col, facet_row):
return px.scatter(
data_read,
x=x,
y=y,
color=color,
size=size,
facet_col=facet_col,
facet_row=facet_row,
height=700,
)
def update_scatter_pente(input_value):
"""
Retourne un nuage de points en fonction de la valeur du menu déroulant
Args:
input_value: pente ou orientation
"""
if input_value == 'pente':
figure_pente = px.scatter(france, x='id', y=['pente', 'pente_optimum'])
figure_pente.layout.yaxis.title = Nom_colonnes['pente']
return figure_pente
if input_value == 'orientation':
orientation_pente = px.scatter(
france, x='id', y=['orientation', 'orientation_optimum'])
orientation_pente.layout.yaxis.title = Nom_colonnes['orientation']
return orientation_pente
print('type error')
return 'type error'
def update_image_src(values):
df_aux = df.copy()
select_mask = df_aux.Category.isin([s for s in values])
figure = px.scatter(df_aux.loc[select_mask, :],
x="Dim1",
y="Dim2",
log_x=False,
hover_name="index",
color="Category",
hover_data=["Prediction"] +
class_names).update_yaxes(hoverformat=".2f")
return figure
def make_figure(x, y, color, size, facet_col, facet_row):
return px.scatter(
tips,
x=x,
y=y,
color=color,
text="Architecture Name",
size=size,
facet_col=facet_col,
facet_row=facet_row,
height=700,
)
def generate_bubble_chart():
return px.scatter(px.data.gapminder(),
x="gdpPercap",
y="lifeExp",
animation_frame="year",
animation_group="country",
size="pop",
color="country",
hover_name="country",
log_x=True,
size_max=45,
range_x=[100, 100000],
range_y=[15, 90])
def app():
post = st.selectbox('Select Post!',['GK','DF','MF','FW'])
if post=='GK':
xa=st.selectbox('Select x-axis parameter!',list(GK.columns)[1:])
ya=st.selectbox('Select y-axis parameter!',list(GK.columns)[1:])
fig=px.scatter(GK,x=xa,y=ya,color='web_name')
st.write(fig)
elif post=='DF':
xa=st.selectbox('Select x-axis parameter!',list(DF.columns)[1:])
ya=st.selectbox('Select y-axis parameter!',list(DF.columns)[1:])
fig=px.scatter(DF,x=xa,y=ya,color='web_name')
st.write(fig)
elif post=='MF':
xa=st.selectbox('Select x-axis parameter!',list(MF.columns)[1:])
ya=st.selectbox('Select y-axis parameter!',list(MF.columns)[1:])
fig=px.scatter(MF,x=xa,y=ya,color='web_name')
st.write(fig)
elif post=='FW':
xa=st.selectbox('Select x-axis parameter!',list(FW.columns)[1:])
ya=st.selectbox('Select y-axis parameter!',list(FW.columns)[1:])
fig=px.scatter(FW,x=xa,y=ya,color='web_name')
st.write(fig)
def make_figure(color):
print('ccc ', color)
if color == None:
my_color = None
else:
my_color = data1[color]
return px.scatter(
components,
x=0,
y=1,
color=my_color,
height=700,
)
def orders_items(self, df1, df2):
dff = pd.concat([df1, df2])
dff.amount = dff.amount.fillna(0)
return px.scatter(
dff,
color="featured_category_id",
y="offers",
x="days_as_user",
size='amount',
template="no_background",
color_discrete_map=self.color_dict,
title='Orders for # of Items',
)
def scatter_nba_clusters(df, title, hover_data):
fig = px.scatter(df,
x='Cluster_x',
y='Cluster_y',
color='Cluster',
title=title,
hover_data=hover_data)
fig.update_traces(mode='markers',
marker=dict(size=8,
opacity=.8,
line=dict(width=1, color='DarkSlateGrey')))
#fig.show()
st.plotly_chart(fig)
def scatter1_plot(df, x, y):
'''
Generate the plot.
'''
figure = go.Figure(
px.scatter(df,
x=x,
y=y,
color="Gender",
trendline="ols",
marginal_x="violin",
marginal_y="violin"))
return dcc.Graph(id='scatter_1', figure=figure)
def games_rating_scatter(df):
df['player_rating'] = df['player_name'] + ' - ' + df['rating'].astype(
'str')
fig = px.scatter(df.loc[df.games > 10],
x='games',
y='rating',
color='preferredposition',
hover_name='player_rating',
hover_data=['club_name', 'nation_name'],
title='Games Played & Player Rating')
fig.update_traces(marker=dict(
opacity=.8, size=10, line=dict(width=1, color='DarkSlateGrey')))
st.plotly_chart(fig)
