def draw_map_plotly(mums, html=None): data = [] for align in mums['+']: x = align[0] y = align[1] length = align[2] data.append(go.Scattergl(x=[x,x+length], y=[y,y+length], marker=dict(color='red'))) for align in mums['-']: x = align[0] y = align[1] length = align[2] data.append(go.Scattergl(x=[x,x+length], y=[y,y-length], marker=dict(color='blue'))) # output layout = go.Layout( showlegend=False, barmode='stack', xaxis=dict(title='reference', domain=[0, 1], showspikes=True, spikemode='across'), yaxis=dict(title='query', domain=[0, 1], showspikes=True, spikemode='across') ) fig = go.Figure(data=data, layout=layout) if html: offline.plot(fig, filename=html, auto_open=False) else: offline.iplot(fig)
def plot_prefixspan(self, l): all_trace = [] for elmt in l: trace = go.Scattergl( y = elmt[1], mode = str(self.mode), name = str(elmt[0]) ) all_trace.append(trace) fig = dict(data=all_trace,layout = { 'xaxis': {'title': 'representation des symbols'}, 'yaxis': {'title': "y"} }) iplot(fig)
def get_zoom_graph(x, y, sf_trigger): fig = { 'data': [ go.Scattergl(x=x, y=y, mode='markers', marker=dict(color=config.get('ZOOM_GRAPH', 'POINTS_COLOR'), size=config.getint( 'ZOOM_GRAPH', 'POINTS_SIZE'))) ], 'layout': [] } return fig
def send_data_timeseries(drop_nb, df_json, tab_ttxd): if drop_nb is not None: if drop_nb != 0: df_data = pd.read_json(df_json) data_time = [] time_x = list(df_data.index) for idx in tab_ttxd[:drop_nb]: data_time.append( go.Scattergl( x=time_x, y=df_data[idx], name=idx, yaxis="y", )) data_time.append( go.Scattergl(x=time_x, y=df_data["tnh"], name="TNH", yaxis="y2", hoverinfo=("x", "y"))) fig_timeseries = go.Figure(data=data_time, layout=layout_timeseries) else: fig_timeseries = go.Figure(data=[go.Scatter()], layout=layout_timeseries) else: fig_timeseries = go.Figure(data=[go.Scatter()], layout=layout_timeseries) return fig_timeseries, template_download_plotly(fig_timeseries, 0)
def __create_list_of_scatters(self): list_of_plotly_scatters = [] labeled_points = zip(X_tsne, labels_array) for l in labels_array: points = [point for (point, label) in labeled_points if label == l] current_scatter = go.Scattergl( x, y=zip(*points), name=self.ROOM_LABELS[l - 1], mode='markers', ) list_of_plotly_scatters.append(current_scatter) return list_of_plotly_scatters
def calc_graph(self): data = self.calculate_hourly_loads() traces = [] analysis_fields = self.remove_unused_fields(data, self.analysis_fields) for field in analysis_fields: y = data[field].values / 1E3 # to MW name = NAMING[field] trace = go.Scattergl(x=data.index, y=y, name=name, marker=dict(color=COLOR[field])) traces.append(trace) data_T = self.calculate_external_temperature() for field in ["T_ext_C"]: y = data_T[field].values name = NAMING[field] trace = go.Scattergl(x=data_T.index, y=y, name=name, yaxis='y2', opacity=0.2) traces.append(trace) return traces
def get_figure_data(jdata, dotsize, word_obs, annot_sel, is_annot): x = np.array(jdata['embed'][0]) y = np.array(jdata['embed'][1]) def annot_word(i_word, showarrow=True): return dict(x=x[i_word + 2], y=y[i_word + 2], xref='x', yref='y', text=jdata['vocab'][i_word + 2], showarrow=showarrow, ax=20, ay=-20) if annot_sel == 'obs': annots = [annot_word(word_obs)] elif annot_sel == 'none': annots = [] else: if len(is_annot) > 0: annots = [annot_word(i_high) for i_high in is_annot] else: annots = [] return { 'data': [ go.Scattergl(x=x, y=y, mode='markers', marker=dict(size=dotsize), text=jdata['vocab']) ], 'layout': go.Layout(autosize=True, hovermode='closest', yaxis=dict(zeroline=False, range=[y.min() - 5, y.max() + 5], showticklabels=False, mirror=True, showline=True), xaxis=dict(zeroline=False, range=[x.min() - 5, x.max() + 5], showticklabels=False, mirror=True, showline=True), showlegend=False, annotations=annots, margin=go.Margin(l=5, r=5, b=15, t=15, pad=4)) }
def plot_expression_UMAP(adata, selected_gene): traces = [] traces.append( go.Scattergl( x=adata.obsm["X_umap"][:, 0], y=adata.obsm["X_umap"][:, 1], text="Cell ID: " + adata.obs["cell_ID"], mode='markers', marker={ 'size': 10, 'line': { 'width': 1, 'color': 'grey' }, "color": adata.obs_vector(selected_gene), "colorscale": "viridis", "cmin": 0, "cmax": np.max(adata.obs_vector(selected_gene)), "colorbar": dict(title=str(selected_gene)), }, unselected={"marker": { "opacity": min_opacity, }}, selected={"marker": { "opacity": max_opacity, }}, )) return { 'data': traces, 'layout': dict(xaxis={"title": "UMAP 1"}, yaxis={"title": "UMAP 2"}, margin={ 'l': 40, 'b': 40, 't': 10, 'r': 10 }, legend={ 'x': 0, 'y': 1 }, hovermode='closest', transition={'duration': 100}, width=4 * scale, height=3 * scale) }
def update_graph(ratingcheck, prices): dff = transforms.df low = prices[0] high = prices[1] dff = dff.loc[(dff['price'] >= low) & (dff['price'] <= high)] if ratingcheck == ['Y']: dff = dff.loc[dff['rating'] >= 95] else: dff trace1 = go.Scattergl(x=dff['rating'], y=dff['price'], mode='markers', opacity=0.7, marker={ 'size': 8, 'line': { 'width': 0.5, 'color': 'white' } }, name='Price v Rating') return html.Div([ dcc.Graph(id='rating-price', figure={ 'data': [trace1], 'layout': dict(xaxis={ 'type': 'log', 'title': 'Rating' }, yaxis={'title': 'Price'}, margin={ 'l': 40, 'b': 40, 't': 10, 'r': 10 }, legend={ 'x': 0, 'y': 1 }, hovermode='closest') }) ])
def generate_row(fig, row, raw_indicators, data) -> tools.make_subplots: """ Generator all the indicator selected by the user for a specific row """ for indicator in raw_indicators.split(','): if indicator in data: scattergl = go.Scattergl(x=data['date'], y=data[indicator], name=indicator) fig.append_trace(scattergl, row, 1) else: logger.info( 'Indicator "%s" ignored. Reason: This indicator is not found ' 'in your strategy.', indicator) return fig
def update_figure(selected_feature1, selected_feature2): data = [ go.Scattergl( x=df[selected_feature1], y=df[selected_feature2], mode = 'markers' ) ] return { 'data': data, 'layout': go.Layout( hovermode='closest' ) }
def create_scatter(x_values, y_values, mode, hovertext): """ """ tracer = go.Scattergl( x=x_values, y=y_values, mode=mode, #line=dict(color='black'), line=dict(color='rgba(147,112,219,0.1)'), showlegend=False, text=hovertext, hovertemplate=('%{text}'), visible=True) return tracer
def make_sub(dfs, df_keys, params): traces = [] for key, df in zip(df_keys, dfs): for par in params: if par in df.columns: this_df = df.dropna(subset=[par]) if this_df.shape[0] > 0: traces.append( go.Scattergl(x=this_df.index, y=this_df[par], name=key + ', ' + par, mode=graph_mode, marker=dict(size=5))) else: pass return traces
def calc_graph(analysis_fields, data_frame): graph = [] duration = range(HOURS_IN_YEAR) x = [(a - min(duration)) / (max(duration) - min(duration)) * 100 for a in duration] # calculate relative values for field in analysis_fields: data_frame = data_frame.sort_values(by=field, ascending=False) y = data_frame[field].values trace = go.Scattergl(x=x, y=y, name=field, fill='tozeroy', opacity=0.8, marker=dict(color=COLOR[field])) graph.append(trace) return graph
def price_duration_curve(price): price = price.sort_values('RRP', ascending=False) price = price.reset_index(drop=True) price['duration'] = price.index price['duration'] = (price['duration'] / price['duration'].max()) * 100 chart_data = go.Scattergl(x=price['duration'], y=price['RRP']) annual_profile_layout = get_default_layout() annual_profile_layout['xaxis']['title'] = 'Duration (%)' annual_profile_layout['yaxis']['title'] = 'Price ($/MWh)' annual_profile_layout['yaxis']['tickvals'] = [ 1, 10, 100, 1000, price['RRP'].max() ] annual_profile_layout['yaxis']['type'] = 'log' chart_data = {'data': [chart_data], 'layout': annual_profile_layout} chart_data = json.dumps(chart_data, cls=plotly.utils.PlotlyJSONEncoder) return chart_data
def visualize_prediction(file_path: str, prediction_list): (fs, x) = read('/Users/noresources/Pycharm_projects/InhaleSense/data/raw/' + file_path) # Create a trace predicted = go.Scattergl(x=np.arange(0, x.shape[0]), y=x, marker=dict(color=list( map(SetColor, np.arange(0, x.shape[0]), repeat(prediction_list))), size=1.5, opacity=0.5), mode="markers") return predicted
def cluster_analysis(paths, topn=100): model = api.load("glove-wiki-gigaword-200") #"glove-twitter-50") data = [] vector, labels, names = [], [], [] cnt = Counter() wwords = [] for path in paths: print('Analyzing: ', path) x = normalization.normalize_srt(path) wwords.append( [i for i, _ in word_counter.word_counter(x).most_common(topn)]) cnt.update(wwords[-1]) #print(words) for path, words in zip(paths, wwords): for word in words: try: if cnt[word] > 1: continue vector.append(model.wv[word]) labels.append(word) names.append(path) except Exception as e: print(e) print("Not found %s in vector" % word) embedded = TSNE(n_components=2, init='pca').fit_transform(vector) x, y = np.hsplit(embedded, 2) x = x.reshape(-1) y = y.reshape(-1) last = 0 for i in range(len(names)): if i + 1 == len(names) or names[i] != names[i + 1]: print(last, i) trace = go.Scattergl( x=x[last:i], y=y[last:i], mode='markers', # marker=dict(color='#FFBAD2', line=dict(width=1)), text=labels[last:i], name=names[i]) last = i + 1 data.append(trace) plotly.offline.plot(data, filename='compare_webgl.html')
def plot_chart(path_to_png, path_to_log_list): print(path_to_png[0:-4] + ".html") output_file(path_to_png[0:-4] + ".html") TOOLS = 'pan,box_zoom,wheel_zoom,save,hover,reset,resize' p = figure(title="TrainLoss(smoothed) vs NumIters", x_axis_label='NumIters') fig, ax1 = plt.subplots() cf.set_config_file(offline=False, world_readable=True, theme='ggplot') for path_to_log in path_to_log_list: os.system('%s %s ./ ' % (get_log_parsing_script(), path_to_log)) data_file = get_data_file(6, path_to_log) pddata = pd.read_csv(data_file) standard = ['NumIters', 'Seconds', 'LearningRate'] labels = [label for label in pddata if label not in standard] sp = 500 if len(pddata['NumIters']) > 2000 else 5 skip = 5 if len(pddata['NumIters']) > 2000 else 0 ylims = [100, -100] data = [] for label, i in zip(labels, range(len(labels))): Y = pddata[label].ewm(span=sp, adjust=True).mean() plt.plot(pddata["NumIters"], Y, alpha=0.4) ylims[0] = min(ylims[0], Y[skip:].min()) ylims[1] = max(ylims[1], Y[skip:].max()) data += [go.Scattergl(x=pddata["NumIters"], y=Y, name=label)] # p.line(pddata["NumIters"], Y, legend=label, # color=Spectral11[i%11], line_width=2) print(int(pddata["NumIters"].iloc[-1])) plt.legend() ax1.set_ylim(ylims) # p.extra_y_ranges = {"LearningRate": Range1d(start=0, end=pddata['LearningRate'].max()*1.1)} # p.add_layout(LinearAxis(y_range_name="LearningRate"), 'right') # p.line(pddata["NumIters"], # pddata['LearningRate'], # legend='LearningRate', # color='navy', y_range_name="LearningRate") # p.add_layout(LinearAxis(y_range_name="LearningRate"), 'left') # save(p) # ax2 = ax1.twinx() # ax2.plot(pddata["NumIters"], pddata['LearningRate'], alpha=0.4) plt.title('TrainLoss vs NumIters') # ax2.set_ylabel('Learning Rate', color='r') plt.xlabel('NumIters') plt.savefig(path_to_png) url = py.plot(data, filename=path_to_png[0:-4], fileopt='overwrite') print(url)
def generate_plotly_scatter(x, y, c, x_label, y_label, text, figsize, marker_size=8, dpi=40, alpha=0.8, cbar_title=None, colormap='Hot', save_to_path=None, show=True, publish_name=None): data = [ go.Scattergl(x=x, y=y, text=text, hoverinfo='text', mode='markers', marker=dict( size=marker_size, color=c, colorscale=colormap, showscale=True, opacity=alpha, colorbar=dict(title=cbar_title), )) ] layout = go.Layout(xaxis=dict(title=x_label), yaxis=dict(title=y_label), hovermode='closest', width=figsize[0] * dpi, height=figsize[1] * dpi) fig = go.Figure(data=data, layout=layout) if publish_name: py.plotly.plot(fig, filename=publish_name, show_link=True, auto_open=False) if save_to_path: py.offline.plot(fig, filename=save_to_path, show_link=False, auto_open=False) if show: py.offline.iplot(fig, show_link=False)
def display(data, title, xlabel, ylabel): app = dash.Dash(__name__) app.layout = html.Div(children=[ html.H1(children=title), dcc.Graph(id='graph', figure={ 'data': [ go.Scattergl(x=list(zip(*data))[0], y=list(zip(*data))[1], mode='markers') ], 'layout': go.Layout(xaxis={'title': xlabel}, yaxis={'title': ylabel}) }) ]) app.run_server(host='0.0.0.0', debug=False)
def _scatter(coords, *args, **kwargs): """Run the appropriate scatter function""" assert coords.shape[1] in [2, 3], "incorrect dimensions for coords" if coords.shape[1] == 2: try: return go.Scattergl(x=coords[:, 0], y=coords[:, 1], *args, **kwargs) except AttributeError: return go.Scatter(x=coords[:, 0], y=coords[:, 1], *args, **kwargs) else: return go.Scatter3d(x=coords[:, 0], y=coords[:, 1], z=coords[:, 2], *args, **kwargs)
def get_embedding_scatterplots(embeddings, sizes, opacity_states, colors, names): """ AAA """ data = [] for embedding, size, opacity, color, name in zip(embeddings, sizes, opacity_states, colors, names): temp_data = go.Scattergl(x=embedding['Z1'], y=embedding['Z2'], mode='markers', marker=dict(color=color, size=size, opacity=opacity), hoverinfo='text', hovertext=embedding['text'], customdata=embedding.index.tolist(), name=name) data.append(temp_data) layout = go.Layout(xaxis=dict(showticklabels=False, ticks=''), yaxis=dict(showticklabels=False, ticks=''), margin=dict(t=30), paper_bgcolor='rgba(0,0,0,0)', clickmode='event+select', showlegend=True, legend=dict(font=dict(color="white")), legend_orientation="h") fig = go.Figure(data=data, layout=layout) return fig
def plot_scatter_by_capteur(self, data, capteur): all_trace = [] for cpt in capteur: for k, v in data.items(): if cpt in k: trace = go.Scattergl( x = data[k]["Date"], y = data[k]["Valeur"], mode = str(self.mode), name = str(str(k)) ) all_trace.append(trace) fig = dict(data=all_trace,layout = { 'xaxis': {'title': 'Le temps'}, 'yaxis': {'title': "La valeur"} }) iplot(fig)
def get_scatter_plot(df_trans, x, y, title='Scatter Plot'): trace1 = go.Scattergl(x=df_trans[x], y=df_trans[y], text=df_trans[x].index, mode='markers', marker=dict(size=2)) trace2 = go.Box(x=df_trans[x], text=df_trans[x].index, name=x, boxpoints='outliers', jitter=0, marker=dict(size=2), yaxis='y2') trace3 = go.Box(y=df_trans[y], text=df_trans[y].index, name=y, boxpoints='outliers', jitter=0, marker=dict(size=2), xaxis='x2') vs_traces = [trace1, trace2, trace3] vs_layout = go.Layout(title=title.format(x, y), hovermode='closest', titlefont=dict(size=14, color='#0e4886'), xaxis=dict(tickfont=dict(size=10), titlefont=dict(color='#0e4886'), title=x, domain=[0, 0.85], showgrid=False), xaxis2=dict(domain=[0.85, 1], showticklabels=False, showgrid=False), yaxis=dict(tickfont=dict(size=10), title=y, titlefont=dict(color='#0e4886'), domain=[0, 0.85], showgrid=False), yaxis2=dict(domain=[0.85, 1], showticklabels=False, showgrid=False), showlegend=False, font=dict(size=10), margin=dict(l=45, r=5, t=30, b=30)) fig = go.Figure(data=vs_traces, layout=vs_layout) return fig
def generate_row(fig, row, raw_indicators, data) -> tools.make_subplots: """ Generator all the indicator selected by the user for a specific row """ if raw_indicators is None or raw_indicators == "": return fig for indicator in raw_indicators.split(','): if indicator in data: scattergl = go.Scattergl( x=data['date'], y=data[indicator], name=indicator ) fig.append_trace(scattergl, row, 1) return fig
def plot_2d_scatter(df, x, y, xlab='', ylab='', title='', filename='2d-scatter.html', inline=False): # Create a trace trace = go.Scattergl(x=df[x], y=df[y], mode='markers') data = [trace] if inline: init_notebook_mode() iplot(data, filename=filename) else: plot(data, filename=filename)
def plot_2D_scatter(x, y, text='', title='', xlab='', ylab='', hoverinfo='text', color='black', colorscale='Blues', size=8, showscale=False, symmetric_x=False, symmetric_y=False, pad=0.5, hline=False, vline=False, return_trace=False): range_x = [-max(abs(x)) - pad, max(abs(x)) + pad] if symmetric_x else [] range_y = [-max(abs(y)) - pad, max(abs(y)) + pad] if symmetric_y else [] trace = go.Scattergl(x=x, y=y, mode='markers', text=text, hoverinfo=hoverinfo, hovermode='closest', marker={ 'color': color, 'colorscale': colorscale, 'showscale': showscale, 'size': size }) if return_trace: return trace else: layout = go.Layout(title=title, xaxis={ 'title': xlab, 'range': range_x }, yaxis={ 'title': ylab, 'range': range_y }, hovermode='closest') fig = go.Figure(data=[trace], layout=layout) return iplot(fig)
def plotly_clips(bam_path): import plotly.offline as py import plotly.graph_objs as go aln = list(parse_bam(bam_path).items())[0][1] aligned_depth = [sum(weight.values()) for weight in aln.weights] ins = [sum(i.values()) for i in aln.insertions] x_axis = list(range(len(aligned_depth))) traces = [ go.Scattergl(x=x_axis, y=aligned_depth, mode='lines', name='Aligned depth'), go.Scattergl(x=x_axis, y=aln.consensus_depth, mode='lines', name='Consensus depth'), go.Scattergl(x=x_axis, y=aln.clip_start_depth, mode='lines', name='Soft clip start depth'), go.Scattergl(x=x_axis, y=aln.clip_end_depth, mode='lines', name='Soft clip end depth'), go.Scattergl(x=x_axis, y=aln.clip_starts, mode='markers', name='Soft clip starts'), go.Scattergl(x=x_axis, y=aln.clip_ends, mode='markers', name='Soft clip ends'), go.Scattergl(x=x_axis, y=ins, mode='markers', name='Insertions'), go.Scattergl(x=x_axis, y=aln.deletions, mode='markers', name='Deletions') ] layout = go.Layout(xaxis=dict(type='linear', autorange=True), yaxis=dict(type='linear', autorange=True)) fig = go.Figure(data=traces, layout=layout) out_fn = os.path.splitext(os.path.split(bam_path)[1])[0] py.plot(fig, filename=out_fn + '.clips.html')
def visualize_groundtruth(file_path: str, relevant): (fs, x) = read('/Users/noresources/Pycharm_projects/InhaleSense/data/raw/' + file_path) Exhale = [] Inhale = [] Drug = [] for idx, snippet in relevant.iterrows(): if snippet[1] == 'Exhale': Exhale.append({'begin': snippet[2], 'end': snippet[3]}) elif snippet[1] == 'Inhale': Inhale.append({'begin': snippet[2], 'end': snippet[3]}) elif snippet[1] == 'Drug': Drug.append({'begin': snippet[2], 'end': snippet[3]}) # print(Exhale, Inhale, Drug) # function below sets the color based on amount def SetColor_range(x): for exh in Exhale: if exh['begin'] < x and exh['end'] > x: return "red" for inh in Inhale: if inh['begin'] < x and inh['end'] > x: return "blue" for dru in Drug: if dru['begin'] < x and dru['end'] > x: return "green" return "black" # Create a trace ground_truth = go.Scattergl(x=np.arange(0, x.shape[0]), y=x, marker=dict(color=list( map(SetColor_range, np.arange(0, x.shape[0]))), size=1.5, opacity=0.5), mode="markers") return ground_truth
def _make_trace2d(neuron, plane, prefix='', opacity=1., visible=True, style=None, line_width=2): '''Create the trace to be plotted''' names = defaultdict(int) lines = list() for neurite in iter_neurites(neuron): names[neurite.type] += 1 try: neurite_color = style[neurite]['color'] except KeyError: neurite_color = TREE_COLOR.get(neurite.root_node.type, 'black') name = _neurite_name(neurite, prefix, names) for section in iter_sections(neurite): segs = [(s[0][COLS.XYZ], s[1][COLS.XYZ]) for s in iter_segments(section)] try: colors = style[section]['color'] except KeyError: colors = neurite_color coords = dict() for i, coord in enumerate('xyz'): coords[coord] = list( chain.from_iterable( (p1[i], p2[i], None) for p1, p2 in segs)) coords = dict(x=coords[plane[0]], y=coords[plane[1]]) lines.append( go.Scattergl(name=name, visible=visible, opacity=opacity, showlegend=False, line=dict(color=colors, width=line_width), mode='lines', **coords)) return lines