def make_annotations(pos, text, font_size=10, font_color='rgb(250,250,250)'): L=len(pos) if len(text)!=L: raise ValueError('The lists pos and text must have the same len') annotations = go.Annotations() for k in range(L): annotations.append( go.Annotation( text=labels[k], # or replace labels with a different list for the text within the circle x=pos[k][0], y=2*M-position[k][1], xref='x1', yref='y1', font=dict(color=font_color, size=font_size), showarrow=False) ) return annotations
def create_annotated_heatmap(x=None, y=None, z=None): data = go.Heatmap(z=z, x=x, y=y, colorscale='Viridis') annotations = go.Annotations() for n, row in enumerate(z): for m, val in enumerate(row): annotations.append(go.Annotation(text=str(z[n][m]), x=x[m], y=y[n], xref='x1', yref='y1', showarrow=False)) fig = go.Figure(data=go.Data([data])) fig['layout'].update( annotations=annotations, xaxis=go.XAxis(ticks='', title='y_pred', side='bottom'), yaxis=go.YAxis(ticks='', title='y_true', ticksuffix=' '), # ticksuffix is a workaround to add a bit of padding autosize=False ) return json.dumps(fig, cls=plotly.utils.PlotlyJSONEncoder)
def update_graph4(product_selected1, product_selected2, product_selected3): z = confusion_matrix(y_test, y_pred) trace15 = go.Heatmap(z=z, x=['0', '1'], y=['1', '0'], colorscale=["#ab6d41", "#ffb785"]) xx = [0, 1] yy = [1, 0] annotations = go.Annotations() for n, row in enumerate(z): for m, val in enumerate(row): annotations.append( go.Annotation(text=str(z[n][m]), x=xx[m], y=yy[n], xref='x1', yref='y1', showarrow=False)) return { 'data': [trace15], 'layout': go.Layout( font=dict(family="Arial Narrow, sans-serif", color="black", size=16), annotations=annotations, width=400, height=400, autosize=False, showlegend=False, yaxis=dict(tickmode='array', tickvals=[-0.5, 0, 0.5, 1, 1.5], ticktext=['', 'Self-harm', '', 'No<br>self-harm', '']), xaxis=dict(tickmode='array', tickvals=[-0.5, 0, 0.5, 1, 1.5], ticktext=['', 'No self-harm', '', 'Self-harm', '']), title='<b>Confusion Matrix</b>', yaxis_title_text='<b>actual</b>', xaxis_title_text='<b>predicted</b>', paper_bgcolor='#F5F5F7') }
def make_annotations(pos, info, font_size=8, font_color='rgb(0,0,0)'): L = len(pos) if len(info) != L: raise ValueError( 'make_annotations()::The lists pos and info must have the same len' ) annotations = go.Annotations() for k in range(L): item = go.Annotation( text=info[k], # text to be shown within the node x=pos[k][0], y=pos[k][1], xref='x1', yref='y1', font=dict(color=font_color, size=font_size), showarrow=False) annotations.append(item) return annotations
def make_annotations(pos, text, font_size=14, font_color='#fff'): if len(text) != L: raise ValueError('The lists pos and text must have the same len') labels = go.Annotations() for k in pos: labels.append( go.Annotation( text=annotations[vertex_to_i[k]], x=pos[k][0], y=2 * M - position[k][1], xref='x1', yref='y1', font=dict(color=font_color, size=font_size), showarrow=False, bgcolor='#6175c1', bordercolor='#c7c7c7', borderwidth=1, borderpad=2, ), ) return labels
def MakeAnnotations(positions, texts, font_size=10, font_color='rgb(250,250,250)'): posLength = len(positions) textLength = len(texts) if (posLength != textLength): raise ValueError('Position and texts mismatch.') annotations = objs.Annotations() for k in range(posLength): currentColor = font_color currentText = texts[k] if (texts[k] == "None"): currentText = "X" currentColor = "red" annotations.append( objs.Annotation(text=currentText, x=positions[k][0], y=positions[k][1], xref='x1', yref='y1', font=dict(color=currentColor, size=font_size), showarrow=False)) return annotations
# Sums the Global sales of a game's genre and platform, and transforms # it into a matrix for the heatmap sales_df = games[['Genre', 'Platform', 'Global_Sales']] Sales = sales_df.groupby(['Genre', 'Platform']).sum().unstack(fill_value=0) # Average sales ṕer title Popularity = Sales.values / Titles.values Popularity = np.nan_to_num(Popularity) Popularity = np.round(Popularity, 2) # Extracts the labels for the legend genres = list(Titles.index.values) platforms = list(Titles.columns.values) # Label of heatmap cells annotations = go.Annotations() for i, row in enumerate(Sales.values): for j, val in enumerate(row): annotations.append( go.Annotation(text=str(Popularity[i][j]), x=platforms[j], y=genres[i], xref='x1', yref='y1', showarrow=False, font={ 'size': 11, 'color': 'white' } if Popularity[i][j] < 4.5 else { 'size': 11, 'color': 'black'
def plot_stacked_barchart_cath(stats_df, title, plot_out=None): plot_dict = {} for cath in np.unique(stats_df['cath_topology']): plot_dict[cath] = {} for dataset in np.unique(stats_df['dataset']): plot_dict[cath]['Set ' + str(dataset)] = len(stats_df.query('cath_topology == @cath and dataset == @dataset')) plot_df = pd.DataFrame(plot_dict) plot_df_relative = plot_df.apply(lambda x: x/np.sum(x), axis=1) plot_df.loc['Total'] = plot_df.sum(axis=0).tolist() plot_df_relative.loc['Total'] = plot_df.loc['Total'] / plot_df.loc['Total'].sum(axis=0) #add bar for every group == cath data = [] for cath in plot_df.columns: data.append( go.Bar( x=plot_df_relative.index.tolist(), y=plot_df_relative[cath], showlegend=True, name=cath ) ) #add annotation for every bar y=0 annotations_list = [] for cath in plot_df.columns: y += plot_df_relative[cath]['Total'] for dataset in plot_df.index.tolist(): annotations_list.append( go.Annotation( x=dataset, y=y-0.1, text=str(plot_df[cath][dataset]), showarrow=False, font=dict(color='#ffffff') ) ) plot = { "data": data, "layout": go.Layout( barmode="stack", title=title, yaxis=dict( title="Proportion of CATH classes", exponentformat="e", showexponent='All' ), annotations=go.Annotations(annotations_list), legend=dict(orientation="h"), font=dict(size=16) ) } if title=="": plot['layout']['margin']['t'] = 10 plotly_plot(plot, filename=plot_out, auto_open=False)
def plot_scatter(apc_mat, ec_mat, plot_file): indices_i, indices_j = np.triu_indices(apc_mat.shape[0], k=1) apc = apc_mat[indices_i, indices_j] ec = ec_mat[indices_i, indices_j] text = [ "i: {0}<br>j: {1}<br>apc:{2}<br>ec:{3}".format(i, j, apc_mat[i, j], ec_mat[i, j]) for i, j in zip(indices_i, indices_j) ] scatter_data = go.Scatter(x=apc, y=ec, mode='markers', marker=dict(color="black"), text=text, showlegend=False) diagonal = go.Scatter(x=[0, np.max(list(apc) + list(ec))], y=[0, np.max(list(apc) + list(ec))], mode="lines", line=dict(color="darkgrey", width=4, dash="dot"), showlegend=False) pearson_r = pearsonr(apc, ec) data = [] data.append(diagonal) data.append(scatter_data) fig = { "data": data, "layout": go.Layout(hovermode="text", font=dict(size=24), yaxis=dict(title="Entropy Correction", exponentformat="e", showexponent='All', scaleratio=1, scaleanchor='x'), xaxis=dict(title="Average Product Correction", exponentformat="e", showexponent='All', scaleratio=1, scaleanchor='y'), annotations=go.Annotations([ go.Annotation(x=0.05, y=0.95, showarrow=False, text='Pearson r = {0}'.format( np.round(pearson_r[0], decimals=3)), font=dict(color="black", size=24), xref='paper', yref='paper') ]), margin=dict(t=10), width="550", height="500") } plotly_plot(fig, filename=plot_file, auto_open=False, show_link=False)
def plot_slot_avail(node_info, sec_since_epoch=None): """Plot "slot" availability. Parameters ---------- node_info : pandas.DataFrame sec_since_epoch : numeric, optional If provided, a date-time stamp will be displayed on the plots indicating the time the information displayed was generated. """ if DEBUG: t0 = time.time() print(">> plot_slot_avail") updated_at = "" if sec_since_epoch is not None: datetime_stamp, _ = make_datetime_stamp(sec_since_epoch, human_readable=True) updated_at = "Updated {}".format(datetime_stamp) slot_cores = np.array( [1, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 24, 28, 32, 40]) slot_mem = 2**np.arange(0, 11) cluster_node_info = OrderedDict([ ("ACI CPU", node_info.query('cluster == "aci"')), ( "CyberLAMP CPU-Only", node_info.query('(cluster == "cyberlamp") & (subgroup != "phi")'), ), ( "CyberLAMP Single-GPU", node_info.query('(cluster == "cyberlamp") & (subgroup != "phi")'), ), ]) for cluster_name, cni in cluster_node_info.items(): print(">> Working on {} cluster".format(cluster_name)) # TODO: cyberlamp has different CPUs available on the 1-GPU nodes for # GPU vs. non-GPU jobs. Knowing which cores are "taken" (or if it's # just a count, not particular cores that are dedicatd to job type) is # not possible as the pbsnodes parsing script stands (might need data # from another source about actual jobs that are running on each node # and what they call out). sc = slot_cores[slot_cores <= cni.cores.max()] sm = slot_mem[slot_mem <= cni.mem_tot.max()] if "gpu" in cluster_name.lower(): sg = 1 sc = sc[sc <= 20] sm = sm[sm <= 242] else: sg = 0 slots = compute_open_slots(node_info=cni, slot_cores=sc, slot_mem=sm, slot_gpus=sg) if np.all(slots <= 3): log_slots = slots else: with np.errstate(divide="ignore"): log_slots = np.log10(slots) neginf_mask = np.isinf(log_slots) neginf_fill_val = -np.max(log_slots) / 6 log_slots[neginf_mask] = neginf_fill_val min_slots = slots.min() max_slots = slots.max() lin_tickvals = np.array( [1, 3, 10, 30, 100, 300, 1e3, 3e3, 1e4, 3e4, 1e5, 3e5, 1e6], dtype=int) lin_tickvals = lin_tickvals[(lin_tickvals > min_slots) & (lin_tickvals < max_slots)] if np.all(slots <= 3): lin_tickvals = np.array([0, max_slots], dtype=int) tickvals = lin_tickvals else: if len(lin_tickvals) < 3: order = np.floor(np.log10(min_slots)) lin_tickvals = np.arange( 10**np.floor(np.log10(min_slots)), max_slots + 1, 10**order, dtype=int, ) lin_tickvals = np.array(sorted( set(lin_tickvals.tolist() + [max_slots])), dtype=int) tickvals = np.log10(lin_tickvals) lin_tickvals = sorted(set([0] + lin_tickvals.tolist())) tickvals = [neginf_fill_val] + tickvals.tolist() ticktext = ["{:d}".format(tv) for tv in lin_tickvals] text = np.empty_like(slots, dtype=str).tolist() for (core_i, cores), (mem_i, mem) in product(enumerate(sc), enumerate(sm)): if cores == 1: ct = "core" else: ct = "cores" val = slots[core_i, mem_i] if val == 1: slt = "slot" else: slt = "slots" text[core_i][ mem_i] = "{:d} {:s} & {:d} GiB mem : {:d} {:s}".format( cores, ct, mem, val, slt) # print(f"slots\n{slots}") # print(f"log_slots\n{log_slots}") # print(f"tickvals\n{tickvals}") trace = graph_objs.Heatmap( z=log_slots, x=[str(m) + " GiB" for m in sm], y=[str(sc[0]) + " core"] + [str(c) + " cores" for c in sc[1:]], zsmooth=False, xgap=1, ygap=1, colorscale="Viridis", colorbar=dict( outlinewidth=0, tickvals=tickvals, ticktext=ticktext, ), hoverinfo="text", text=text, ) data = [trace] layout = graph_objs.Layout( title="{} Job Slots Available".format(cluster_name), annotations=graph_objs.Annotations([ graph_objs.Annotation( x=0.5, y=1.07, showarrow=False, text=updated_at, xref="paper", yref="paper", ), ]), xaxis=dict(ticks="", nticks=36), yaxis=dict(ticks=""), ) fig = graph_objs.Figure(data=data, layout=layout) plotly.plot(fig, filename=cluster_name, auto_open=False) if DEBUG: print(">> plot_slot_avail:", time.time() - t0)
def update_graph(occupation_data, skill_data): """ Creates the 3D movable graph to visualize the common skills between respective roles """ input_data = occupation_data + skill_data input_data = [a.lower() for a in input_data] if input_data == []: fix_position_list = [ 'web developer', 'ict project manager', 'ict business analyst', 'software developer', 'ict network engineer', 'database administrator', 'ict consultant', 'data analyst', 'ict application developer', 'mobile app developer' ] for key, value in graph_visualization_data.items(): if key == 'nodes': nodes_new = [ k for k in value if k['id'].lower() in fix_position_list ] if key == 'links': links_new = [ k for k in value if k['source'].lower() in fix_position_list or k['target'].lower() in fix_position_list ] new_graph_data = {'nodes': nodes_new, 'links': links_new} G = nx.json_graph.node_link_graph(new_graph_data) pos = nx.spring_layout(G, dim=3) Xn_role = [pos[k][0] for k in pos if k in occupations] Yn_role = [pos[k][1] for k in pos if k in occupations] Zn_role = [pos[k][2] for k in pos if k in occupations] role_labels = [k for k in pos if k in occupations] Xn_skill = [pos[k][0] for k in pos if k in skills_graph] Yn_skill = [pos[k][1] for k in pos if k in skills_graph] Zn_skill = [pos[k][2] for k in pos if k in skills_graph] skill_labels = [k for k in pos if k in skills_graph] Xe = [] Ye = [] Ze = [] for e in G.edges(): Xe.extend([pos[e[0]][0], pos[e[1]][0], None]) Ye.extend([pos[e[0]][1], pos[e[1]][1], None]) Ze.extend([pos[e[0]][2], pos[e[1]][2], None]) trace_nodes_role = go.Scatter3d(x=Xn_role, y=Yn_role, z=Zn_role, mode='markers', marker=dict(size='18', symbol='dot', color='rgb(255,140,0)'), text=role_labels, hoverinfo='text') trace_nodes_skill = go.Scatter3d(x=Xn_skill, y=Yn_skill, z=Zn_skill, mode='markers', marker=dict(symbol='dot', color='rgb(33,188,235)'), text=skill_labels, hoverinfo='text') trace_edges = go.Scatter3d(mode='lines', x=Xe, y=Ye, z=Ze, line=dict(width=0.6, color='rgb(119,136,153)'), hoverinfo='none') axis = dict( showline=False, # hide axis line, grid, ticklabels and title zeroline=False, showgrid=False, showticklabels=False, showbackground=False, title='') layout_skill_graph = go.Layout( title="Skill tree for Jobs", titlefont=dict(color='white'), showlegend=False, scene=go.Scene( xaxis=go.XAxis(axis), yaxis=go.YAxis(axis), zaxis=go.ZAxis(axis), ), margin=dict(l=0, r=0, t=40, b=0), hovermode='closest', plot_bgcolor='#131827', paper_bgcolor='#131827', #set background color annotations=go.Annotations([ go.Annotation(showarrow=False, text="", xref='paper', yref='paper', x=0, y=0.1, xanchor='left', yanchor='bottom', font=go.Font(size=14)) ])) data = go.Data([trace_edges, trace_nodes_role, trace_nodes_skill]) fig = go.Figure(data=data, layout=layout_skill_graph) return fig else: for key, value in graph_visualization_data.items(): if key == 'nodes': nodes_new = [k for k in value if k['id'].lower() in input_data] if key == 'links': links_new = [ k for k in value if k['source'].lower() in input_data or k['target'].lower() in input_data ] new_graph_data = {'nodes': nodes_new, 'links': links_new} G = nx.json_graph.node_link_graph(new_graph_data) pos = nx.spring_layout(G, dim=3) Xn_role = [pos[k][0] for k in pos if k in occupations] Yn_role = [pos[k][1] for k in pos if k in occupations] Zn_role = [pos[k][2] for k in pos if k in occupations] role_labels = [k for k in pos if k in occupations] Xn_skill = [pos[k][0] for k in pos if k in skills_graph] Yn_skill = [pos[k][1] for k in pos if k in skills_graph] Zn_skill = [pos[k][2] for k in pos if k in skills_graph] skill_labels = [k for k in pos if k in skills_graph] Xe = [] Ye = [] Ze = [] for e in G.edges(): Xe.extend([pos[e[0]][0], pos[e[1]][0], None]) Ye.extend([pos[e[0]][1], pos[e[1]][1], None]) Ze.extend([pos[e[0]][2], pos[e[1]][2], None]) trace_nodes_role = go.Scatter3d(x=Xn_role, y=Yn_role, z=Zn_role, mode='markers', marker=dict(size='18', symbol='dot', color='rgb(255,140,0)'), text=role_labels, hoverinfo='text') trace_nodes_skill = go.Scatter3d(x=Xn_skill, y=Yn_skill, z=Zn_skill, mode='markers', marker=dict(symbol='dot', color='rgb(33,188,235)'), text=skill_labels, hoverinfo='text') trace_edges = go.Scatter3d(mode='lines', x=Xe, y=Ye, z=Ze, line=dict(width=0.6, color='rgb(119,136,153)'), hoverinfo='none') axis = dict( showline=False, # hide axis line, grid, ticklabels and title zeroline=False, showgrid=False, showticklabels=False, showbackground=False, title='') layout_skill_graph = go.Layout( title="Skill tree for Jobs", titlefont=dict(color='white'), showlegend=False, scene=go.Scene( xaxis=go.XAxis(axis), yaxis=go.YAxis(axis), zaxis=go.ZAxis(axis), ), margin=dict(l=0, r=0, t=40, b=0), hovermode='closest', plot_bgcolor='#131827', paper_bgcolor='#131827', #set background color annotations=go.Annotations([ go.Annotation(showarrow=False, text="", xref='paper', yref='paper', x=0, y=0.1, xanchor='left', yanchor='bottom', font=go.Font(size=14)) ])) data = go.Data([trace_edges, trace_nodes_role, trace_nodes_skill]) fig = go.Figure(data=data, layout=layout_skill_graph) return fig
def plot_boxplot(statistics_dict, key, plot_out): methods=sorted(statistics_dict.keys()) data = [] annotations_list = [] max_value=-np.inf min_value=np.inf for method in methods: values = statistics_dict[method][key] proteins = statistics_dict[method]['protein'] target_neff = statistics_dict[method]['target neff'] sample_neff = statistics_dict[method]['sample neff'] box = go.Box( y=values, boxmean=True, pointpos=1.8, jitter=0.4, boxpoints='all', name=method, marker=dict(opacity=1), text=[proteins[i] + "<br>target neff: " + str(target_neff[i]) + "<br>sample neff: " + str(sample_neff[i]) for i in range(len(values))], hoverinfo='all', orientation='v', showlegend=False ) data.append(box) max_value = np.max([max_value, np.max(values)]) min_value = np.min([min_value, np.min(values)]) for method in methods: annotations_list.append( go.Annotation( x=method, y=max_value + (max_value-min_value)/10.0, text=str(len(statistics_dict[method][key])), showarrow=False ) ) plot = { "data": data, "layout": go.Layout( yaxis=dict( exponentformat='e', showexponent='All' ), annotations=go.Annotations(annotations_list), font=dict(size=18) ) } if key == "neff_difference": plot['layout']['title'] = "Neff Difference between original Pfam and synthetic alignment" plot['layout']['yaxis']['title'] = "Pfam Neff - synthetic Neff" if key == "mutation_rate": plot['layout']['title'] = "Mutation rate used for Sampling" plot['layout']['yaxis']['title'] = "mutation rate" plotly_plot(plot, filename=plot_out, auto_open=False)
def get_plotly_networkx_3d(self, varset="all", include_plotlyjs=False): import networkx as nx g, edge_labels = nx.Graph(), {} for i, (name, var) in enumerate(self.items()): #if i == 5: break if varset != "all" and var.varset != varset: continue g.add_node(var, name=name) for parent in var.get_parents(): #print(parent, "is parent of ", name) parent = self[parent] g.add_edge(parent, var) # TODO: Add getters! What about locked nodes! #i = [dep.node for dep in child.deps].index(task) #edge_labels[(task, child)] = " ".join(child.deps[i].exts) # Get positions for all nodes using layout_type. # e.g. pos = nx.spring_layout(g) #pos = getattr(nx, layout_type + "_layout")(g) #, scale=100000, iterations=30) pos = nx.spring_layout(g, dim=3) import plotly.graph_objs as go trace1 = go.Scatter3d(x=[], y=[], z=[], mode='lines', line=go.Line(width=2.0, color='#888'), #, dash="dot"), hoverinfo='none', ) for edge in g.edges(): x0, y0, z0 = pos[edge[0]] x1, y1, z1 = pos[edge[1]] trace1['x'] += [x0, x1, None] trace1['y'] += [y0, y1, None] trace1['z'] += [z0, z1, None] trace2 = go.Scatter3d( x=[], y=[], z=[], name='variable', marker=go.Marker(symbol='dot', size=10, #color=group, colorscale='Viridis', line=go.Line(width=2) ), text=[v.name for v in g], textposition='center', mode='markers+text', hoverinfo='text', hovertext=[v.mnemonics for v in g.nodes()], ) for node in g.nodes(): x, y, z = pos[node] trace2['x'].append(x) trace2['y'].append(y) trace2['z'].append(z) axis=dict(showbackground=False, showline=False, zeroline=False, showgrid=False, showticklabels=False, title='' ) layout = go.Layout( title="Abinit variables (3D visualization)", width=1000, height=1000, showlegend=False, scene=go.Scene( xaxis=go.XAxis(axis), yaxis=go.YAxis(axis), zaxis=go.ZAxis(axis), ), margin=go.Margin(t=100), hovermode='closest', annotations=go.Annotations([go.Annotation( showarrow=False, #text="Data source: <a href='http://bost.ocks.org/mike/miserables/miserables.json'>[1]</a>", text="Hello", xref='paper', yref='paper', x=0, y=0.1, xanchor='left', yanchor='bottom', font=go.Font(size=14), )]), ) data = go.Data([trace1, trace2]) fig = go.Figure(data=data, layout=layout) import plotly s = plotly.offline.plot(fig, include_plotlyjs=include_plotlyjs, output_type='div') return s
data = [go.Histogram(x=ingredients_count)] layout = layout = go.Layout( title='How many ingredients make up a dinner recipe?', xaxis=dict(title='Number of ingredients in each recipe'), yaxis=dict(title='Number of recipes with x number of ingredients'), bargap=0.1, bargroupgap=0.1, annotations=go.Annotations([ go.Annotation( x=0, y=0, showarrow=False, text='<a href="https://twitter.com/rikunert">@rikunert</a>', xanchor='left', xref='paper', yref='paper'), go.Annotation(x=1, y=0, showarrow=False, text='source: <a href="https://cookpad.com">cookpad</a>', xanchor='right', xref='paper', yref='paper') ])) fig = go.Figure(data=data, layout=layout) po.plot(fig, filename='file.html') #py.iplot(data, filename='basic histogram') # let's get an idea of how many times different ingredients actually occur ingredients_recipe = [r['ingredients'] for r in recipe_info] ingredients = [
showline=True, zeroline=True, mirror="ticks", ticks="inside", linewidth=2, tickwidth=2, zerolinewidth=2, ) bandlayout = go.Layout( width=700, height=500, title="Bands diagram", xaxis=bandxaxis, yaxis=bandyaxis, annotations=go.Annotations(annotations) ) bandfig = go.Figure(data=bandTraces + vlines, layout=bandlayout) plot_url = iplot(bandfig, filename="Bands") # In[14]: # plot DOS and bands together dosbandfig = make_subplots(rows=1, cols=2, shared_yaxes=True) # add the bands for btrace in bandTraces: dosbandfig.append_trace(btrace, 1, 1) # add vlines for specific k-points
def generate_comparison_plot(plot_data, data_keys, field_names=None): print(field_names) if field_names is None: field_names = data_keys ptitle = 'MegaQC Comparison Plot' plot_x = [] plot_y = [] plot_z = [] plot_col = [] plot_size = [] plot_names = [] annotations = go.Annotations([]) for s_name in plot_data: plot_names.append(s_name) try: plot_x.append(plot_data[s_name][data_keys['x']]) plot_y.append(plot_data[s_name][data_keys['y']]) except KeyError: print("Couldn't find key {} (available: {})".format(plot_data[s_name].keys(), data_keys)) try: plot_z.append(plot_data[s_name][data_keys['z']]) except KeyError: plot_z.append(None) try: plot_col.append(plot_data[s_name][data_keys['col']]) except KeyError: plot_col.append(None) try: plot_size.append(plot_data[s_name][data_keys['size']]) except KeyError: plot_size.append(None) # Colour with a colour scale markers = {} if not all([x == None for x in plot_col]): markers['color'] = plot_col markers['colorscale'] = 'Viridis' markers['showscale'] = True annotations.append(go.Annotation( text = field_names['col'], x = 1.02, y = 0.5, textangle= - 90, xref = 'paper', yref = 'paper', showarrow = False )) # Scale the marker size according to a variable if not all([x == None for x in plot_size]): smax = max([x for x in plot_size if type(x) is float]) smin = min([x for x in plot_size if type(x) is float]) srange = smax - smin if srange > 0: norm_plot_size = [] for x in plot_size: if type(x) is float: norm_plot_size.append((((x - smin)/srange)*35)+2) else: norm_plot_size.append(2) markers['size'] = norm_plot_size ptitle += '<br><span style="font-size:0.7rem">Marker Size represents "{}"</span>'.format(field_names['size']) plot_height = 600 if all([x == None for x in plot_z]): fig = go.Scatter( x = plot_x, y = plot_y, mode = 'markers', marker = markers, text = plot_names ) else: markers.update({'opacity':0.8}) fig = go.Scatter3d( x = plot_x, y = plot_y, z = plot_z, mode = 'markers', marker = markers, text = plot_names ) plot_height = 800 # Make the plot layout = go.Layout( title = ptitle, # For 2D plots xaxis = dict( title = field_names['x'] ), yaxis = dict( title = field_names['y'] ), # For 3D plots scene = dict( xaxis = dict( title = field_names['x'] ), yaxis = dict( title = field_names['y'] ), zaxis = dict( title = field_names['z'] ), ), annotations = annotations, height = plot_height ) plot_div = py.plot( go.Figure(data = [fig], layout = layout), output_type = 'div', show_link = False, config = dict( modeBarButtonsToRemove = [ 'sendDataToCloud', 'resetScale2d', 'hoverClosestCartesian', 'hoverCompareCartesian', 'toggleSpikelines' ], displaylogo = False ) ) return plot_div
def plot_scatter_comparison(title, x_axis_title, y_axis_title, mat_1, mat_2, plot_out, color_vector=None, qqplot=False): L = mat_1.shape[0] upper_triangular_indices = np.triu_indices(L, k=1) score_1 = mat_1[upper_triangular_indices] score_2 = mat_2[upper_triangular_indices] lin_reg_x = list( np.arange(np.min([np.min(score_1), np.min(score_2)]), np.max([np.max(score_1), np.max(score_2)]), 0.05)) slope, intercept, rvalue, pvalue, stderr = linregress(score_1, score_2) lin_reg_y = [intercept + slope * x for x in lin_reg_x] text = [ "i: " + str(i + 1) + ", j: " + str(j + 1) for i, j in zip( upper_triangular_indices[0], upper_triangular_indices[1]) ] if color_vector is not None: text = [ text[ij] + ", sum_nia * sum_njb: " + str(color_vector[ij]) for ij in range(len(text)) ] color_scale = cl.interp(cl.scales['3']['seq']['Reds'], 400) color_vector = [color_scale[i - 1] for i in color_vector] opacity = 1 else: color_vector = 'rgb(31,120,180)' opacity = 1 data = [] data.append( go.Scattergl(x=[ np.min([np.min(score_1), np.min(score_2)]), np.min([np.max(score_1), np.max(score_2)]) ], y=[ np.min([np.min(score_1), np.min(score_2)]), np.min([np.max(score_1), np.max(score_2)]) ], mode='lines', line=dict(color='lightgrey', width=3, dash='dash'), showlegend=False)) data.append( go.Scattergl(x=score_1, y=score_2, text=text, mode='markers', marker=dict(opacity=opacity, color=color_vector), hoverinfo="x+y+text", showlegend=False)) if qqplot: index_sorted_i = np.argsort(score_1) index_sorted_j = np.argsort(score_2) text_sorted = [ "i: " + str(i + 1) + ", j: " + str(j + 1) for i, j in zip(upper_triangular_indices[0][index_sorted_i], upper_triangular_indices[1][index_sorted_j]) ] data.append( go.Scattergl(x=sorted(score_1), y=sorted(score_2), text=text_sorted, mode='markers', marker=dict(color="rgb(255,127,0)"), hoverinfo="x+y+text", showlegend=False)) data.append( go.Scattergl( x=lin_reg_x, y=lin_reg_y, mode='lines', line=dict(color="black", width=4), #"rgb(166,206,227)"),#"rgb(51,160,44)"), showlegend=False)) plot = { "data": data, "layout": go.Layout(annotations=go.Annotations([ go.Annotation(x=np.percentile(lin_reg_x, 95), y=np.percentile(lin_reg_y, 95), showarrow=True, ax=30, ay=50, arrowcolor='black', arrowside="start", text='y = {0} + {1}x'.format( np.round(intercept, decimals=3), np.round(slope, decimals=3)), font=dict(color="black", size=18), xref='x1', yref='y1') ]), title=title, font=dict(size=18), yaxis1=dict( title=y_axis_title, exponentformat="e", showexponent='All', scaleratio=1.0, scaleanchor='x', ), xaxis1=dict(title=x_axis_title, exponentformat="e", showexponent='All', scaleratio=1.0, scaleanchor='y')) } plotly_plot(plot, filename=plot_out, auto_open=False)
def corrPlot( x, # 1D data vector or list of 1D dsata vectors y, # 1D data vector or list of 1D dsata vectors z=None, # optional colors for the lines names=None, # names of x, y (ex:['A', 'B'] maxdata=2000, # max # of points to plot above histogram (if too high, it will be slow) addCorr=True, # whether to add correlation statistics into plot (R2, spearmanR2, Pvals, & y=mx+b) addCorrLine=True, # whether to plot correlation line addXYline=False, # whether to plot y=x line text=None, # whether to add additional text to each point plot=True, # if false, just returns plotly json object title='Correlation', # title of plot xlbl='', # ylbl='', markersize=None, # either None or #. If None, will automatically determine best ): """ Plots x , y data and their trendline using plotly EX: plot diff between two series corrPlot(x, y, xlbl='A', ylbl='B', addCorr=False, addCorrLine=False, addXYline=True) """ #TODO: remove outliers # 1st convert t ndarray # 1st convert t ndarray if type(x) != np.ndarray: x = np.array(x) if type(y) != np.ndarray: y = np.array(y) # (1) get N if np.issubdtype(x.dtype, np.number): # given an np array x = np.atleast_2d(x) y = np.atleast_2d(y) N, Lx = x.shape else: # given a data array N = len(x) # (2) remove NaNs tmpx, tmpy = [], [] for n in range(N): bad = np.atleast_2d(np.isnan(x[n]) | np.isnan(y[n])) tmpx += [x[n][~bad[0]]] tmpy += [y[n][~bad[0]]] x = np.array(tmpx) y = np.array(tmpy) # (3) get Lx if np.issubdtype(x.dtype, np.number): # given an np array N, Lx = x.shape Lx = np.tile(Lx, N) else: # given a data array Lx = [len(l) for l in x] Ly = [len(l) for l in y] if Lx != Ly: raise ValueError('All x & y vectors must be same length!!!') # if data has too many points, remove some for speed Iplot = [ np.arange(Lx[n]) if Lx[n] < maxdata else np.random.choice( Lx[n], size=maxdata, replace=False) for n in range(N) ] if names is None: names = ['Line ' + str(i) for i in range(N)] if isinstance(names, str): names = [names] traces = [] # determine scatterpoint colors if z is not None: assert N == 1, 'So far coloring only works w/ 1 data series' if type(z) != np.ndarray: z = np.array(z) z = np.atleast_2d(z) cols = z showleg = False showscale = True line_col = ['black'] lg = [None] scattertext = ['z=%d' % (i) for i in range(Lx[0])] if text is None else text else: if N > 1: lg = names showleg = False cols = cl.scales[str(max(3, N))]['qual']['Set1'] else: lg = [None] showleg = True cols = ['blue'] line_col = cols showscale = False if text is None: scattertext = '' else: scattertext = text # scale markersize Lxp = np.min([max(Lx), maxdata]) if markersize is None: if Lxp > 5000: markersize = 1 elif Lxp > 2000: markersize = 2 elif Lxp > 1000: markersize = 3 elif Lxp > 200: markersize = 4 elif Lxp > 80: markersize = 5 elif Lxp > 25: markersize = 7 else: markersize = 9 scatPlot = [ go.Scatter(x=x[n][Iplot[n]], y=y[n][Iplot[n]], name=names[n], legendgroup=lg[n], mode='markers', opacity=.5, text=scattertext, marker={ 'size': markersize, 'color': cols[n], 'showscale': showscale, 'colorscale': 'Portland' }) for n in range(N) ] traces += scatPlot annots = [] if addCorr: for n in range(N): slope, intercept, R2, p_val, std_err = sp.stats.linregress( x[n], y[n]) R2sp, p_val_sp = sp.stats.spearmanr(x[n], y[n]) corrtext = 'Pearson [R2, P]=[%.2f,%.2f] <br> ' \ 'Spearman [R2, P]=[%.2f,%.2f] <br> ' \ 'y=%.2fx+%.2f' \ % (R2, p_val, R2sp, p_val_sp, slope, intercept) #if only 1 data record print stats on graph if N == 1: annots = go.Annotations([ go.Annotation(x=0.05, y=0.95, showarrow=False, text=corrtext, xref='paper', yref='paper') ]) if addCorrLine: x_rng = [np.min(x[0]), np.max(x[0])] dx_rng = x_rng[1] - x_rng[0] shift = .03 # shift from edges xc = np.array( [x_rng[0] + dx_rng * shift, x_rng[1] - dx_rng * shift]) yc = slope * xc + intercept corrline = [ go.Scatter(x=xc, y=yc, name=names[n] + ' corr', legendgroup=lg[n], showlegend=showleg, mode='lines', line={'color': line_col[n]}, hovertext=corrtext, hoverinfo='name+text') ] traces += corrline if addXYline: x_rng = [np.min(x[0]), np.max(x[0])] dx_rng = x_rng[1] - x_rng[0] shift = .03 # shift from edges xc = np.array([x_rng[0] + dx_rng * shift, x_rng[1] - dx_rng * shift]) xyline = [ go.Scatter(x=xc, y=xc, name='X=Y', showlegend=True, mode='lines', line={'color': 'black'}) ] traces += xyline showleg = False if N == 1 else True layout = go.Layout( title=title, annotations=annots, xaxis={'title': xlbl}, yaxis={'title': ylbl}, hovermode='closest', showlegend=showleg, ) fig = go.Figure(data=traces, layout=layout) return plotOut(fig, plot)
def main(): # Centrality for graph representation. centrality = Centrality.Centrality(Graph(), "../FacebookNetwork/dataset/SplitedData/train.edges", "../FacebookNetwork/dataset/SplitedData/val.edges", "../FacebookNetwork/dataset/SplitedData/test.edges", "../FacebookNetwork/dataset/SplitedData/neg_train.edges", "../FacebookNetwork/dataset/SplitedData/neg_val.edges", "../FacebookNetwork/dataset/SplitedData/neg_test.edges") centrality.arg.LoadEdgesData() betweenness = centrality.BetweenCentrality() closeness = centrality.ClosenessCentrality() eigenVec = centrality.EigenVector_Centrality() #PredictionModels, Split positive and negative data pos_train = DataReader.DataReader(Graph(), "../FacebookNetwork/dataset/SplitedData/train.edges", "../FacebookNetwork/dataset/SplitedData/val.edges", "../FacebookNetwork/dataset/SplitedData/test.edges", "../FacebookNetwork/dataset/SplitedData/neg_train.edges", "../FacebookNetwork/dataset/SplitedData/neg_val.edges", "../FacebookNetwork/dataset/SplitedData/neg_test.edges") neg_train = DataReader.DataReader(Graph(), "../FacebookNetwork/dataset/SplitedData/train.edges", "../FacebookNetwork/dataset/SplitedData/val.edges", "../FacebookNetwork/dataset/SplitedData/test.edges", "../FacebookNetwork/dataset/SplitedData/neg_train.edges", "../FacebookNetwork/dataset/SplitedData/neg_val.edges", "../FacebookNetwork/dataset/SplitedData/neg_test.edges") pos_val = DataReader.DataReader(Graph(), "../FacebookNetwork/dataset/SplitedData/train.edges", "../FacebookNetwork/dataset/SplitedData/val.edges", "../FacebookNetwork/dataset/SplitedData/test.edges", "../FacebookNetwork/dataset/SplitedData/neg_train.edges", "../FacebookNetwork/dataset/SplitedData/neg_val.edges", "../FacebookNetwork/dataset/SplitedData/neg_test.edges") neg_val = DataReader.DataReader(Graph(), "../FacebookNetwork/dataset/SplitedData/train.edges", "../FacebookNetwork/dataset/SplitedData/val.edges", "../FacebookNetwork/dataset/SplitedData/test.edges", "../FacebookNetwork/dataset/SplitedData/neg_train.edges", "../FacebookNetwork/dataset/SplitedData/neg_val.edges", "../FacebookNetwork/dataset/SplitedData/neg_test.edges") #Load Edges for each graph pos_train.LoadEdgesData() neg_train.LoadEdgesData() pos_val.LoadEdgesData() neg_val.LoadEdgesData() #Split into negative and positive files. pos_train.GenerateTrain() #we will get pos and neg files. pos_val.GenerateValidation() #we will get pos and neg files. #LabelData into dictionnary for files pos_train.LoadGeneratedFiles(pos_train.fluxTr) neg_train.LoadGeneratedFiles(neg_train.fluxTr_neg) pos_val.LoadGeneratedFiles(pos_val.fluxV) neg_val.LoadGeneratedFiles(neg_val.fluxVal_neg) X_train_pos = pos_train.LabelData() X_train_neg = neg_train.LabelData() X_val_pos = pos_val.LabelData() X_val_neg = neg_val.LabelData() print('----------------- Spliting and labeling data X & Y------------------------- \n') Y_train_pos = np.full(shape=(X_train_pos.shape[0],1), fill_value=1) Y_train_neg = np.full(shape=(X_train_neg.shape[0],1), fill_value=0) Y_val_pos = np.full(shape=(X_val_pos.shape[0],1), fill_value=1) Y_val_neg = np.full(shape=(X_val_neg.shape[0],1), fill_value=0) X_train = np.append(X_train_pos,X_train_neg,axis=0) y_train = np.append(Y_train_pos,Y_train_neg,axis=0) X_val = np.append(X_val_pos, X_val_neg, axis=0) y_val = np.append(Y_val_pos, Y_val_neg, axis=0) np.random.shuffle(X_train) np.random.shuffle(y_train) np.random.shuffle(X_val) np.random.shuffle(y_val) print('----------------- Done ------------------------- \n ') print('\n----------------- Linear Model Predictions ------------------------- \n') reg = linear_model.Ridge (alpha = .5) reg.fit(X=X_train[:-1],y=y_train[:-1]) reg.predict(X_train[-1:]) len(reg.predict(X_val)) np.mean((reg.predict(X_val) - y_val)**2) print('Log loss ',log_loss(y_val,reg.predict(X_val))) print('\n ----------------- Linear LinearRegression ------------------------- \n') regressor = LinearRegression() regressor.fit(X_train, y_train) print('Slope',regressor.intercept_) y_pred = regressor.predict(X_val) df = pd.DataFrame({'Actual': y_val.flatten(), 'Predicted': y_pred.flatten()}) #print(df) print('\n ----------------- SVM ------------------------- \n') clf_svm = svm.SVC() clf_svm.fit(X=X_train[:-1],y=y_train[:-1]) print(log_loss(y_val,clf_svm.predict(X_val))) print('\n ------------------------ Implementing Kernel SVM | Polynomial ------------------------ \n') svclassifier2 = svm.SVC(kernel='poly', degree=8,C=150) # this is the degre of the polynomial. svclassifier2.fit(X_train, y_train) #making prediction y_predp = svclassifier2.predict(X_val) #evaluating the poly svm print(confusion_matrix(y_val, y_predp)) print(classification_report(y_val, y_predp)) print('\n --------------------------- Implementing Kernel SVM | Linear -------------------------- \n') svclassifier1 = svm.SVC(kernel='linear') svclassifier1.fit(X_train, y_train) #Make predict y_pred = svclassifier1.predict(X_val) #Evaluating the Algorithm print(svclassifier1.score(X_val, y_val)) print(confusion_matrix(y_val,y_pred)) print(classification_report(y_val,y_pred)) print('\n ------------------------ Implementing Kernel SVM | Sigmoid ------------------------ \n') svclassifier4 = svm.SVC(kernel='sigmoid') svclassifier4.fit(X_train, y_train) #making predict y_preds = svclassifier4.predict(X_val) #Evaluating Algorithm print(confusion_matrix(y_val, y_preds)) print(classification_report(y_val, y_preds)) print('\n------------------------ Implementing Kernel SVM | Gaussian ------------------------\n') svclassifier3 = svm.SVC(kernel='rbf') svclassifier3.fit(X_train, y_train) #making predit y_predg = svclassifier3.predict(X_val) #Evaluating Algorithm print(confusion_matrix(y_val, y_predg)) print(classification_report(y_val, y_predg)) print('\n ------------------------ KNN ------------------------ \n') sc = StandardScaler() sc.fit(X_train) X_train = sc.transform(X_train) X_val = sc.transform(X_val) print('Value for K Math.sqrt(len of X_train) -------> ',math.sqrt(len(X_train))) print("Please wait for graph representation ....") accuracy = [] #We agregate the Accuracy averages for 18 neighbors. f1_scores = [] #Metrics ... index = range(3,81) for i in index: classifier = KNeighborsClassifier(n_neighbors = i, metric= 'euclidean', weights='uniform', leaf_size= 30) #27 classifiers classifier.fit(X_train, y_train) y_pred = classifier.predict(X_val) # Predict the class labels for the provided data conf_matrix = confusion_matrix(y_val, y_pred) # What we predit <VS> what actually is on test data. res = (conf_matrix[0, 0] + conf_matrix[1, 1]) / sum(sum(conf_matrix)) # Calculate Accuracy of our predit. accuracy.append(res) f1_scores.append(list(zip(y_val, y_pred))) print('In the range of 3 to 39 we have this values of accuracy') print(accuracy) # Evaluate the Model. print('We evaluate the Matrix of Confusion') mc = confusion_matrix(y_val, y_pred) print(classification_report(y_val, y_pred)) print(mc) # Graph representation plt.figure(figsize=(10, 6), num='Knn Algorithm Facebook Network Prediction') plt.plot(index, accuracy, color='green', linestyle='dashed', marker='o', markerfacecolor='blue', markersize=10) plt.title('Accuracy ratio according to K values') plt.xlabel('K Values') plt.ylabel('Accuracy average') plt.show() #LoadLabels. nodesLabels = [] edges = [] #nodesLabels = [nodesLabels.append(eachEgo['name']) for eachEgo in centrality.arg.graph.vs] for eachEgo in centrality.arg.graph.vs: nodesLabels.append(eachEgo['name']) #edges = [edges.append(edge.tuple) for edge in centrality.arg.graph.es] #ça marche pas je ne sais pas pourquoi. for e in centrality.arg.graph.es: edges.append(e.tuple) layout = centrality.arg.graph.layout('kk', dim=3) #Prepare coordinates for Nodes and Edges. Xn=[layout[n][0] for n in range(len(centrality.arg.graph.vs))]# x-coordinates of nodes Yn=[layout[n][1] for n in range(len(centrality.arg.graph.vs))]# y-coordinates Zn=[layout[n][2] for n in range(len(centrality.arg.graph.vs))]# z-coordinates #Lists of edges. Xe=[] Ye=[] Ze=[] for e in edges: Xe+=[layout[e[0]][0],layout[e[1]][0], None]# x-coordinates of edge ends Ye+=[layout[e[0]][1],layout[e[1]][1], None] Ze+=[layout[e[0]][2],layout[e[1]][2], None] trace1=go.Scatter3d(x=Xe, y=Ye, z=Ze, mode='lines', line=go.Line(color='rgb(125,125,125)', width=1), hoverinfo='none' ) trace2=go.Scatter3d(x=Xn, y=Yn, z=Zn, mode='markers', name='Alters', marker=go.Marker(symbol='circle', color=eigenVec, size=10,colorbar=go.ColorBar( title='Node Degree' ), colorscale='Viridis', line=go.Line(color='rgb(158,18,130)', width=0.5) ), text=nodesLabels, hoverinfo='text' ) axis=dict(showbackground=True, showline=True, zeroline=False, showgrid=True, showticklabels=True, title='' ) plan = go.Layout( title="Facebook Ego-Network", width=1000, height=1000, showlegend=True, scene=go.Scene( xaxis=go.XAxis(axis), yaxis=go.YAxis(axis), zaxis=go.ZAxis(axis), ), margin=go.Margin(t=100), hovermode='closest', annotations=go.Annotations([ go.Annotation( showarrow=True, xref='paper', yref='paper', x=0, y=0.1, xanchor='left', yanchor='top', font=go.Font(size=14) ) ]),) data=go.Data([trace1, trace2]) fig=go.Figure(data=data, layout=plan) fig.show()
def getAnnotations(df,annotations,kind='lines',theme=None,**kwargs): """ Generates an annotations object Parameters: ----------- df : DataFrame Original DataFrame of values annotations : dict or list Dictionary of annotations {x_point : text} or List of Plotly annotations """ for key in list(kwargs.keys()): if key not in __ANN_KWARGS: raise Exception("Invalid keyword : '{0}'".format(key)) theme_data = getTheme(theme) kwargs['fontcolor']=kwargs.pop('fontcolor',theme_data['annotations']['fontcolor']) kwargs['arrowcolor']=kwargs.pop('arrowcolor',theme_data['annotations']['arrowcolor']) kwargs['fontsize']=kwargs.pop('fontsize',12) def check_ann(annotation): local_list=[] try: _annotation=dict_replace_keyword({},'font',annotation,False) _annotation=dict_replace_keyword(_annotation,'font',kwargs,False) local_list.append(go.Annotation(_annotation)) except: if 'title' in annotation: local_list.append( go.Annotation( text=annotation['title'], showarrow=False, x=0, y=1, xref='paper', yref='paper', font={'size':24 if not 'fontsize' in kwargs else kwargs['fontsize']} ) ) del annotation['title'] for k,v in list(annotation.items()): if kind in ('candlestick','ohlc','candle'): d=ta._ohlc_dict(df) maxv=df[d['high']].ix[k] yref='y2' else: maxv=df.ix[k].sum() if k in df.index else 0 yref='y1' ann=go.Annotation( x=k, y=maxv, xref='x', yref=yref, text=v, showarrow=True, arrowhead=7, ax=0, ay=-100, textangle=-90 ) local_list.append(ann) _l=[] for i in local_list: _l.append(dict_replace_keyword(i,'font',kwargs,True)) local_list=_l return local_list if not isinstance(annotations,list): annotations=[annotations] _list_ann=[] for ann in annotations: _list_ann.extend(check_ann(ann)) return go.Annotations(_list_ann)
def get_player_trend(_player, _nb_games, _season, _season_type): pid = _player['PLAYER_ID'] name = _player['PLAYER_NAME'] team = _player['TEAM_ABBR'] last_n_games_fp_avg = _player['LAST_N_GAMES_NBA_FANTASY_PTS'] last_n_games_ttfl_avg = _player['LAST_N_GAMES_TTFL_SCORE'] ov_fp_avg = _player['NBA_FANTASY_PTS'] ov_ttfl_avg = _player['TTFL_SCORE'] ov_gp = _player['GP'] PLAYER_HEADSHOT_URL = 'https://ak-static.cms.nba.com/wp-content/uploads/headshots/nba/latest/260x190/' PLAYER_HEADSHOT_EXT = '.png' TEAM_LOGO_URL = 'https://www.nba.com/.element/img/1.0/teamsites/logos/teamlogos_500x500/' TEAM_LOGO_EXT = '.png' # --- print "Fetching %s log..." % name (game_matchup, game_date, game_fp, game_ttfl) = get_player_log(pid, _nb_games, _season, _season_type) print "%s log fetched..." % name # --- (ng_date, player_team, vs_team, location) = get_player_next_game(pid) if location == 'H': ng_matchup = 'vs.' else: ng_matchup = '@' ng_text = '%s <br> %s %s %s' % (ng_date, player_team, ng_matchup, vs_team) inj_status = _player['INJ_STATUS'] if inj_status == 'True': injury_text = 'OUT (%s from %s)' % (_player['INJ_TYPE'], _player['INJ_DATE']) else: injury_text = '' # --- print "Tracing %s rating trend..." % name # trace plots for nba fp and ttfl score trends xaxis = [] for (matchup, date) in zip(game_matchup, game_date): xaxis.append("%s<br>%s" % (date, matchup)) trace1 = pgo.Scatter(x=xaxis, y=game_fp, mode='lines+markers', name='nba fp trend', line=dict(shape='spline', ), hoverinfo='y') trace2 = pgo.Scatter(x=xaxis, y=game_ttfl, mode='lines+markers', name='ttfl score trend', line=dict(shape='spline', ), hoverinfo='y') trace3 = pgo.Scatter(x=xaxis, y=[last_n_games_fp_avg] * len(xaxis), mode='lines', name='last %d games nba fp avg' % len(xaxis), line=dict(dash='dash', ), hoverinfo='y') trace4 = pgo.Scatter(x=xaxis, y=[last_n_games_ttfl_avg] * len(xaxis), mode='lines', name='last %d games ttfl avg' % len(xaxis), line=dict(dash='dash', ), hoverinfo='y') trace5 = pgo.Scatter(x=xaxis, y=[ov_fp_avg] * len(xaxis), mode='lines', name='overall (%d) nba fp avg' % ov_gp, line=dict(dash='dash', ), hoverinfo='y') trace6 = pgo.Scatter(x=xaxis, y=[ov_ttfl_avg] * len(xaxis), mode='lines', name='overall (%d) ttfl avg' % ov_gp, line=dict(dash='dash', ), hoverinfo='y') data = [trace1, trace2, trace3, trace4, trace5, trace6] layout = pgo.Layout( title='%s %s %s Ratings Trend' % (name, _season, _season_type), titlefont=dict(size=18, ), xaxis=dict(tickangle=45, ), yaxis=dict(range=[0, 100], ), images=[ dict( source=PLAYER_HEADSHOT_URL + str(pid) + PLAYER_HEADSHOT_EXT, xref="paper", yref="paper", x=0.1, y=1.1, sizex=0.25, sizey=0.25, xanchor="center", yanchor="top", layer="below", ), dict( source=TEAM_LOGO_URL + team.lower() + TEAM_LOGO_EXT, xref="paper", yref="paper", x=0.5, y=0.5, sizex=1, sizey=1, xanchor="center", yanchor="middle", opacity=0.2, layer="below", ), ], legend=dict(x=0.8, y=1.05, font=dict(size=10, ), bordercolor='#000000', borderwidth=1), annotations=pgo.Annotations([ pgo.Annotation( xref='paper', yref='paper', x=0.2, y=1.0, showarrow=False, text='Next Game: %s' % ng_text, ), pgo.Annotation( xref='paper', yref='paper', x=0.5, y=1.0, showarrow=False, text=injury_text, font=dict(size=12, color='#D62728'), ), ]), ) fig = pgo.Figure(data=data, layout=layout) fname = './tmp/%d_ratings.html' % (pid) po.plot(fig, filename=fname) print "%s rating trend traced..." % name print "----------"
def draw_text(self, **props): """Create an annotation dict for a text obj. Currently, plotly uses either 'page' or 'data' to reference annotation locations. These refer to 'display' and 'data', respectively for the 'coordinates' key used in the Exporter. Appropriate measures are taken to transform text locations to reference one of these two options. props.keys() -- [ 'text', (actual content string, not the text obj) 'position', (an x, y pair, not an mpl Bbox) 'coordinates', ('data', 'axes', 'figure', 'display') 'text_type', ('title', 'xlabel', or 'ylabel') 'style', (style dict, see below) 'mplobj' (actual mpl text object) ] props['style'].keys() -- [ 'alpha', (opacity of text) 'fontsize', (size in points of text) 'color', (hex color) 'halign', (horizontal alignment, 'left', 'center', or 'right') 'valign', (vertical alignment, 'baseline', 'center', or 'top') 'rotation', 'zorder', (precedence of text when stacked with other objs) ] """ self.msg += " Attempting to draw an mpl text object\n" if not mpltools.check_corners(props['mplobj'], self.mpl_fig): warnings.warn( "Looks like the annotation(s) you are trying \n" "to draw lies/lay outside the given figure size.\n\n" "Therefore, the resulting Plotly figure may not be \n" "large enough to view the full text. To adjust \n" "the size of the figure, use the 'width' and \n" "'height' keys in the Layout object. Alternatively,\n" "use the Margin object to adjust the figure's margins.") align = props['mplobj']._multialignment if not align: align = props['style']['halign'] # mpl default if 'annotations' not in self.plotly_fig['layout']: self.plotly_fig['layout']['annotations'] = go.Annotations() if props['text_type'] == 'xlabel': self.msg += " Text object is an xlabel\n" self.draw_xlabel(**props) elif props['text_type'] == 'ylabel': self.msg += " Text object is a ylabel\n" self.draw_ylabel(**props) elif props['text_type'] == 'title': self.msg += " Text object is a title\n" self.draw_title(**props) else: # just a regular text annotation... self.msg += " Text object is a normal annotation\n" if props['coordinates'] is not 'data': self.msg += " Text object isn't linked to 'data' " \ "coordinates\n" x_px, y_px = props['mplobj'].get_transform().transform( props['position']) x, y = mpltools.display_to_paper( x_px, y_px, self.plotly_fig['layout'] ) xref = 'paper' yref = 'paper' xanchor = props['style']['halign'] # no difference here! yanchor = mpltools.convert_va(props['style']['valign']) else: self.msg += " Text object is linked to 'data' " \ "coordinates\n" x, y = props['position'] axis_ct = self.axis_ct xaxis = self.plotly_fig['layout']['xaxis{0}'.format(axis_ct)] yaxis = self.plotly_fig['layout']['yaxis{0}'.format(axis_ct)] if (xaxis['range'][0] < x < xaxis['range'][1] and yaxis['range'][0] < y < yaxis['range'][1]): xref = 'x{0}'.format(self.axis_ct) yref = 'y{0}'.format(self.axis_ct) else: self.msg += " Text object is outside " \ "plotting area, making 'paper' reference.\n" x_px, y_px = props['mplobj'].get_transform().transform( props['position']) x, y = mpltools.display_to_paper(x_px, y_px, self.plotly_fig['layout']) xref = 'paper' yref = 'paper' xanchor = props['style']['halign'] # no difference here! yanchor = mpltools.convert_va(props['style']['valign']) annotation = go.Annotation( text=(str(props['text']) if isinstance(props['text'], six.string_types) else props['text']), opacity=props['style']['alpha'], x=x, y=y, xref=xref, yref=yref, align=align, xanchor=xanchor, yanchor=yanchor, showarrow=False, # change this later? font=go.layout.annotation.Font( color=props['style']['color'], size=props['style']['fontsize'] ) ) self.plotly_fig['layout']['annotations'] += annotation, self.msg += " Heck, yeah I drew that annotation\n"
def conditionalHist(x, y, Nbins=50, std=True, plot=False, xlbl='X', ylbl='Y', stats=None): """ gives E[y|x] :param x: :param y: :param Nbins: number of bins in the hist :param std: whether to calc/plot standard deviation of the hist :param plot: 1/0 :param xlbl: :param ylbl: :param stats: whether to add trendline to plot :return: """ x = np.array(x) y = np.array(y) # calc min/max xrange (ie make robust to outliers maxstd = 8 # if max above this many stddevs from mean, it is clipped percclip = [5, 95] # percentile above which it is clipped meanx, stdx, minx, maxx = np.mean(x), np.std(x), np.min(x), np.max(x) xrange = np.percentile( x, percclip ) if meanx + maxstd * stdx < maxx or meanx - maxstd * stdx > minx else [ minx, maxx ] bins = np.linspace(*xrange, Nbins + 2) bins = bins[1:-1] # remove edge effects dig = np.digitize(x, bins) #remove values outside of range Igood = list(dig != 0) and list(dig < Nbins) condHist = accum(dig[Igood], y[Igood], func=np.mean, size=Nbins) if std: condStd = accum(dig[Igood], y[Igood], func=np.std) if plot: traces = [] traces += [go.Scatter(x=bins, y=condHist, name='E[Y|X]')] if std: ploterror_top = go.Scatter( x=bins, y=condHist + condStd, fill='none', fillcolor='rgba(200,100,80,0.2)', mode='lines', marker=dict(color="444"), line=dict(width=0), showlegend=True, legendgroup='bounds', name='var[Y|X]', opacity=.7, ) ploterror_bottom = go.Scatter( x=bins, y=condHist - condStd, fill='tonexty', fillcolor='rgba(200,100,80,0.2)', mode='lines', marker=dict(color="444"), line=dict(width=0), showlegend=False, legendgroup='bounds', name='lower bound', opacity=.7, ) traces += [ploterror_top, ploterror_bottom] if stats: slope, intercept, R2, p_val, std_err = sp.stats.linregress(x, y) R2sp, p_val_sp = sp.stats.spearmanr(x, y) corrtext = 'Pearson [R2, P]=[%.2f,%.2f] <br> ' \ 'Spearman [R2, P]=[%.2f,%.2f] <br> ' \ 'y=%.2fx+%.2f' \ % (R2, p_val, R2sp, p_val_sp, slope, intercept) print(corrtext) annots = go.Annotations([ go.Annotation(x=0.05, y=0.95, showarrow=False, text=corrtext, xref='paper', yref='paper') ]) else: annots = [] title = 'Conditional Histogram of ' + xlbl + ' | ' + ylbl layout = go.Layout(title=title, xaxis={'title': xlbl}, yaxis={'title': ylbl}, annotations=annots) if in_notebook(): pyo.iplot({'data': traces, 'layout': layout}) else: pyo.plot({ 'data': traces, 'layout': layout }, filename='getStimOnOffTimes.html') if std: return condHist, bins, condStd else: return condHist, bins