def distribution(): mu, sigma = 0, 0.5 measured = np.random.normal(mu, sigma, 1000) hist, edges = np.histogram(measured, density=True, bins=20) x = np.linspace(-2, 2, 1000) pdf = 1 / (sigma * np.sqrt(2 * np.pi)) * np.exp(-(x - mu) ** 2 / (2 * sigma ** 2)) cdf = (1 + scipy.special.erf((x - mu) / np.sqrt(2 * sigma ** 2))) / 2 output_server("distribution_reveal") p = figure(title="Interactive plots", background_fill="#E5E5E5") p.quad(top=hist, bottom=0, left=edges[:-1], right=edges[1:], fill_color="#333333", line_color="#E5E5E5", line_width=3) # Use `line` renderers to display the PDF and CDF p.line(x, pdf, line_color="#348abd", line_width=8, alpha=0.7, legend="PDF") p.line(x, cdf, line_color="#7a68a6", line_width=8, alpha=0.7, legend="CDF") p.legend.orientation = "top_left" p.xaxis.axis_label = 'x' p.xgrid[0].grid_line_color = "white" p.xgrid[0].grid_line_width = 3 p.yaxis.axis_label = 'Pr(x)' p.ygrid[0].grid_line_color = "white" p.ygrid[0].grid_line_width = 3 push() return p, cursession()
def animated(): from numpy import pi, cos, sin, linspace N = 50 + 1 r_base = 8 theta = linspace(0, 2 * pi, N) r_x = linspace(0, 6 * pi, N - 1) rmin = r_base - cos(r_x) - 1 rmax = r_base + sin(r_x) + 1 colors = ["FFFFCC", "#C7E9B4", "#7FCDBB", "#41B6C4", "#2C7FB8", "#253494", "#2C7FB8", "#41B6C4", "#7FCDBB", "#C7E9B4"] * 5 output_server("animated_reveal") p = figure(title="Animations", x_range=[-11, 11], y_range=[-11, 11]) p.annular_wedge( 0, 0, rmin, rmax, theta[:-1], theta[1:], inner_radius_units="data", outer_radius_units="data", fill_color=colors, line_color="black", ) push() return p, cursession()
def _make_figures(self,ep,trainerr,metvals): self._datasources = [] figures = [] fig = figure(title='Total Training Cost',x_axis_label='Epoch',y_axis_label='Cost') fig.line([ep],[trainerr],name='plot') ds = fig.select(dict(name='plot'))[0].data_source self._datasources.append(ds) if self._plotmetricmean: figures.append(fig) fig = figure(title='Metric Mean',x_axis_label='Epoch',y_axis_label='Mean') fig.line([ep],[np.nanmean(metvals)],name='plot') ds = fig.select(dict(name='plot'))[0].data_source self._datasources.append(ds) figures.append(fig) for mv,(mk,m) in zip(metvals,self.metrics): if m.metric in xnn.metrics.metric_names: name = xnn.metrics.metric_names[m.metric] else: name = m.metric.__name__ fig = figure(title=mk,x_axis_label='Epoch',y_axis_label=name) fig.line([ep],[mv],name='plot') ds = fig.select(dict(name='plot'))[0].data_source self._datasources.append(ds) figures.append(fig) allfigs = vplot(*figures) push()
def create_plot(self): output_server('animation') source = ColumnDataSource(data=dict(x=[], y=[])) p = figure(plot_width=800, plot_height=400) p.line(x='x', y='y', source=source, name='line') push() return p, cursession()
def draw_plot(all_freqs, all_segm_dict, uniq_id="no-id"): #zbior nazw wszystkich komorek podczas symulacji cells_types = set() for i in range(len(all_freqs)): for e in all_freqs[i].keys(): cells_types.add(e) #dla kazdego typu komorek przypisywany jest inny kolor col_dict = {} from bokeh.palettes import brewer colors_palette = brewer["Spectral"][11] color = lambda: random.randint(0, 255) for i, element in enumerate(cells_types): if i < 11: col_dict[element] = colors_palette[i] else: #losowy kolor col_dict[element] = ('#%02X%02X%02X' % (color(), color(), color())) #dodanie klucza od wartosci ktorych nie ma po pierwszej iteracji for element in cells_types: for i in range(len(all_freqs)): if element not in all_freqs[i]: all_freqs[i][element] = [0, 0, 0, 0] output_server("stops3" + uniq_id) bar, geny = plot_segments(all_freqs[0], col_dict) plot = plot_environment(all_segm_dict[0]) push() return bar, plot, cursession(), geny
def draw_bokeh_plot(pop_mat, grid_shape, color_dict, width=800, uniq_id="no-id"): #wykres na siatce heksagonalnej output_server("stops2" + uniq_id) p = figure(plot_width=width, title="STOPS") p.ygrid.grid_line_color = "white" p.xgrid.grid_line_color = "white" m, n = grid_shape beta = 0.5 alpha = beta / math.sqrt(3) h = beta / math.sqrt(3) points_x = [] points_y = [] y = 0 for i in range(n): if i % 2 == 1: x = -0.5 else: x = -1 for j in range(m): if i % 2 == 1: x += 1 else: x += 1 points = hexagon_points(x, y, alpha, beta) points_x.append(points[0]) points_y.append(points[1]) y += 3 * h colors, wektor = value_color(pop_mat, color_dict) source = ColumnDataSource(data=dict( points_x=points_x, points_y=points_y, wektor=wektor, colors=colors)) p.patches(xs="points_x", ys="points_y", source=source, line_color="blue", color="colors", line_width=2, fill_alpha=0.8) hover = HoverTool(plot=p, tooltips=dict(wektor="@wektor")) p.tools.append(hover) push() return p, cursession()
def run(self): while True: priority, obj = self.queue.get() if priority == PushThread.PUT: cursession().store_objects(obj) elif priority == PushThread.PUSH: push() # delete queued objects when training has finished if obj == "after_training": with self.queue.mutex: del self.queue.queue[:] break self.queue.task_done()
def on_epoch_end(self, epoch, logs={}): I = self.get_image() if not hasattr(self, 'fig'): self.fig = figure(title=self.fig_title, x_range=[0, 1], y_range=[0, 1]) self.fig.image(image=[I], x=[0], y=[0], dw=[1], dh=[1], name='weight') renderer = self.fig.select({'name': 'weight'}) self.plots.append(renderer[0].data_source) show(self.fig) else: self.plots[0].data['image'] = [I] cursession().store_objects(self.plots[0]) push()
def update_plots(self, epoch, monitors): """ Given the calculated monitors (collapsed name and value tuple), add its datapoint to the appropriate figure and update the figure in bokeh-server. Parameters ---------- epoch : int The epoch (x-axis value in the figure). monitors : dict The dictionary of monitors calculated at this epoch. The dictionary is of the form {collapsed_monitor_name: value}. The name is the same that was used in the creation of the figures in the plot, so it is used as the key to finding the appropriate figure to add the data. """ if BOKEH_AVAILABLE: for key, value in monitors.items(): if key in self.figure_indices: if key not in self.plots: # grab the correct figure by its index for the key (same with the color) fig = self.figures[self.figure_indices[key]] color_idx = self.figure_color_indices[ self.figure_indices[key]] # split the channel from the monitor name name = key.split(COLLAPSE_SEPARATOR, 1) if len(name) > 1: name = name[1] else: name = name[0] # create a new line fig.line([epoch], [value], legend=name, x_axis_label='iterations', y_axis_label='value', name=name, line_color=self.colors[color_idx % len(self.colors)]) color_idx += 1 # set the color index back in the figure list self.figure_color_indices[ self.figure_indices[key]] = color_idx # grab the render object and put it in the plots dictionary renderer = fig.select(dict(name=name)) self.plots[key] = renderer[0].data_source else: self.plots[key].data['x'].append(epoch) self.plots[key].data['y'].append(value) cursession().store_objects(self.plots[key]) push()
def main(document, server_url): plots = {} output_server(document, url=server_url) # Create figures for each group of channels p = [] p_indices = {} for i, channel_set in enumerate(channels): channel_set_opts = {} if isinstance(channel_set, dict): channel_set_opts = channel_set channel_set = channel_set_opts.pop("channels") channel_set_opts.setdefault("title", "{} #{}".format(document, i + 1)) p.append(figure(**channel_set_opts)) for channel in channel_set: p_indices[channel] = i files = [f for f in listdir(document) if isfile(join(document, f)) and "_log_" in f] for file_name in sorted(files, key=lambda s: int(re.findall(r"\d+", s)[1])): with open(join(document, file_name), "rb") as f: log = pickle.load(f) iteration = log.status["iterations_done"] i = 0 for key, value in log.current_row.items(): if key in p_indices: if key not in plots: fig = p[p_indices[key]] fig.line( [iteration], [value], legend=key, x_axis_label="iterations", y_axis_label="value", name=key, line_color=colors[i % len(colors)], ) i += 1 renderer = fig.select(dict(name=key)) plots[key] = renderer[0].data_source else: plots[key].data["x"].append(iteration) plots[key].data["y"].append(value) cursession().store_objects(plots[key]) push()
def do(self, which_callback, *args): log = self.main_loop.log iteration = log.status["iterations_done"] i = 0 for key, value in log.current_row.items(): if key in self.p_indices: if key not in self.plots: fig = self.p[self.p_indices[key]] fig.line([iteration], [value], legend=key, name=key, line_color=self.colors[i % len(self.colors)]) i += 1 renderer = fig.select(dict(name=key)) self.plots[key] = renderer[0].data_source else: self.plots[key].data["x"].append(iteration) self.plots[key].data["y"].append(value) cursession().store_objects(self.plots[key]) push()
def update_plots(self, epoch, monitors): """ Given the calculated monitors (collapsed name and value tuple), add its datapoint to the appropriate figure and update the figure in bokeh-server. Parameters ---------- epoch : int The epoch (x-axis value in the figure). monitors : dict The dictionary of monitors calculated at this epoch. The dictionary is of the form {collapsed_monitor_name: value}. The name is the same that was used in the creation of the figures in the plot, so it is used as the key to finding the appropriate figure to add the data. """ if BOKEH_AVAILABLE: for key, value in monitors.items(): if key in self.figure_indices: if key not in self.plots: # grab the correct figure by its index for the key (same with the color) fig = self.figures[self.figure_indices[key]] color_idx = self.figure_color_indices[self.figure_indices[key]] # split the channel from the monitor name name = key.split(COLLAPSE_SEPARATOR, 1) if len(name) > 1: name = name[1] else: name = name[0] # create a new line fig.line([epoch], [value], legend=name, x_axis_label='iterations', y_axis_label='value', name=name, line_color=self.colors[color_idx % len(self.colors)]) color_idx += 1 # set the color index back in the figure list self.figure_color_indices[self.figure_indices[key]] = color_idx # grab the render object and put it in the plots dictionary renderer = fig.select(dict(name=name)) self.plots[key] = renderer[0].data_source else: self.plots[key].data['x'].append(epoch) self.plots[key].data['y'].append(value) cursession().store_objects(self.plots[key]) push()
def wrapper(*args, **kwargs): docname = prefix + str(uuid.uuid4()) output_server(docname, url=url) curdoc().autoadd(False) app = func(*args, **kwargs) curdoc()._plotcontext.children = [app] curdoc().add_all() changed = push() logger.debug("stored: %s", str(changed)) app.docname = docname return app
def do(self, which_callback, *args): log = self.main_loop.log iteration = log.status['iterations_done'] i = 0 for key, value in log.current_row.items(): if key in self.p_indices: if key not in self.plots: fig = self.p[self.p_indices[key]] fig.line([iteration], [value], legend=key, x_axis_label='iterations', y_axis_label='value', name=key, line_color=self.colors[i % len(self.colors)]) i += 1 renderer = fig.select(dict(name=key)) self.plots[key] = renderer[0].data_source else: self.plots[key].data['x'].append(iteration) self.plots[key].data['y'].append(value) cursession().store_objects(self.plots[key]) push()
def on_epoch_end(self, epoch, logs={}): if not hasattr(self, 'fig'): self.fig = figure(title=self.fig_title) for i, v in enumerate(['loss', 'val_loss']): if v == 'loss': L = self.totals[v] / self.seen else: L = logs.get(v) self.fig.line([epoch], [L], legend=v, name=v, line_width=2, line_color=self.colors[i % len(self.colors)]) renderer = self.fig.select({'name': v}) self.plots.append(renderer[0].data_source) show(self.fig) else: for i, v in enumerate(['loss', 'val_loss']): if v == 'loss': L = self.totals[v] / self.seen else: L = logs.get(v) self.plots[i].data['y'].append(L) self.plots[i].data['x'].append(epoch) cursession().store_objects(self.plots[i]) push()
#risale alla id univoca del graph idkey = name + " (" + gtype + ")" if idkey in gobjs: #se il graph già esiste #recupera graph e lo aggiorna con data g = gobjs[idkey] g.update(data) #aggiorna documento relativo a graph, passandone le info a bokeh-server s.use_doc("%s" %idkey) s.store_document(gdocs["%s" %idkey]) #salva graph aggiornato in dizionario gobjs[idkey] = g else: #se il graph non esiste #crea un nuovo graph g = gtypes[gtype](idkey) g.update(data) #crea un nuovo documento d = Document() gdocs["%s" %idkey] = d d.add(g.get_plot()) #passa le info del documento a bokeh-server s.use_doc("%s" %idkey) s.load_document(d) push(s, d) show(g.get_plot()) #crea nuovi ingressi in dizionari in dizionari gobjs[idkey] = g gurls.set(idkey, s.object_link(g.get_plot())) #qui metti controllo su properties
def run_chart(exchange, asset, limit): client = pymongo.MongoClient() db = client['bitpredict_' + exchange] collection = db[asset_ + '_predictions'] def get_data(): cursor = collection.find().limit(limit).sort('_id', pymongo.DESCENDING) data = pd.DataFrame(list(cursor)) data = data.set_index('_id') data = data.sort_index(ascending=True) timestamps = pd.to_datetime(data.index, unit='s').to_series() prices = data.price predictions = data.prediction * 10000 returns = (data.position * data.change).cumsum() * 10000 return timestamps, prices, predictions, returns timestamps, prices, predictions, returns = get_data() output_server('bitpredict_' + exchange + '_extended') background = '#f2f2f2' ylabel_standoff = 0 xformatter = DatetimeTickFormatter(formats=dict(hours=["%H:%M"])) yformatter = PrintfTickFormatter(format="%8.1f") p1 = figure(title=None, plot_width=750, plot_height=300, x_axis_type='datetime', min_border_top=10, min_border_bottom=33, background_fill=background, tools='', toolbar_location=None) p1.line(x=timestamps, y=prices, name='prices', color='#4271ae', line_width=1, legend='Bitcoin Bid/Ask Midpoint', line_cap='round', line_join='round') p1.legend.orientation = 'top_left' p1.legend.border_line_color = background p1.outline_line_color = None p1.xgrid.grid_line_color = 'white' p1.ygrid.grid_line_color = 'white' p1.axis.axis_line_color = None p1.axis.major_tick_line_color = None p1.axis.minor_tick_line_color = None p1.yaxis.axis_label = 'Price' p1.yaxis.axis_label_standoff = ylabel_standoff p1.xaxis.formatter = xformatter p1.yaxis.formatter = PrintfTickFormatter(format='%8.2f') p1.yaxis.major_label_text_font = 'courier' p1.xaxis.major_label_text_font = 'courier' p2 = figure(title=None, plot_width=750, plot_height=295, x_axis_type='datetime', min_border_top=5, min_border_bottom=33, background_fill=background, tools='', toolbar_location=None) p2.line(x=timestamps, y=predictions, name='predictions', color='#c82829', line_width=1, legend='30 Second Prediction', line_cap='round', line_join='round') p2.legend.orientation = 'top_left' p2.legend.border_line_color = background p2.outline_line_color = None p2.xgrid.grid_line_color = 'white' p2.ygrid.grid_line_color = 'white' p2.axis.axis_line_color = None p2.axis.major_tick_line_color = None p2.axis.minor_tick_line_color = None p2.yaxis.axis_label = 'Basis Points' p2.yaxis.axis_label_standoff = ylabel_standoff p2.xaxis.formatter = xformatter p2.yaxis.formatter = yformatter p2.yaxis.major_label_text_font = 'courier' p2.xaxis.major_label_text_font = 'courier' p2.x_range = p1.x_range p3 = figure(title=None, plot_width=750, plot_height=320, x_axis_type='datetime', min_border_top=5, min_border_bottom=10, background_fill=background, x_axis_label='Greenwich Mean Time', tools='', toolbar_location=None) p3.line(x=timestamps, y=returns, name='returns', color='#8959a8', line_width=1, legend='Cumulative Return', line_cap='round', line_join='round') p3.legend.orientation = 'top_left' p3.legend.border_line_color = background p3.outline_line_color = None p3.xgrid.grid_line_color = 'white' p3.ygrid.grid_line_color = 'white' p3.axis.axis_line_color = None p3.axis.major_tick_line_color = None p3.axis.minor_tick_line_color = None p3.yaxis.axis_label = 'Basis Points' p3.yaxis.axis_label_standoff = ylabel_standoff p3.xaxis.formatter = xformatter p3.yaxis.formatter = yformatter p3.xaxis.axis_label_standoff = 12 p3.yaxis.major_label_text_font = 'courier' p3.xaxis.major_label_text_font = 'courier' p3.x_range = p1.x_range vp = vplot(p1, p2, p3) push() ip = load(urlopen('http://jsonip.com'))['ip'] ssn = cursession() ssn.publish() embed.autoload_server(vp, ssn, public=True) renderer = p1.select(dict(name='prices')) ds_prices = renderer[0].data_source renderer = p2.select(dict(name='predictions')) ds_predictions = renderer[0].data_source renderer = p3.select(dict(name='returns')) ds_returns = renderer[0].data_source while True: timestamps, prices, predictions, returns = get_data(exchange, limit) ds_prices.data['x'] = timestamps ds_predictions.data['x'] = timestamps ds_returns.data['x'] = timestamps ds_prices.data['y'] = prices ds_predictions.data['y'] = predictions ds_returns.data['y'] = returns ssn.store_objects(ds_prices) ssn.store_objects(ds_predictions) ssn.store_objects(ds_returns) time.sleep(60)
def do(self, which_callback, *args): for plotter in self.plotters: plotter.call() push()
def run_chart(exchange, asset, limit): client = pymongo.MongoClient() db = client['bitpredict_'+exchange] collection = db[asset_+'_predictions'] def get_data(): if (limit) cursor = collection.find() else cursor = collection.find().limit(limit) data = pd.DataFrame(list(cursor)) data = data.set_index('_id') data = data.sort_index(ascending=True) timestamps = pd.to_datetime(data.index, unit='s').to_series() returns = data.returns.cumsum()*100 return timestamps, returns timestamps, returns = get_data() output_server('bitpredict_'+exchange+'_performance') background = '#f2f2f2' ylabel_standoff = 0 xformatter = DatetimeTickFormatter(formats=dict(hours=["%H:%M"])) yformatter = PrintfTickFormatter(format="%8.1f") p = figure(title=None, plot_width=750, plot_height=500, x_axis_type='datetime', min_border_top=5, min_border_bottom=10, background_fill=background, x_axis_label='Date', tools='', toolbar_location=None) p.line(x=timestamps, y=returns, name='returns', color='#8959a8', line_width=1, legend='Cumulative Return', line_cap='round', line_join='round') p.legend.orientation = 'top_left' p.legend.border_line_color = background p.outline_line_color = None p.xgrid.grid_line_color = 'white' p.ygrid.grid_line_color = 'white' p.axis.axis_line_color = None p.axis.major_tick_line_color = None p.axis.minor_tick_line_color = None p.yaxis.axis_label = 'Percent' p.yaxis.axis_label_standoff = ylabel_standoff p.xaxis.formatter = xformatter p.yaxis.formatter = yformatter p.xaxis.axis_label_standoff = 12 p.yaxis.major_label_text_font = 'courier' p.xaxis.major_label_text_font = 'courier' push() ip = load(urlopen('http://jsonip.com'))['ip'] ssn = cursession() ssn.publish() tag = embed.autoload_server(p, ssn, public=True) renderer = p.select(dict(name='returns')) ds_returns = renderer[0].data_source while True: timestamps, returns = get_data() ds_returns.data['x'] = timestamps ds_returns.data['y'] = returns ssn.store_objects(ds_returns) time.sleep(300)
p.legend.border_line_color = background p.outline_line_color = None p.xgrid.grid_line_color = 'white' p.ygrid.grid_line_color = 'white' p.axis.axis_line_color = None p.axis.major_tick_line_color = None p.axis.minor_tick_line_color = None p.yaxis.axis_label = 'Percent' p.yaxis.axis_label_standoff = ylabel_standoff p.xaxis.formatter = xformatter p.yaxis.formatter = yformatter p.xaxis.axis_label_standoff = 12 p.yaxis.major_label_text_font = 'courier' p.xaxis.major_label_text_font = 'courier' push() ip = load(urlopen('http://jsonip.com'))['ip'] ssn = cursession() ssn.publish() tag = embed.autoload_server(p, ssn, public=True).replace('localhost', ip) html = """ {%% extends "layout.html" %%} {%% block bokeh %%} %s {%% endblock %%} """ % tag with open('templates/performance.html', 'w+') as f: f.write(html) renderer = p.select(dict(name='returns'))
def plot_bokeh(symulacja, normalized_types = False, types_to_plot = None, type_labels = None, ligand_labels = None,uniq_id="no-id"): from bokeh.plotting import figure, VBox, output_server, cursession, push, Session from bokeh.models import Range1d from bokeh.document import Document pops = symulacja[0] ligands = symulacja[1] types = symulacja[2] if types_to_plot == None: types_to_plot = types.keys() if type_labels == None: type_labels = dict([]) for k in types.keys(): type_labels[k] = k if ligand_labels == None: ligand_labels = dict([]) for k in ligands.keys(): ligand_labels[k] = k output_server("stops1"+uniq_id) len_pops = len(pops) step_axis = range(len_pops) TOOLS="resize,pan,wheel_zoom,box_zoom,reset,previewsave,poly_select" xrange1 = Range1d(start=0, end=len_pops-1) if normalized_types: #dwa wykresy - rozmiar populacji i procent komorek fig1 = figure(title="Population size",width=800, height=332,tools=TOOLS,x_range=xrange1) fig1.line(step_axis,pops,line_color = "blue",line_width=2,line_alpha=0.9) fig2 = figure(title="% of cells of specific types in the population",width=724,height=300,tools=TOOLS,x_range=xrange1) for k, v in types.items(): if k in types_to_plot: norm_sizes = [(float(v[i]) / pops[i] * 100) for i in range(len(pops))] color = lambda: random.randint(0,255) rcolor = ('#%02X%02X%02X' % (color(),color(),color())) fig2.line(step_axis, norm_sizes, line_width=2, line_color = rcolor, legend=type_labels[k]) fig2.legend.orientation = "top_right" else: fig1 = figure(title="Population / type size",width=724,height=300,tools=TOOLS,x_range=xrange1) for k, v in types.items(): if k in types_to_plot: color = lambda: random.randint(0,255) rcolor = ('#%02X%02X%02X' % (color(),color(),color())) fig1.line(step_axis, v, line_width = 2, line_color=rcolor, legend = type_labels[k]) fig1.legend.orientation = "top_right" fig1.line(step_axis, pops, line_width = 2.0, line_color = "blue", legend = "population size") fig3 = figure(title="Ligands",width=724,height=300,tools=TOOLS,x_range=xrange1) for k, v in ligands.items(): color = lambda: random.randint(0,255) rcolor = ('#%02X%02X%02X' % (color(),color(),color())) fig3.line(step_axis, v, line_width = 3, line_color = rcolor, legend = ligand_labels[k]) fig3.legend.orientation = "top_right" push() if normalized_types: p = VBox(fig1,fig2,fig3) else: p = VBox(fig1,fig3) session=cursession() return p,session