Beispiel #1
0
def plot_t_eff(dataframe):
    def create_data_source(df):
        return ColumnDataSource(data=dict(t_eff=df['t_eff'],expnum=df['expnum'],program=df['program'],attnum=df['attnum'],band=df['band'],b_eff=df['b_eff'],c_eff=df['c_eff'],f_eff=df['f_eff']))
    line_colors = ['black','blue','yellow','pink']
    plots = []
    # Creating scatter plot
    p = figure(tools = [PanTool(),BoxZoomTool(),ResizeTool(),WheelZoomTool(),ResetTool(),HoverTool(tooltips = [('expnum','@expnum'),('band','@band'),('program', '@program'),('t_eff','@t_eff'),('b_eff','@b_eff'),('c_eff','@c_eff'),('f_eff','@f_eff'),('attempt','@attnum')])], x_axis_label = "expnum", y_axis_label = "t_eff", title = 't_eff',width=1000,height=500 )
    for i,prog in enumerate(dataframe.program.unique()):
        df_false = dataframe[(dataframe['assessment']=='False') & (dataframe['program'] ==prog)]
        df_true = dataframe[(dataframe['assessment']=='True') & (dataframe['program'] ==prog)]
        df_unknown = dataframe[(dataframe['assessment']=='Unknown') & (dataframe['program']==prog)]

        p.scatter('expnum','t_eff',source=create_data_source(df_false),fill_color='red',line_color=line_colors[i],size=8,line_width=3,legend = prog)
        p.scatter('expnum','t_eff',source=create_data_source(df_true),fill_color='green',line_color=line_colors[i],size=8,line_width = 3, legend = prog)
        p.scatter('expnum','t_eff',source=create_data_source(df_unknown),fill_color='orange',line_color=line_colors[i],size=8,line_width=3,legend = prog)

    p.xaxis[0].formatter = NumeralTickFormatter(format="000000")
    plots.append(p)

    # Creating histogram
    dataframe.t_eff = dataframe.t_eff.convert_objects(convert_numeric=True)

    p2 = figure(x_axis_label = "t_eff", y_axis_label = "expnum", title = 't_eff',width=1000,height=500)

    h,edges = np.histogram(dataframe.t_eff.values, bins=np.linspace(float(min(dataframe.t_eff)),float(max(dataframe.t_eff)),35))
    p2.quad(top=h, bottom=0, left=edges[:-1], right=edges[1:], fill_color="#036564", line_color="#033649")
    text = """Mean: {mean}
            Min: {min}
            Max: {max}""".format(mean=round(dataframe.t_eff.mean(skipna=True),3),min = dataframe.t_eff.min(),max=dataframe.t_eff.max())
    mytext = glyphs.Text(x=edges[-1]-(edges[-1]/3),y=h.max()-(h.max()/3),text=[text],text_font_size='10pt')
    p2.add_glyph(mytext)

    plots.append(p2)

    return plots
        def lineChart(df, xlabel, vFields, color=None, clustered=None, title=None):
            ylabel = ','.join(v for v in vFields)
            x = list(df[xlabel].values)
            if df[xlabel].dtype == object:
                p = figure(y_axis_label=ylabel, x_axis_label=xlabel, title=title, x_range=x, **self.get_common_figure_options())
            else:
                p = figure(y_axis_label=ylabel, x_axis_label=xlabel, title=title, **self.get_common_figure_options())

            if clustered is not None:
                colors = self.colorPalette(len(df[clustered].unique())) if color is None else color
                df[clustered] = df[clustered].astype(str)

                for j,c in enumerate(list(df[clustered].unique())) if clustered else enumerate([None]):
                    df2 = df[df[clustered] == c] if c else df
                    df2 = df2.drop(clustered, axis=1) if c else df2

                    for i,v in enumerate(vFields):
                        y = list(df2[v].values)
                        l = v if self.isSubplot() else c
                        p.line(x, y, line_width=2, color=colors[i] if self.isSubplot() else colors[j], legend=l if self.showLegend() else None)
            else:
                colors = self.colorPalette(len(vFields)) if color is None else color
                

                for i,v in enumerate(vFields):
                    y = list(df[v].values)
                    p.line(x, y, line_width=2, color=colors[i], legend=v if self.showLegend() else None)

            p.legend.location = "top_left"

            hover = HoverTool()
            hover.tooltips = [(xlabel, '@x'), (ylabel, '@y{0.00}'), ('x', '$x'), ('y', '$y')]
            p.add_tools(hover)

            return p
Beispiel #3
0
def pca_plot(fp_list, clusters):
    np_fps = []
    for fp in fp_list:
        arr = numpy.zeros((1,))
        DataStructs.ConvertToNumpyArray(fp, arr)
        np_fps.append(arr)
    pca = PCA(n_components=3)
    pca.fit(np_fps)
    np_fps_r = pca.transform(np_fps)
    p1 = figure(x_axis_label="PC1",
                y_axis_label="PC2",
                title="PCA clustering of PAINS")
    p2 = figure(x_axis_label="PC2",
                y_axis_label="PC3",
                title="PCA clustering of PAINS")
    color_vector = ["blue", "red", "green", "orange", "pink", "cyan", "magenta",
                    "brown", "purple"]
    print len(set(clusters))
    for clust_num in set(clusters):
        print clust_num
        local_cluster = []
        for i in xrange(len(clusters)):
            if clusters[i] == clust_num:
                local_cluster.append(np_fps_r[i])
        print len(local_cluster)
        p1.scatter(np_fps_r[:,0], np_fps_r[:,1],
                   color=color_vector[clust_num])
        p2.scatter(np_fps_r[:,1], np_fps_r[:,2],
                   color=color_vector[clust_num])
    return HBox(p1, p2)
Beispiel #4
0
def data_retrieval():


    conn = lite.connect('/Users/shanekenny/PycharmProjects/WiFinder/app/website/WiFinderDBv02.db')
    with conn:
        df = pd.read_sql_query("SELECT W.Log_Count, W.Time, W.Hour, W.Datetime, R.RoomID, R.Capacity, C.ClassID, C.Module, C.Reg_Students, O.Occupancy, O.OccID FROM WIFI_LOGS W JOIN CLASS C ON W.ClassID = C.ClassID JOIN ROOM R ON C.Room = R.RoomID JOIN OCCUPANCY O ON C.ClassID = O.ClassID WHERE R.RoomID = 'B002' AND W.Datetime = '2015-11-12' GROUP BY W.LogID;", conn)


        df['Time'] = df['Time'].apply(pd.to_datetime)
        p = figure(width=800, height=250, x_axis_type="datetime", )
        p.extra_y_ranges = {"foo": Range1d(start=0, end=1)}

        p.line(df['Time'], df['Log_Count'],  color='red',legend='Log Count')
        p.line(df['Time'], df['Reg_Students'], color='green',legend='Registered Students')
        p.line(df['Time'], df['Capacity'], color='blue', legend='Capacity')
        p.line(df['Time'], df['Occupancy']*100, color='orange', legend='Occupancy')

        p.add_layout(LinearAxis(y_range_name="foo"), 'left')

        p2 = figure(width=800, height=250, x_axis_type="datetime", x_range=p.x_range,)
        p2.line(df['Time'], df['Log_Count'], color='red', legend='Log Count')

        r= gridplot([[p, p2]], toolbar_location=None)

        js_resources = INLINE.render_js()
        css_resources = INLINE.render_css()
        script, div = components(r)
        return flask.render_template(
            'explore.html',
            script=script,
            div=div,
            js_resources=js_resources,
            css_resources=css_resources,)
Beispiel #5
0
    def test_return_type(self):
        plot1 = figure()
        plot1.circle([], [])
        plot2 = figure()
        plot2.circle([], [])
        # This is a testing artefact, users dont' have to do this in practice
        curdoc().add_root(plot1)
        curdoc().add_root(plot2)

        r = bes.components(plot1)
        assert len(r) == 2

        _, divs = bes.components((plot1, plot2))
        assert isinstance(divs, tuple)

        _, divs = bes.components([plot1, plot2])
        assert isinstance(divs, tuple)

        _, divs = bes.components({"Plot 1": plot1, "Plot 2": plot2})
        assert isinstance(divs, dict)
        assert all(isinstance(x, string_types) for x in divs.keys())

        _, divs = bes.components(OrderedDict([("Plot 1", plot1), ("Plot 2", plot2)]))
        assert isinstance(divs, OrderedDict)
        assert all(isinstance(x, string_types) for x in divs.keys())
def bokeh2(X):
    Y = de_mean_matrix(X)    

    TOOLS="resize,crosshair,pan,wheel_zoom,box_zoom,reset,previewsave,box_select"
    
    hover = HoverTool(
        tooltips=[
            ("index", "$index"),
            ("(x,y)", "($x, $y)"),
            ("desc", "@desc"),
        ]
    )

    bplt.output_file("data.html", title="Rescaling")
    
    s1 = bplt.figure(width=500, plot_height=250, title="Data", tools=[hover, TOOLS])
    s1.scatter(X[:,0].A1, X[:,1].A1, marker="circle",
              line_color="#6666ee", fill_color="#ee6666",
              fill_alpha=0.5, size=12)
    
    s2 = bplt.figure(width=500, plot_height=250, title="De-meaned", tools=TOOLS)
    s2.scatter(Y[:,0].A1, Y[:,1].A1, marker="circle",
              line_color="#6666ee", fill_color="#ee6666",
              fill_alpha=0.5, size=12)
    
    # put all the plots in a VBox
    p = bplt.vplot(s1, s2)
    
    # show the results
    bplt.show(p)
Beispiel #7
0
def plot_3(data, ss):
    """t-SNE embedding of the parameters, colored by score
    """
    scores = np.array([d['mean_test_score'] for d in data])
    # maps each parameters to a vector of floats
    warped = np.array([ss.point_to_moe(d['parameters']) for d in data])

    # Embed into 2 dimensions with t-SNE
    X = TSNE(n_components=2).fit_transform(warped)

    e_scores = np.exp(scores)
    mine, maxe = np.min(e_scores), np.max(e_scores)
    color = (e_scores - mine) / (maxe - mine)
    mapped_colors = map(rgb2hex, cm.get_cmap('RdBu_r')(color))

    bk.figure(title='t-SNE (unsupervised)')
    bk.hold()
    df_params = nonconstant_parameters(data)
    df_params['score'] = scores
    bk.circle(
        X[:, 0], X[:, 1], color=mapped_colors, radius=1,
        source=ColumnDataSource(df_params), fill_alpha=0.6,
        line_color=None, tools=TOOLS)
    cp = bk.curplot()
    hover = cp.select(dict(type=HoverTool))
    format_tt = [(s, '@%s' % s) for s in df_params.columns]
    hover.tooltips = OrderedDict([("index", "$index")] + format_tt)

    xax, yax = bk.axis()
    xax.axis_label = 't-SNE coord 1'
    yax.axis_label = 't-SNE coord 2'
Beispiel #8
0
def main():
    xs = np.linspace(-np.pi, np.pi, 100, endpoint=True)
    xs = np.linspace(0, 4*np.pi, 100)
    ys_exp = np.exp(xs)
    ys_sin = np.sin(xs)
    ys_cos = np.sin(xs)
    ys_tan = np.tan(xs)

    output_file("grid_example.html")

    fig1 = figure(width=250, plot_height=250, title=None)
    fig1.circle(xs, ys_exp, size=10, color="navy", alpha=0.5)

    fig2 = figure(width=250, plot_height=250,
                  x_range=fig1.x_range, title=None)
    fig2.triangle(xs, ys_sin, size=10, color="firebrick", alpha=0.5)

    fig3 = figure(width=250, height=250,
                  x_range=fig2.x_range, y_range=fig2.y_range, title=None)
    fig3.square(xs, ys_cos, color="olive")

    fig4 = figure(width=250, height=250, title=None)
    fig4.line(xs, ys_tan, color="green")

    show(gridplot([[fig1, fig2],
                   [fig3, fig4]]))
Beispiel #9
0
def test_gridplot_merge_tools_with_None():
    p1, p2, p3, p4 = figure(), figure(), figure(), figure()

    gridplot([[p1, None, p2], [p3, p4, None]], merge_tools=True)

    for p in p1, p2, p3, p4:
        assert p.toolbar_location is None
Beispiel #10
0
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")

    hold()

    figure(title="Interactive plots",
           tools="pan, wheel_zoom, box_zoom, reset, previewsave",
           background_fill="#E5E5E5")
    quad(top=hist, bottom=np.zeros(len(hist)), left=edges[:-1], right=edges[1:],
         fill_color="#333333", line_color="#E5E5E5", line_width=3)

    # Use `line` renderers to display the PDF and CDF
    line(x, pdf, line_color="#348abd", line_width=8, alpha=0.7, legend="PDF")
    line(x, cdf, line_color="#7a68a6", line_width=8, alpha=0.7, legend="CDF")

    xgrid().grid_line_color = "white"
    xgrid().grid_line_width = 3
    ygrid().grid_line_color = "white"
    ygrid().grid_line_width = 3

    legend().orientation = "top_left"

    return curplot(), cursession()
Beispiel #11
0
def animated():

    from numpy import pi, cos, sin, linspace, zeros_like

    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

    cx = cy = zeros_like(rmin)

    output_server("animated_reveal")

    figure(title="Animations")

    hold()

    annular_wedge(
        cx, cy, rmin, rmax, theta[:-1], theta[1:],
        x_range=[-11, 11],
        y_range=[-11, 11],
        inner_radius_units="data",
        outer_radius_units="data",
        fill_color=colors,
        line_color="black",
        tools="pan,wheel_zoom,box_zoom,reset,previewsave"
    )

    return curplot(), cursession()
    def knit_html(self,es):
        #col1
        fig1 = figure(width=250,height=250)
        vis_bokeh.draw_1d_hist_from_es("dummy1",0,35,30,es,"run*",ax=fig1) #changes fig1, but also returns it

        fig2=figure(width=250,height=250)
        xmin,xmax = 0,65
        xbins = 20
        xname = "hcalEnergy"
        ymin,ymax = 0,65
        ybins = 20
        yname = "muonHits"
        vis_bokeh.draw_2d_hist_from_es(xname,xmin,xmax,xbins,yname,ymin,ymax,ybins,es,
                                         index="run*",ax=fig2)
        fig_column1 = vplot(fig1,fig2)

        #col2
        fig3 = figure(width=250,height=250)
        fig3=vis_bokeh.draw_1d_hist_from_es("dummy23",0,100,30,es,"run*",ax=fig3,hist_drawer="classic")
        fig4 = figure(width=250,height=250)
        fig4=vis_bokeh.draw_1d_hist_from_es("dummy45",0,40,30,es,"run*",ax=fig4)
        fig_column2 = vplot(fig3,fig4)

        fig_grid = hplot(fig_column1,fig_column2)
        
        return vis_bokeh.fig_to_html(fig_grid)
Beispiel #13
0
def animated():
    M = 5
    N = M*10 + 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

    p = figure(title="Animations", x_range=[-11, 11], y_range=[-11, 11])

    # figure() function auto-adds the figure to curdoc()
    p = figure(x_range=(-11, 11), y_range=(-11, 11))
    r = p.annular_wedge(0, 0, rmin, rmax, theta[:-1], theta[1:],
                    fill_color=colors, line_color="white")

    def update_animated(plot):
        ds = r.data_source
        rmin = roll(ds.data["inner_radius"], 1)
        rmax = roll(ds.data["outer_radius"], -1)
        ds.data.update(inner_radius=rmin, outer_radius=rmax)
        curdoc().add_periodic_callback(update_animated, 50)

    return p
Beispiel #14
0
def bokeh_plot(df):
    tooltip = """
        <div>
            <div>
                <img
                src="@image_files" height="60" alt="image"
                style="float: left; margin: 0px 15px 15px 0px; image-rendering: pixelated;"
                border="2"
                ></img>
            </div>
            <div>
                <span style="font-size: 17px;">@source_filenames</span>
            </div>
        </div>
              """
    filenames = b64_image_files(df['images'])
    df['image_files'] = filenames
    colors_raw = cm.viridis((df['time'] - df['time'].min()) /
                            (df['time'].max() - df['time'].min()), bytes=True)
    colors_str = ['#%02x%02x%02x' % tuple(c[:3]) for c in colors_raw]
    df['color'] = colors_str
    source = ColumnDataSource(df)
    bplot.output_file('plot.html')
    hover0 = HoverTool(tooltips=tooltip)
    hover1 = HoverTool(tooltips=tooltip)
    tools0 = [t() for t in TOOLS] + [hover0]
    tools1 = [t() for t in TOOLS] + [hover1]
    pca = bplot.figure(tools=tools0)
    pca.circle('PC1', 'PC2', color='color', source=source)
    tsne = bplot.figure(tools=tools1)
    tsne.circle('tSNE-0', 'tSNE-1', color='color', source=source)
    p = bplot.gridplot([[pca, tsne]])
    bplot.show(p)
Beispiel #15
0
    def __init__(self):
        xs = np.linspace(-np.pi, np.pi, 11)
        ys = xs
        Xs, Ys = np.meshgrid(xs, ys)
        self.Xs, self.Ys = Xs.flatten(), Ys.flatten()
        initdegree = 0
        mat = rot_mat(initdegree)
        transXs, transYs = mat @ np.array([self.Xs, self.Ys])

        TOOLS = "pan,lasso_select,save,reset"

        self.source = ColumnDataSource(data=dict(Xs=self.Xs, Ys=self.Ys,
                                                 transXs=transXs,
                                                 transYs=transYs))

        self.fig = figure(tools=TOOLS, title="target",
                          x_range=(-np.pi*np.sqrt(2)-1, np.pi*np.sqrt(2)+1),
                          y_range=(-np.pi*np.sqrt(2)-1, np.pi*np.sqrt(2)+1))
        self.fig.circle('Xs', 'Ys', source=self.source)

        self.transfig = figure(tools=TOOLS, title="transformed",
                               x_range=self.fig.x_range, y_range=self.fig.y_range)
        self.transfig.circle('transXs', 'transYs', source=self.source, size=6)

        self.rot_param = Slider(title="degree", value=0,
                                start=0, end=360, step=1)
        self.rot_param.on_change('value', self.update_data)

        self.plot = column(self.rot_param, gridplot([[self.fig, self.transfig]]))
def create_standard_plot(h=600, w=600, title='', x_range=None, tools='previewsave'):
    '''Create a standard plot and set consistent theme. Saves specifiying these every time.

    Args:
        h (int): The height (in pixels) of the plot.
        w (int): The width (in pixels) of the plot.
        title (str): The title of the plot.
        x_range (list): A list of variables for the x axis.
        tools (str): The tools to be displayed at the top of the chart.

    Returns:
        A plot object.

    '''

    if x_range is not None:
        plot = bp.figure(tools=tools, background_fill_color='#E5E5E5', x_range=x_range, title=title, plot_height=h, plot_width=w)
    else:
        plot = bp.figure(tools=tools, background_fill_color='#E5E5E5', title=title, plot_height=h, plot_width=w)

    plot.xgrid.grid_line_color = 'white'
    plot.ygrid.grid_line_color = 'white'
    plot.grid.grid_line_width = 1
    plot.xaxis.major_label_text_font_size='10pt'
    plot.yaxis.major_label_text_font_size='10pt'
    plot.xaxis.axis_label_text_font_size='12pt'
    plot.yaxis.axis_label_text_font_size='12pt'

    return plot
Beispiel #17
0
    def test_axis(self):
        plt.figure()
        p = plt.circle([1,2,3], [1,2,3])
        self.assertEqual(len(plt.axis()), 2)

        expected = set(plt.axis())

        ax = LinearAxis()
        expected.add(ax)
        p.above.append(ax)
        self.assertEqual(set(plt.axis()), expected)

        ax2 = LinearAxis()
        expected.add(ax2)
        p.below.append(ax2)
        self.assertEqual(set(plt.axis()), expected)

        ax3 = LinearAxis()
        expected.add(ax3)
        p.left.append(ax3)
        self.assertEqual(set(plt.axis()), expected)

        ax4 = LinearAxis()
        expected.add(ax4)
        p.right.append(ax4)
        self.assertEqual(set(plt.axis()), expected)
Beispiel #18
0
def test_gridplot_merge_tools_flat():
    p1, p2, p3, p4 = figure(), figure(), figure(), figure()

    lyt.gridplot([[p1, p2], [p3, p4]], merge_tools=True)

    for p in p1, p2, p3, p4:
        assert p.toolbar_location is None
Beispiel #19
0
def test_layout_sizing_mode(sizing_mode):
    p1, p2, p3, p4 = figure(), figure(), figure(), figure()

    lyt.layout([[p1, p2], [p3, p4]], sizing_mode=sizing_mode)

    for p in p1, p2, p3, p4:
        assert p1.sizing_mode == sizing_mode
Beispiel #20
0
    def bokeh_plot(self):
        import os
        from bokeh.plotting import line
        from bokeh.plotting import hold, figure, show, output_file
        import numpy as np
        import bokeh.embed as embed

        figure()
        hold()

        for i in self.SensorDict:
            line(
                self.SensorDict[i]['dates'], self.SensorDict[i]['values']
            )
            print(len(self.SensorDict[i]['dates']))
            #print(self.SensorDict[i]['dates'][0])
            #print(self.SensorDict[i]['values'][0])
        print('tjo')
        os.chdir('..')
        os.chdir('..')

        output_file('plot.html', title='Plot22')




        show()
def create_plot(team="LAA", year=2012):
    expr = bz.by(db.Salaries.teamID,
                 avg=db.Salaries.salary.mean(),
                 max=db.Salaries.salary.max(),
                 ratio=db.Salaries.salary.max() / db.Salaries.salary.min())
    expr = expr.sort('ratio', ascending=False)

    df_salary_gb = into(pd.DataFrame, expr)
    source1 = into(ColumnDataSource, df_salary_gb[["teamID", "avg"]])

    plot1 = plt.figure(title="Salary ratio by team", x_range=list(df_salary_gb["teamID"]))
    plot1.scatter(x="teamID", y="avg", source=source1, size=20)
    plot1.xaxis.major_label_orientation = np.pi/3

    df = into(pd.DataFrame, db.Salaries)
    df = df[df["teamID"] == team]
    df = df[df["yearID"] == year]

    df = df[["playerID","salary"]].sort('salary')
    source_team = into(ColumnDataSource, df)
    p_team = plt.figure(title="Salary of players for %s during %s" % (team, year),
                        x_range=list(df["playerID"]))#, tools=TOOLS)
    p_team.scatter(x="playerID", y="salary", source=source_team, size=20)
    p_team.xaxis.major_label_orientation = np.pi/3

    p = plt.gridplot([[plot1, p_team]])
    return p
def bokeh_brushed():
    """these are taken EXACTLY from
    http://bokeh.pydata.org/en/latest/docs/user_guide/quickstart.html

    """
    # prepare some date
    N = 300
    x = np.linspace(0, 4*np.pi, N)
    y0 = np.sin(x)
    y1 = np.cos(x)

    # NEW: create a column data source for the plots to share
    source = bkm.ColumnDataSource(data=dict(x=x, y0=y0, y1=y1))

    # create a new plot and add a renderer
    left = bkp.figure(tools=BOKEH_TOOLS, width=350, height=350, title=None)
    left.circle('x', 'y0', source=source)

    # create another new plot and add a renderer
    right = bkp.figure(tools=BOKEH_TOOLS, width=350, height=350, title=None)
    right.circle('x', 'y1', source=source)

    # put the subplots in a gridplot
    p = bkp.gridplot([[left, right]])

    return bke.components(p)
Beispiel #23
0
 def __init__(self, size):
     self.size = size
     
     self.time = RingBuffer(size)
     self.i_corr = RingBuffer(size)
     self.q_corr = RingBuffer(size)
     self.phase_error = RingBuffer(size)
     self.delay_error = RingBuffer(size)
     
     plot = figure(title='i corr', plot_width=250, plot_height=250, tools="pan,wheel_zoom,box_zoom,reset,save")
     plot.line(self.time.get(), self.i_corr.get(), size=12, alpha=0.7, name='i_corr')
     self.i_corr_plot = plot
     
     plot = figure(title='q corr', plot_width=250, plot_height=250, tools="pan,wheel_zoom,box_zoom,reset,save")
     plot.line(self.time.get(), self.q_corr.get(), size=12, alpha=0.7, name='q_corr')
     self.q_corr_plot = plot
     
     plot = figure(title='phase error', plot_width=250, plot_height=250, tools="pan,wheel_zoom,box_zoom,reset,save")
     plot.line(self.time.get(), self.phase_error.get(), size=12, alpha=0.7, name='phase_error')
     self.phase_error_plot = plot
     
     plot = figure(title='delay error', plot_width=250, plot_height=250, tools="pan,wheel_zoom,box_zoom,reset,save")
     plot.line(self.time.get(), self.delay_error.get(), size=12, alpha=0.7, name='delay_error')
     self.delay_error_plot = plot
     
     children = [self.i_corr_plot, self.q_corr_plot, self.phase_error_plot, self.delay_error_plot]
     self.plot = hplot(*children, name="tracking outputs")
def pca(target, control, title, name_one, name_two):
    np_fps = []
    for fp in target + control:
        arr = numpy.zeros((1,))
        DataStructs.ConvertToNumpyArray(fp, arr)
        np_fps.append(arr)
    ys_fit = [1] * len(target) + [0] * len(control)
    names = ["PAINS", "Control"]
    pca = PCA(n_components=3)
    pca.fit(np_fps)
    np_fps_r = pca.transform(np_fps)
    p1 = figure(x_axis_label="PC1",
                y_axis_label="PC2",
                title=title)
    p1.scatter(np_fps_r[:len(target), 0], np_fps_r[:len(target), 1],
               color="blue", legend=name_one)
    p1.scatter(np_fps_r[len(target):, 0], np_fps_r[len(target):, 1],
               color="red", legend=name_two)
    p2 = figure(x_axis_label="PC2",
                y_axis_label="PC3",
                title=title)
    p2.scatter(np_fps_r[:len(target), 1], np_fps_r[:len(target), 2],
               color="blue", legend=name_one)
    p2.scatter(np_fps_r[len(target):, 1], np_fps_r[len(target):, 2],
               color="red", legend=name_two)
    return HBox(p1, p2)
 def __init__(self, predit_funct=None):
     Callback.__init__(self)
     # output_notebook()
     self.loss = np.array([])
     self.psnrs = np.array([])
     output_server("line")
     self.imagew = 512
     self.min_loss = 10000
     self.predit_funct = predit_funct
     self.p = figure()
     self.p2 = figure()
     self.x = np.array([])
     self.y = np.array([])
     self.bx = np.array([])
     self.by = np.array([])
     self.cx = np.array([])
     self.epochNo = 0
     self.p.line(self.x, self.y, name='line', color="tomato", line_width=2)
     self.p.line(self.bx, self.by, name='batch_line', color="blue", line_width=2)
     self.p2.line(self.cx, self.psnrs, name='psnr', color="green", line_width=2)
     show(self.p)
     # show(self.p2)
     # self.p2 = figure(x_range=[0, self.imagew], y_range=[0, self.imagew])
     # self.p2.image_rgba(name='image', image=[np.array((self.imagew, self.imagew), dtype='uint32')], x=0, y=0, dw=self.imagew, dh=self.imagew)
     # show(self.p2)
     self.psnr = 0
Beispiel #26
0
def plot_hist(values, logx=False, title=""):
    """Plot bokeh histograms"""
    t = "{2} distribution (μ={0:.2f}, σ={0:.2f})".format(
        np.mean(values), np.std(values), title)
    if logx:
        p1 = figure(title=t, x_axis_type="log")
        p1.xaxis.axis_label = 'Log(x)'
    else:
        p1 = figure(title=t)
        p1.xaxis.axis_label = 'x'

    hist, edges = np.histogram(values, density=True, bins='fd')

    p1.quad(top=hist, bottom=0, left=edges[:-1], right=edges[1:],
            fill_color="#036564", line_color="#036564")
    p1.legend.location = "center_right"
    p1.legend.background_fill_color = "darkgrey"
    p1.yaxis.axis_label = 'Pr(x)'

    p1.xaxis.major_label_text_font = 'helvetica'
    p1.yaxis.major_label_text_font = 'helvetica'
    p1.title.text_font = 'helvetica'
    p1.xaxis.axis_label_text_font = 'helvetica'

    return p1
Beispiel #27
0
 def make_trip_distance_histogram(self):
     bins = self.trip_distance_bins
     centers = pd.rolling_mean(bins, 2)[1:]
     figure(title="trip distance in miles",
            title_text_font='12pt',
            plot_width=300,
            plot_height=200,
            x_range=[bins[0], bins[-1]],
            y_range=[0, 1],
            tools="pan,wheel_zoom,box_zoom,select,reset"
     )
     source = HistogramDataSource(
         data_url="/bokeh/taxidata/distancehist/",
     )
     hold()
     plot = rect("centers", "y", np.mean(np.diff(centers)) * 0.7, "counts",
                 source=source)
     self.trip_distance_source = plot.select({'type' : ColumnDataSource})[0]
     self.trip_distance_ar_source = source
     plot.min_border=0
     plot.h_symmetry=False
     plot.v_symmetry=False
     select_tool = _get_select_tool(plot)
     if select_tool:
         select_tool.dimensions = ['width']
     self.distance_histogram = plot
Beispiel #28
0
def plot_circle_density(nodes, degrees, plot_width=800, plot_height=800):
    print("Plotting circle density graph")
    TOOLS="hover,pan,wheel_zoom,box_zoom,reset,click,previewsave"    
    plt.figure(plot_width=plot_width, plot_height=plot_height, tools=TOOLS)
    theta = np.random.uniform(0, 2*np.pi, size=len(nodes))
    max_d, min_d = np.max(degrees), np.min(degrees)
    scale = 1.0/np.log(degrees) - 1.0/np.log(max_d)
    xs = np.cos(theta)*scale
    ys = np.sin(theta)*scale
    source_dict = dict(
        xs = xs,
        ys = ys,
        degrees = degrees,
        nodes = nodes,
        alphas = np.log(degrees)/np.log(max(degrees)),
    )
    source = ColumnDataSource(source_dict)
    plt.hold(True)
    plt.circle('xs', 'ys', source=source,
               radius=0.0025,
               fill_alpha='alphas',
               x_axis_type=None, y_axis_type=None, 
               title="Density Distribution of Degrees")
    plt.text([max(xs), max(xs)], 
             [.95*max(ys), .85*max(ys)], 
             ["distance from center = 1 / log(deg)",
              "angle = random"], 
             angle=0,
             text_baseline="bottom", text_align="right")
    hover = [t for t in plt.curplot().tools if isinstance(t, HoverTool)][0]
    hover.tooltips = OrderedDict([
        ('node', '@nodes'), ('degree', '@degrees')
    ])
    plt.hold(False)
    return plt.curplot()
Beispiel #29
0
 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 bokeh_linked():
    """these are taken EXACTLY from
    http://bokeh.pydata.org/en/latest/docs/user_guide/quickstart.html

    """
    # prepare some data
    N = 100
    x = np.linspace(0, 4*np.pi, N)
    y0 = np.sin(x)
    y1 = np.cos(x)
    y2 = np.sin(x) + np.cos(x)

    # create a new plot
    s1 = bkp.figure(width=250, plot_height=250, title=None)
    s1.circle(x, y0, size=10, color="navy", alpha=0.5)

    # NEW: create a new plot and share both ranges
    s2 = bkp.figure(
        x_range=s1.x_range, y_range=s1.y_range, width=250, plot_height=250,
        title=None
    )
    s2.triangle(x, y1, size=10, color="firebrick", alpha=0.5)

    # NEW: create a new plot and share only one range
    s3 = bkp.figure(x_range=s1.x_range, width=250, plot_height=250, title=None)
    s3.square(x, y2, size=10, color="olive", alpha=0.5)

    # NEW: put the subplots in a gridplot
    p = bkp.gridplot([[s1, s2, s3]], toolbar_location=None)

    return bke.components(p)
Beispiel #31
0
    39.56752, 39.36423, 39.22605, 39.11656, 38.95788, 38.81393, 38.60929,
    38.40118, 38.21500, 38.21472, 38.10272, 37.97469, 37.78990, 37.56670,
    37.35363, 37.20443, 37.09597, 37.01706, 36.99908, 36.99908, 36.99926,
    36.99910, 36.99831, 36.99845, 36.99828, 37.00383, 37.00325, 37.00247,
    37.00102, 37.00147, 37.00166, 37.00097, 37.00105, 37.00094, 37.00048,
    37.00012, 37.00017, 37.00022, 36.99998, 36.99998, 36.99998, 36.99998,
    36.99998, 36.99998, 37.00040, 37.00040, 37.13439, 37.47222, 37.70735,
    37.77873, 37.95499, 38.20495, 38.55049, 38.75165, 38.90545, 39.08777,
    39.23851, 39.36296, 39.45715, 39.61018, 39.75817, 39.99994, 40.09896,
    40.30302, 40.49580
]

from bokeh.plotting import figure
from bokeh.io import output_file, show

p = figure(x_axis_label='longtitude (degrees)',
           y_axis_label='latitude (degrees)')
'''
INSTRUCTIONS

*   Create a list of the longitude positions for each state as x. This has already been done for you.
*   Create a list of the latitude positions for each state as y. The variable names for the latitude positions are az_lats, co_lats, nm_lats, and ut_lats.
*   Use p.patches() to add the patches glyph to the figure p. Supply the x and y lists as arguments along with a line_color of 'white'.
'''

# Create a list of az_lons, co_lons, nm_lons and ut_lons: x
x = [az_lons, co_lons, nm_lons, ut_lons]

# Create a list of az_lats, co_lats, nm_lats and ut_lats: y
y = [az_lats, co_lats, nm_lats, ut_lats]

# Add patches to figure p with line_color=white for x and y
Beispiel #32
0
import numpy as np

from bokeh.layouts import row, widgetbox
from bokeh.models import CustomJS, Slider
from bokeh.plotting import figure, output_file, show, ColumnDataSource

A1 = -14.72757
A2 = 79.9554
x0 = 7.74771
dx = 0.41551

x = np.linspace(9.5, 6, 100)
y = A2 + (A1 - A2) / (1 + np.exp((x - x0) / dx))
plot = figure(y_range=(-24, 90), plot_width=400, plot_height=400)

plot.line(x, y, line_width=3, line_alpha=0.6)

x = [9]
y = [A2 + (A1 - A2) / (1 + np.exp((x[0] - x0) / dx))]
source = ColumnDataSource(
    data=dict(x=x, y=y, time_left=[f'{y[0]:.0f} hours'], text_color=['green']))
plot.circle('x', 'y', source=source, color='red', size=10)
plot.text(8.5,
          -7,
          text='time_left',
          text_color='text_color',
          alpha=0.6667,
          text_font_size='36pt',
          text_baseline='middle',
          text_align='center',
          source=source)
Beispiel #33
0
from bokeh.plotting import figure, output_file, show

if __name__ == '__main__':
    output_file('graficado_simple.html')
    fig = figure()

    total_vals = int(input('Cuantos valores quieres graficar'))

    x_vals = list(range(total_vals))

    y_vals = []

    for x in x_vals:
        val = int(input(f'Valor y para la x {x}'))
        y_vals.append(val)

    fig.line(x_vals, y_vals, line_width=2)

    show(fig)
Beispiel #34
0
 def image(self, *kargs, **kwargs):
     fig = figure()
     fig.image(*kargs, **kwargs)
     self.figures.append(fig)
Beispiel #35
0
import numpy as np
from numpy import pi

from bokeh.client import push_session
from bokeh.driving import cosine
from bokeh.plotting import figure, curdoc

x = np.linspace(0, 4 * pi, 80)
y = np.sin(x)

p = figure()
r1 = p.line([0, 4 * pi], [-1, 1], color="firebrick")
r2 = p.line(x, y, color="navy", line_width=4)

# open a session to keep our local document in sync with server
session = push_session(curdoc())


@cosine(w=0.03)
def update(step):
    # updating a single column of the the *same length* is OK
    r2.data_source.data["y"] = y * step
    r2.glyph.line_alpha = 1 - 0.8 * abs(step)


curdoc().add_periodic_callback(update, 50)

session.show(p)  # open the document in a browser

session.loop_until_closed()  # run forever
Beispiel #36
0
from bokeh.sampledata.iris import flowers

from bokeh.plotting import figure, output_file, save
from bokeh.models import ColumnDataSource, HoverTool

colormap = {'setosa': 'red', 'versicolor': 'green', 'virginica': 'blue'}
flowers['colors'] = [colormap[x] for x in flowers['species']]

hover = HoverTool(
    tooltips=[("Sepal length", "@sepal_length"), (
        "Sepal width",
        "@sepal_width"), ("Petal length",
                          "@petal_length"), ("Species", "@species")])

p = figure(title="Iris Morphology",
           plot_height=500,
           plot_width=500,
           tools=[hover, "pan,reset,wheel_zoom"])

p.xaxis.axis_label = 'Petal Length'
p.yaxis.axis_label = 'Petal Width'

p.circle('petal_length',
         'petal_width',
         color='colors',
         fill_alpha=0.2,
         size=10,
         source=ColumnDataSource(flowers))

output_file("docs/index.html", title="Iris Morphology")
save(p)
Beispiel #37
0
symbol = 'AAPL'

start = datetime.datetime(2015, 1, 1)
end = datetime.datetime(2016, 1, 1)

df = data.DataReader(name=symbol, data_source="yahoo", start=start, end=end)

inc = df.Close > df.Open
dec = df.Open > df.Close
w = 12 * 60 * 60 * 1000  #half day in milliseconds

TOOLS = "pan,wheel_zoom,box_zoom,reset,save"

p = figure(x_axis_type="datetime",
           tools=TOOLS,
           plot_width=1000,
           title="AAPL Candlestick")

p.segment(df.index, df.High, df.index, df.Low, color="black")
#p.vbar(df.index[inc], w, df.Open[inc], df.Close[inc], color="#32CD32", line_color="green")
#p.vbar(df.index[dec], w, df.Open[dec], df.Close[dec], color="#FF4500", line_color="red")

p.rect(df.index[inc], (df.Open[inc] + df.Close[inc]) / 2,
       w,
       df.Close[inc] - df.Open[inc],
       fill_color="green")
p.rect(df.index[dec], (df.Open[dec] + df.Close[dec]) / 2,
       w,
       df.Open[dec] - df.Close[dec],
       fill_color="red")
Beispiel #38
0
def get_boxplot():
    # generate some synthetic time series for six different categories
    cats = list("abcdef")
    yy = np.random.randn(2000)
    g = np.random.choice(cats, 2000)
    for i, l in enumerate(cats):
        yy[g == l] += i // 2
    df = pd.DataFrame(dict(score=yy, group=g))

    # find the quartiles and IQR for each category
    groups = df.groupby('group')
    q1 = groups.quantile(q=0.25)
    q2 = groups.quantile(q=0.5)
    q3 = groups.quantile(q=0.75)
    iqr = q3 - q1
    upper = q3 + 1.5 * iqr
    lower = q1 - 1.5 * iqr

    # find the outliers for each category
    def outliers(group):
        cat = group.name
        return group[(group.score > upper.loc[cat]['score']) |
                     (group.score < lower.loc[cat]['score'])]['score']

    out = groups.apply(outliers).dropna()

    # prepare outlier data for plotting, we need coordinates for every outlier.
    if not out.empty:
        outx = []
        outy = []
        for keys in out.index:
            outx.append(keys[0])
            outy.append(out.loc[keys[0]].loc[keys[1]])

    p = figure(tools="",
               background_fill_color="#efefef",
               x_range=cats,
               toolbar_location=None)

    # if no outliers, shrink lengths of stems to be no longer than the minimums or maximums
    qmin = groups.quantile(q=0.00)
    qmax = groups.quantile(q=1.00)
    upper.score = [
        min([x, y]) for (x, y) in zip(list(qmax.loc[:, 'score']), upper.score)
    ]
    lower.score = [
        max([x, y]) for (x, y) in zip(list(qmin.loc[:, 'score']), lower.score)
    ]

    # stems
    p.segment(cats, upper.score, cats, q3.score, line_color="black")
    p.segment(cats, lower.score, cats, q1.score, line_color="black")

    # boxes
    p.vbar(cats,
           0.7,
           q2.score,
           q3.score,
           fill_color="#E08E79",
           line_color="black")
    p.vbar(cats,
           0.7,
           q1.score,
           q2.score,
           fill_color="#3B8686",
           line_color="black")

    # whiskers (almost-0 height rects simpler than segments)
    p.rect(cats, lower.score, 0.2, 0.01, line_color="black")
    p.rect(cats, upper.score, 0.2, 0.01, line_color="black")

    # outliers
    if not out.empty:
        p.circle(outx, outy, size=6, color="#F38630", fill_alpha=0.6)

    p.xgrid.grid_line_color = None
    p.ygrid.grid_line_color = "white"
    p.grid.grid_line_width = 2
    p.xaxis.major_label_text_font_size = "12pt"

    return p
from bokeh.plotting import figure, output_file, show
import numpy as np

# prepare some data
x = np.linspace(0, 2.0 * np.pi, 101)
sine = np.sin(x)
cosine = np.cos(x)

# output to static HTML file
output_file("lines.html")

# create a new plot with a title and axis labels
p = figure(title="simple sine curve", x_axis_label='x', y_axis_label='y')

# add a line renderer with legend and line thickness
p.line(x, sine, legend="$\sin$", line_width=2, color='red')
p.line(x, cosine, legend="$\cos$", line_width=2, color='green')

# show the results
show(p)
Beispiel #40
0
from bokeh.io import curdoc, reset_output
from bokeh.layouts import row, column, widgetbox
from bokeh.models import ColumnDataSource, CustomJS
from bokeh.models.widgets import Slider, Dropdown, CheckboxButtonGroup, RadioButtonGroup
from bokeh.plotting import figure

import utils.utils as util
#Init variables
data_directory = "/Users/Jingwei/PycharmProjects/distributed_use/venv/TestDataset/UCR_TS_Archive_2015"
dataset = data_directory + "/FordA/FordA_TRAIN"
t_stamp = 0
window_size = 5
forget_degree = 0
TSClass = None
plot_window = figure(plot_height=150,
                     plot_width=500,
                     title='New Incoming TS micro-batch',
                     tools="reset")
plot_all = figure(plot_height=150, plot_width=500, title='All historical TS')

# Set up widgets
menu_C = [("Normal", "Class: 1"), ("Abnormal", "Class: -1")]
class_select = Dropdown(label="Select Class",
                        button_type="success",
                        menu=menu_C)
winSize_slider = Slider(start=0, end=20, value=5, step=1, title="Window Size")
fDegree_slider = Slider(start=0,
                        end=20,
                        value=5,
                        step=1,
                        title="Forgetting Degree")
Beispiel #41
0
def GainLossPlot(tblGainLoss):
    tblGainLoss['strDate'] = tblGainLoss['timestamp'].dt.strftime(
        '%Y-%m-%d %H:%M')
    tblGainLoss['pp_PriceDelta'] = tblGainLoss['PriceDelta'].round(2).astype(
        str)
    gain_source = ColumnDataSource(tblGainLoss[tblGainLoss['PriceDelta'] < 0])
    loss_source = ColumnDataSource(tblGainLoss[tblGainLoss['PriceDelta'] >= 0])
    gnl_source = ColumnDataSource(tblGainLoss)

    hover = HoverTool(
        tooltips=[
            ('Date:', '@strDate'),
            ('Net Gain/Loss:',
             '$@pp_PriceDelta'),  # use @{ } for field names with spaces
        ],
        formatters={
            'Date:': 'datetime',
        },

        # display a tooltip whenever the cursor is vertically in line with a glyph
        mode='vline',
        names=['line', 'buy'])

    tools = [hover, WheelZoomTool(), 'box_zoom', 'pan', LassoSelectTool()]
    gain_loss_plot = figure(
        x_axis_type="datetime",
        title="Net Performance Accross All Owned CryptoCurrencies",
        y_range=(0, 10000),
        plot_width=1000,
        plot_height=400,
        tools=tools)

    gain_loss_plot.grid.grid_line_alpha = 0.2
    gain_loss_plot.xaxis.axis_label = 'Date'
    gain_loss_plot.yaxis.axis_label = 'Net Gain/Loss (USD)'
    gain_loss_plot.line('timestamp',
                        'PriceDelta',
                        color='darkgrey',
                        alpha=0.3,
                        name="line",
                        source=gnl_source)
    gain_loss_plot.circle('timestamp',
                          'PriceDelta',
                          size=4,
                          legend='Gains',
                          color='black',
                          alpha=0.6,
                          source=loss_source)
    gain_loss_plot.circle('timestamp',
                          'PriceDelta',
                          size=4,
                          legend='Losses',
                          color='darkred',
                          alpha=0.6,
                          source=gain_source)
    zero = Span(location=0,
                dimension='width',
                line_color='grey',
                line_dash='solid',
                line_width=0.5,
                name='buy')

    gain_loss_plot.add_layout(zero)
    gain_loss_plot.legend.location = "top_left"
    return gain_loss_plot
Beispiel #42
0
def make_box(area):
    a = get_data(area)
    h = np.array(a['F(Horiba)'],
                 dtype=float)[~np.isnan(np.array(a['F(Horiba)']))]
    m = np.array(a['F(Merck)'])[~np.isnan(np.array(a['F(Merck)']))]
    raw_data = {
        'device': ['Horiba', 'Merck'],
        'high': [max(h), max(m)],
        'low': [min(h), min(m)],
        'average': [
            float(x)
            for x in ['{:01.2f}'.format(y)
                      for y in [np.mean(h), np.mean(m)]]
        ],
        'color': ["#0d3362", "#c64737"],
        'text': ['Average of F(Horiba)', 'Average of F(Merck)'],
        'size': [np.mean(h) * 10, np.mean(m) * 10]
    }
    df = pd.DataFrame(
        raw_data,
        columns=['device', 'high', 'low', 'average', 'color', 'text', 'size'])
    source = ColumnDataSource(data=df)
    box = figure(title='Result differences based on Mobilab',
                 y_axis_label="Diference degree = F(x)",
                 x_axis_label='Devices',
                 x_range=np.array(df.device),
                 y_range=(-1, 20),
                 plot_width=340,
                 plot_height=350,
                 toolbar_location=None)
    box.grid.grid_line_alpha = 1
    box.segment('device',
                'high',
                'device',
                'low',
                color='color',
                source=source)
    box.rect('device', 'low', 0.2, 0.01, line_color='color', source=source)
    box.rect('device', 'high', 0.2, 0.01, line_color='color', source=source)
    box.circle('device',
               'average',
               size='size',
               color='color',
               source=source,
               legend='text')
    labels = LabelSet(x="device",
                      y="average",
                      text="average",
                      x_offset=0,
                      y_offset=-4,
                      text_font_size="7pt",
                      text_color="white",
                      source=source,
                      text_align='center')
    box.add_layout(labels)
    citation = Label(
        x=10,
        y=-60,
        x_units='screen',
        y_units='screen',
        text=
        "F(x)=|result from Mobilab-result from 'x'| Conclusion: Horiba is more similar than Merck",
        render_mode='css',
        border_line_color='white',
        border_line_alpha=1.0,
        background_fill_color='white',
        background_fill_alpha=1.0)
    box.add_layout(citation)
    return box
def plot(df):
    source = ColumnDataSource(df)

    # Setting up colors by mapper (linear_cmap function)
    palette = [cc.rainbow[i * 15] for i in range(17)]
    mini, maxi = min(df['xG_diff']), max(df['xG_diff'])

    if abs(min(df['xG_diff'])) > abs(max(df['xG_diff'])):
        mini, maxi = min(df['xG_diff']), -min(df['xG_diff'])
    else:
        mini, maxi = -max(df['xG_diff']), max(df['xG_diff'])

    mapper = linear_cmap(field_name='xG_diff',
                         palette=palette,
                         low=mini,
                         high=maxi)

    # Tooltips
    tooltips = [("Name", "@player_name"), ("Games", "@games"),
                ("Goals", "@goals"), ("xG", "@xG"),
                ("(xG - goals)", "@xG_diff")]

    # Draw plot
    p = figure(
        title=
        "Premier League - difference between xG and goals (last 5 games or 30 days ago)",
        x_range=df['player_name'],
        height=800,
        width=1600)  # x_range !!! do source?

    # Title style
    p.title.text_color = "#dddddd"
    p.title.text_font = "Consolas"
    p.title.text_font_size = '24px'
    p.title.align = 'center'

    # Displaying data on plot
    r1 = p.circle("player_name", "xG", size=10, color=mapper,
                  source=source)  # xG (circles)
    r2 = p.square('player_name',
                  'goals',
                  size=10,
                  fill_color=mapper,
                  line_color=None,
                  source=source)  # goals (rectangle)
    r3 = p.segment('player_name',
                   'xG',
                   'player_name',
                   'goals',
                   color=mapper,
                   source=source)  # xG - goals (lines)

    # Styling plot
    p.yaxis.axis_label = 'Goals and xG'
    p.yaxis.axis_label_text_color = '#dddddd'  # color of y label text
    p.yaxis.axis_label_text_font = 'Consolas'
    p.xaxis.major_label_orientation = pi / 4

    p.axis.major_label_text_color = '#dddddd'  # color of axis's values
    p.axis.major_label_text_font = 'Consolas'
    p.axis.axis_line_color = '#dddddd'

    p.border_fill_color = "#1b1b1b"
    p.background_fill_color = "#1b1b1b"

    p.grid.grid_line_color = "#242424"

    p.min_border_top = 40
    p.min_border_left = 60

    # Legend
    legend = Legend(items=[
        LegendItem(label='xG', renderers=[r1]),
        LegendItem(label='goals', renderers=[r2]),
        LegendItem(label='(xG - goals)', renderers=[r3])
    ],
                    background_fill_color="#1b1b1b",
                    label_text_color='#dddddd',
                    label_text_font='Consolas')

    p.add_layout(legend, 'right')
    p.legend.click_policy = "hide"

    # HoverTool
    on_hover = HoverTool(renderers=[r1, r2], tooltips=tooltips)
    p.add_tools(on_hover)

    # Show plot on screen and save it to file
    show(p)
    output_file("data/Premier_League_goals_and_xG_difference.html",
                title="Premier League - difference between goals and xG")
    save(p)
Beispiel #44
0
def WalletPlot(coinHistory):
    coinHistory['PercentCoin'] = coinHistory['coins_transacted'] / coinHistory[
        'coins_transacted'].sum()
    coinHistory['PercentUSD_Purchase'] = coinHistory[
        'price_at_transaction'] / coinHistory['price_at_transaction'].sum()
    coinHistory['PercentUSD_Current'] = coinHistory[
        'CurrentPrice'] / coinHistory['CurrentPrice'].sum()
    coinHistory['NetGainLoss'] = coinHistory[
        'CurrentWalletVallue'] - coinHistory['USD_In']

    currentValue = coinHistory.sort_values('NetGainLoss').groupby('name').sum()
    coinName = []
    coinPriceStart = []
    coinPriceStop = []
    coinNet = []
    coinCurrent = []
    colors = []
    amount = []
    previousCoin = 0

    coins = list(set(coinHistory.name))
    numCoins = len(coins)
    for coin, price, net, amt, color in zip(currentValue.index,
                                            currentValue.CurrentWalletVallue,
                                            currentValue.NetGainLoss,
                                            currentValue.coins_transacted,
                                            Category20[numCoins]):
        coinName.append(coin)
        coinPriceStart.append(previousCoin)
        coinPriceStop.append(previousCoin + price)
        colors.append(color)
        coinNet.append(net)
        amount.append(amt)
        coinCurrent.append(price)
        previousCoin += price

    percent_gainloss = []

    colors = []  # yea i know I'll fix it
    for c in coinName:
        colors.append(colorDict[c])

    # do some rounding and convert to string to make things look better.
    pp_coinCurrent = [str(float("{:.2f}".format(X))) for X in coinCurrent]
    pp_coinNet = [str(float("{:.2f}".format(X))) for X in coinNet]
    pp_amount = [str(float("{:.5f}".format(X))) for X in amount]

    totalDollars = {
        'Coin': coinName,
        'PriceStart': coinPriceStart,
        'PriceStop': coinPriceStop,
        'Color': colors,
        'Net': coinNet,
        'Amount': amount,
        'Current': coinCurrent,
        'pp_Net': pp_coinNet,
        'pp_Amount': pp_amount,
        'pp_Current': pp_coinCurrent,
        'Position': [0 for x in range(len(coinName))]
    }
    print(totalDollars)
    hover = HoverTool(tooltips=[('Coin:', '@Coin'),
                                ('Amount Owned:', '@pp_Amount'),
                                ('Current Value (USD):', '$@pp_Current'),
                                ('Net Gain/Loss:', '$@pp_Net')], )
    source = ColumnDataSource(data=totalDollars)

    total_balance = int(coinHistory['CurrentWalletVallue'].sum())
    coinBar = figure(plot_width=200,
                     plot_height=800,
                     tools=[hover],
                     y_range=(0, total_balance + 500),
                     toolbar_location=None)

    coinBar.vbar(x='Position',
                 width=0.5,
                 bottom='PriceStart',
                 top='PriceStop',
                 color='Color',
                 source=source)
    money_invested = Span(location=coinHistory['USD_In'].sum(),
                          dimension='width',
                          line_color='black',
                          line_dash='dashed',
                          line_width=3)

    money_inValue = '$' + str(
        float("{:.2f}".format(coinHistory['USD_In'].sum())))
    cValue = '$' + str(
        float("{:.2f}".format(coinHistory['CurrentWalletVallue'].sum())))

    # money_inValueText = Label(x=0.25, y=coinHistory['USD_In'].sum() , x_units='screen', text=money_inValue, render_mode='css',
    #   border_line_color='black', border_line_alpha=0.0,
    #   background_fill_color='white', background_fill_alpha=0.0)

    currentValueText = Label(x=50,
                             y=coinHistory['CurrentWalletVallue'].sum(),
                             x_units='screen',
                             text=cValue,
                             render_mode='css',
                             border_line_color='black',
                             border_line_alpha=0.0,
                             background_fill_color='white',
                             background_fill_alpha=0.0)

    coinBar.add_layout(money_invested)
    coinBar.add_layout(currentValueText)
    # coinBar.add_layout(money_inValueText)
    coinBar.xaxis.visible = False
    coinBar.yaxis.visible = False
    coinBar.xgrid.grid_line_color = None
    coinBar.ygrid.grid_line_color = None

    return coinBar
Beispiel #45
0
    def _stacked_hist(dataframe,
                      x_col,
                      stack_col,
                      x_label,
                      width,
                      height,
                      x_range=None,
                      y_range=None):
        data = {"x": sorted(dataframe[x_col].unique().astype(str))}
        for stack_value in dataframe[stack_col].unique():
            x_values = dataframe.groupby(stack_col).get_group(
                stack_value).groupby(x_col).count()
            data[str(stack_value)] = [
                float(x_values[x_values.index == i][stack_col].values)
                if i in x_values.index else 0
                for i in sorted(dataframe[x_col].unique())
            ]
        colors = Category20[dataframe[stack_col].nunique()] if (
            2 < dataframe[stack_col].nunique() < 21) else viridis(
                dataframe[stack_col].nunique())
        legend = [
            stack_col + ": " + i
            for i in dataframe[stack_col].unique().astype(str).tolist()
        ]

        if x_range is None and y_range is None:
            p = figure(x_range=sorted(dataframe[x_col].unique().astype(str)),
                       height=height,
                       width=width,
                       toolbar_location=None,
                       tools="",
                       tooltips="$name: @$name")
        elif x_range is None and y_range is not None:
            p = figure(x_range=sorted(dataframe[x_col].unique().astype(str)),
                       y_range=y_range,
                       height=height,
                       width=width,
                       toolbar_location=None,
                       tools="",
                       tooltips="$name: @$name")
        elif x_range is not None and y_range is None:
            p = figure(x_range=x_range,
                       height=height,
                       width=width,
                       toolbar_location=None,
                       tools="",
                       tooltips="$name: @$name")
        else:
            p = figure(x_range=x_range,
                       y_range=y_range,
                       height=height,
                       width=width,
                       toolbar_location=None,
                       tools="",
                       tooltips="$name: @$name")
        p.vbar_stack(sorted(dataframe[stack_col].unique().astype(str)),
                     x="x",
                     source=pd.DataFrame(data),
                     color=colors,
                     width=0.8,
                     legend_label=legend)
        p.xaxis.axis_label = x_label
        p.yaxis.axis_label = "Counts"
        p.js_on_event(events.DoubleTap, toggle_legend_js(p))
        p.legend.click_policy = "hide"
        return p
    def trend_chart(self,
                    policy_names: list,
                    compounding: bool = False,
                    height: int = 350,
                    width: int = 800):
        """Trend chart of the result using Bokeh.
        
        Parameters
        ----------
        policy_names : list
            List of selected policy names
            
        compounding : bool, default False
            Whether returns are reinvested back into the account.
            
        height : int
            Height of the plot
            
        width : int
            Width of the plot
            
        Returns
        -------
        None
        """

        selected_rst_dict = {key: self.rst_dict[key] for key in policy_names}
        data = pd.DataFrame(selected_rst_dict)
        data["strategy_return"] = self.strategy_return

        if compounding:
            cum = (data + 1).cumprod()
        else:
            cum = data.cumsum() + 1

        if compounding:
            mdd = (cum / cum.cummax() - 1)
        else:
            mdd = cum - cum.cummax()

        source = ColumnDataSource(data=cum)
        source_mdd = ColumnDataSource(data=mdd)

        p = figure(x_axis_type="datetime",
                   title="Trend Line",
                   plot_height=height,
                   plot_width=width)
        p.xgrid.grid_line_color = None
        p.ygrid.grid_line_alpha = 0.5
        p.xaxis.axis_label = 'Time'
        p.yaxis.axis_label = 'Total Return'

        p_mdd = figure(x_axis_type="datetime",
                       title="Max Drawdown",
                       plot_height=height,
                       plot_width=width,
                       x_range=p.x_range)
        p_mdd.xgrid.grid_line_color = None
        p_mdd.ygrid.grid_line_alpha = 0.5
        p_mdd.xaxis.axis_label = 'Time'
        p_mdd.yaxis.axis_label = 'MDD'

        lines = []
        for i in range(len(cum.columns)):
            lines.append(
                p.line("Date",
                       cum.columns[i],
                       source=source,
                       line_width=2,
                       line_alpha=0.8,
                       line_color=Spectral10[i % 10],
                       legend_label=cum.columns[i],
                       muted_color=Spectral10[i % 10],
                       muted_alpha=0.1))

        lines_mdd = []
        for i in range(len(mdd.columns)):
            lines_mdd.append(
                p_mdd.line("Date",
                           mdd.columns[i],
                           source=source_mdd,
                           line_width=2,
                           line_alpha=0.8,
                           line_color=Spectral10[i % 10],
                           legend_label=mdd.columns[i],
                           muted_color=Spectral10[i % 10],
                           muted_alpha=0.1))

        p.legend.location = "top_left"
        p.legend.click_policy = "mute"

        p_mdd.legend.location = "bottom_left"
        p_mdd.legend.click_policy = "mute"

        LABELS = list(cum.columns)
        checkbox_group = CheckboxGroup(labels=LABELS)
        checkbox_group.active = list(range(len(LABELS)))

        code = """ for (var i = 0; i < lines.length; i++) {
                        lines[i].visible = false;
                        if (cb_obj.active.includes(i)){lines[i].visible = true;}
                    }
               """
        callback = CustomJS(code=code, args={'lines': lines})
        checkbox_group.js_on_click(callback)

        callback = CustomJS(code=code, args={'lines': lines_mdd})
        checkbox_group.js_on_click(callback)

        grid = gridplot([[p, checkbox_group], [p_mdd]])
        show(grid)
Beispiel #47
0
    def _heatmap(df: pd.DataFrame,
                 col_x: str,
                 col_y: str,
                 col_values: str,
                 color_mapper: Optional[bokeh.models.ColorMapper] = None,
                 normalize: str = "None",
                 height: int = 500,
                 width: int = 500,
                 x_range=None,
                 y_range=None):
        df = df.copy()

        # normalize values
        if normalize == "Column":
            for name in df[col_x].unique():
                df.loc[(
                    df[col_x] == name,
                    col_values)] /= df[df[col_x] == name][col_values].sum()
        elif normalize == "Row":
            for name in df[col_y].unique():
                df.loc[(
                    df[col_y] == name,
                    col_values)] /= df[df[col_y] == name][col_values].sum()

        # ensure the x and y column are in a categorical format
        if df[col_x].dtype != str or df[col_y].dtype != str:
            df = df[[col_x, col_y, col_values]].copy()
            df[col_x] = df[col_x].astype(str)
            df[col_y] = df[col_y].astype(str)

        if x_range is not None and y_range is not None:
            p = figure(x_range=x_range,
                       y_range=y_range,
                       x_axis_location="above",
                       tools="hover",
                       toolbar_location=None,
                       tooltips=[('', '@' + col_values)],
                       width=width,
                       height=height)
        elif x_range is not None and y_range is None:
            p = figure(x_range=x_range,
                       y_range=sorted(df[col_y].unique()),
                       x_axis_location="above",
                       tools="hover",
                       toolbar_location=None,
                       tooltips=[('', '@' + col_values)],
                       width=width,
                       height=height)
        elif x_range is None and y_range is not None:
            p = figure(x_range=sorted(df[col_x].unique())[::-1],
                       y_range=y_range,
                       x_axis_location="above",
                       tools="hover",
                       toolbar_location=None,
                       tooltips=[('', '@' + col_values)],
                       width=width,
                       height=height)
        else:
            p = figure(x_range=sorted(df[col_x].unique())[::-1],
                       y_range=sorted(df[col_y].unique()),
                       x_axis_location="above",
                       tools="hover",
                       toolbar_location=None,
                       tooltips=[('', '@' + col_values)],
                       width=width,
                       height=height)

        p.grid.grid_line_color = None
        p.axis.axis_line_color = None
        p.axis.major_tick_line_color = None
        p.axis.major_label_standoff = 0

        p.rect(x=col_x,
               y=col_y,
               width=1,
               height=1,
               source=df,
               fill_color={
                   'field': col_values,
                   'transform': color_mapper
               },
               line_color=None)
        return p
Beispiel #48
0
    def _categorical_2d_histogram(dataframe, category_col, hist_col, bins,
                                  range, normalize, precision, color_mapper,
                                  hist_col_is_categorical, width, height):
        data = {"x": np.array([]), "y": [], "z": np.array([])}
        hist_min = dataframe[hist_col].min() if range is None else range[0]
        hist_max = dataframe[hist_col].max() if range is None else range[1]
        if hist_max < hist_min:
            hist_max = hist_min * 1.1
        for group in dataframe.groupby(category_col):
            if hist_col_is_categorical:
                bins = dataframe[hist_col].nunique()
                unique_values = dataframe[hist_col].unique()
                x, z = np.unique(group[1][hist_col], return_counts=True)
                data["y"] += [str(group[0])] * bins
                z = np.array(
                    [float(z[x == i]) if i in x else 0 for i in unique_values])
                if normalize:
                    z = z / z.sum()
                data["x"] = np.append(data["x"], unique_values.astype(str))
                data["z"] = np.append(data["z"], z)
            else:
                z, x = np.histogram(group[1][hist_col],
                                    bins=bins,
                                    range=(hist_min, hist_max))
                if normalize:
                    z = z / z.sum()
                data["y"] += [str(group[0])] * bins
                data["x"] = np.append(data["x"],
                                      x[:-1].round(precision).astype(str))
                data["z"] = np.append(data["z"], z)
        df = pd.DataFrame(data)

        color_bar, color_mapper = _create_colorbar_and_color_mapper(
            data["z"].min(), data["z"].max(), color_mapper)

        # create the 2d histogram
        p = figure(x_range=sorted(df["x"].unique().astype(str)),
                   y_range=sorted(df["y"].unique().astype(str)),
                   x_axis_location="above",
                   tools="hover",
                   toolbar_location=None,
                   tooltips=[('', '@z')],
                   width=width,
                   height=height,
                   x_axis_label=hist_col,
                   y_axis_label=category_col)
        p.grid.grid_line_color = None
        p.axis.axis_line_color = None
        p.axis.major_tick_line_color = None
        p.axis.major_label_standoff = 0

        p.rect(x="x",
               y="y",
               width=1,
               height=1,
               source=df,
               fill_color={
                   'field': "z",
                   'transform': color_mapper
               },
               line_color=None)

        p.add_layout(color_bar, 'right')

        return p
Beispiel #49
0
def histogram(values: Union[np.ndarray, List[np.ndarray]],
              bins: int = 10,
              range: Tuple[int] = None,
              density: bool = False,
              remove_tools: bool = False,
              linked_axis=True,
              title="",
              x_label="",
              y_label="",
              orientation="horizontal",
              width: int = 500,
              height: int = 500) -> bokeh.plotting.Figure:
    "Creates a histogram"
    if isinstance(values, np.ndarray):
        if orientation == "vertical":
            x_label, y_label = y_label, x_label
        p = figure(width=width,
                   height=height,
                   title=title,
                   x_axis_label=x_label,
                   y_axis_label=y_label)
        counts, edges = np.histogram(values,
                                     bins=bins,
                                     range=range,
                                     density=density)
        if orientation == "horizontal":
            p.quad(top=counts, bottom=0, left=edges[:-1], right=edges[1:])
        elif orientation == "vertical":
            p.quad(top=edges[1:], bottom=edges[:-1], left=0, right=counts)
        if remove_tools:
            p.toolbar.logo = None
            p.toolbar_location = None
        return p
    elif isinstance(values, list):
        if not isinstance(title, list):
            title = [title] * len(values)
        if not isinstance(x_label, list):
            x_labels = [x_label] * len(values)
        if not isinstance(y_label, list):
            y_labels = [y_label] * len(values)
        if orientation == "vertical":
            x_labels, y_labels = y_labels, x_labels
        plot_list = []
        for values_element, plot_title, x_label, y_label in zip(
                values, title, x_labels, y_labels):
            if len(plot_list) == 0 or linked_axis == False:
                p = figure(width=width,
                           height=height,
                           title=plot_title,
                           x_axis_label=x_label,
                           y_axis_label=y_label)
            else:
                p = figure(width=width,
                           height=height,
                           x_range=plot_list[0].x_range,
                           y_range=plot_list[0].y_range,
                           title=plot_title,
                           x_axis_label=x_label,
                           y_axis_label=y_label)
            counts, edges = np.histogram(values_element,
                                         bins=bins,
                                         range=range,
                                         density=density)
            if orientation == "horizontal":
                p.quad(top=counts, bottom=0, left=edges[:-1], right=edges[1:])
            elif orientation == "vertical":
                p.quad(top=edges[1:], bottom=edges[:-1], left=0, right=counts)
            if remove_tools:
                p.toolbar.logo = None
                p.toolbar_location = None
            plot_list.append(p)
        return plot_list
    else:
        raise TypeError("values has to be of type list or np.ndarray")
Beispiel #50
0
def barplot(counts: Union[np.ndarray, List[np.ndarray]],
            values: Union[np.ndarray, List[np.ndarray]],
            bar_type: Literal["horizontal", "vertical"] = "horizontal",
            linked_axis=True,
            width: int = 500,
            height: int = 500,
            **kwargs) -> bokeh.plotting.Figure:
    """Creates a figure with a barplot, were the counts is the bar height and values are the labels for the bars."""
    if isinstance(counts, list) and isinstance(values, list):
        plot_list = []
        for counts_element, values_element in zip(counts, values):
            values_element = [str(entry) for entry in values_element]
            if bar_type == "horizontal":
                if len(plot_list) == 0:
                    p = figure(width=width,
                               height=height,
                               y_range=values_element)
                    p.hbar(y=values_element,
                           left=0,
                           right=counts_element,
                           height=0.9)
                    display(pn.Row(p))
                else:
                    if linked_axis:
                        p = figure(width=width,
                                   height=height,
                                   y_range=plot_list[0].y_range,
                                   x_range=plot_list[0].x_range)
                    else:
                        p = figure(width=width,
                                   height=height,
                                   y_range=values_element)
                    p.hbar(y=values_element,
                           left=0,
                           right=counts_element,
                           height=0.9)
            elif bar_type == "vertical":
                if len(plot_list) == 0:
                    p = figure(width=width,
                               height=height,
                               x_range=values_element)
                    p.vbar(x=values_element,
                           bottom=0,
                           top=counts_element,
                           width=0.9)
                else:
                    if linked_axis:
                        p = figure(width=width,
                                   height=height,
                                   x_range=plot_list[0].x_range,
                                   y_range=plot_list[0].y_range)
                    else:
                        p = figure(width=width,
                                   height=height,
                                   x_range=values_element)
                    p.vbar(x=values_element,
                           bottom=0,
                           top=counts_element,
                           width=0.9)
            else:
                raise ValueError(
                    "hist_type has to be of 'horizontal' or 'vertical'")
            plot_list.append(p)
        return plot_list
    elif isinstance(counts, np.ndarray) and isinstance(values, np.ndarray):
        values = [str(entry) for entry in values]
        if bar_type == "horizontal":
            p = figure(width=width, height=height, y_range=values)
            p.hbar(y=values, left=0, right=counts, height=0.9)
        elif bar_type == "vertical":
            p = figure(width=width, height=height, x_range=values)
            p.vbar(x=values, bottom=0, top=counts, width=0.9)
        else:
            raise ValueError(
                "hist_type has to be of 'horizontal' or 'vertical'")
        return p
    else:
        raise TypeError(
            "counts and values need to be of the same type (list or np.ndarray)"
        )
from bokeh.plotting import figure, output_file, show

# prepare some data
x = [1, 2, 3, 4, 5]
y = [6, 7, 2, 4, 5]

# output to static HTML file
output_file("lines.html")

# create a new plot with a title and axis labels
p = figure(title="simple line example", x_axis_label='x', y_axis_label='y')

# add a line renderer with legend and line thickness
p.line(x, y, legend_label="Temp.", line_width=2)

# show the results
show(p)
Beispiel #52
0
def heatmap(data: Union[pd.DataFrame, List[pd.DataFrame]],
            col_x: str,
            col_y: str,
            col_values: str,
            color_mapper: Optional[bokeh.models.ColorMapper] = None,
            normalize: str = "None",
            link_plots: bool = True,
            height: int = 500,
            width: int = 500) -> bokeh.plotting.Figure:
    def _heatmap(df: pd.DataFrame,
                 col_x: str,
                 col_y: str,
                 col_values: str,
                 color_mapper: Optional[bokeh.models.ColorMapper] = None,
                 normalize: str = "None",
                 height: int = 500,
                 width: int = 500,
                 x_range=None,
                 y_range=None):
        df = df.copy()

        # normalize values
        if normalize == "Column":
            for name in df[col_x].unique():
                df.loc[(
                    df[col_x] == name,
                    col_values)] /= df[df[col_x] == name][col_values].sum()
        elif normalize == "Row":
            for name in df[col_y].unique():
                df.loc[(
                    df[col_y] == name,
                    col_values)] /= df[df[col_y] == name][col_values].sum()

        # ensure the x and y column are in a categorical format
        if df[col_x].dtype != str or df[col_y].dtype != str:
            df = df[[col_x, col_y, col_values]].copy()
            df[col_x] = df[col_x].astype(str)
            df[col_y] = df[col_y].astype(str)

        if x_range is not None and y_range is not None:
            p = figure(x_range=x_range,
                       y_range=y_range,
                       x_axis_location="above",
                       tools="hover",
                       toolbar_location=None,
                       tooltips=[('', '@' + col_values)],
                       width=width,
                       height=height)
        elif x_range is not None and y_range is None:
            p = figure(x_range=x_range,
                       y_range=sorted(df[col_y].unique()),
                       x_axis_location="above",
                       tools="hover",
                       toolbar_location=None,
                       tooltips=[('', '@' + col_values)],
                       width=width,
                       height=height)
        elif x_range is None and y_range is not None:
            p = figure(x_range=sorted(df[col_x].unique())[::-1],
                       y_range=y_range,
                       x_axis_location="above",
                       tools="hover",
                       toolbar_location=None,
                       tooltips=[('', '@' + col_values)],
                       width=width,
                       height=height)
        else:
            p = figure(x_range=sorted(df[col_x].unique())[::-1],
                       y_range=sorted(df[col_y].unique()),
                       x_axis_location="above",
                       tools="hover",
                       toolbar_location=None,
                       tooltips=[('', '@' + col_values)],
                       width=width,
                       height=height)

        p.grid.grid_line_color = None
        p.axis.axis_line_color = None
        p.axis.major_tick_line_color = None
        p.axis.major_label_standoff = 0

        p.rect(x=col_x,
               y=col_y,
               width=1,
               height=1,
               source=df,
               fill_color={
                   'field': col_values,
                   'transform': color_mapper
               },
               line_color=None)
        return p

    def _create_colorbar_and_color_mapper(min_val, max_val, color_mapper):
        # create color bar
        if color_mapper is None:
            color_mapper = LinearColorMapper(palette=Viridis[256],
                                             low=min_val,
                                             high=max_val)

        color_bar = ColorBar(color_mapper=color_mapper,
                             major_label_text_font_size="7px",
                             label_standoff=6,
                             border_line_color=None,
                             location=(0, 0))
        return color_bar, color_mapper

    # handel multiple inputs here
    if isinstance(data, list):
        plot_list = []
        if link_plots:
            min_value = min(df[col_values].min() for df in data)
            max_value = max(df[col_values].max() for df in data)
            color_bar, color_mapper = _create_colorbar_and_color_mapper(
                min_value, max_value, color_mapper)
        for df in data:
            if not link_plots:
                color_bar, color_mapper = _create_colorbar_and_color_mapper(
                    df[col_values].min(), df[col_values].max(), None)
            temp_heatmap = _heatmap(df, col_x, col_y, col_values, color_mapper,
                                    normalize, height, width)
            if not link_plots:
                temp_heatmap.add_layout(color_bar, 'right')
            plot_list.append(temp_heatmap)
        if link_plots:
            c_bar_figure = figure(width=65,
                                  height=height,
                                  toolbar_location=None,
                                  min_border=0,
                                  outline_line_color=None)
            c_bar_figure.add_layout(color_bar, 'right')
            plot_list.append(c_bar_figure)
        return plot_list
    elif isinstance(data, pd.DataFrame):
        color_bar, color_mapper = _create_colorbar_and_color_mapper(
            data[col_values].min(), data[col_values].max(), color_mapper)
        p = _heatmap(data, col_x, col_y, col_values, color_mapper, normalize,
                     height, width)
        p.add_layout(color_bar, 'right')
        return p
    else:
        raise TypeError("Data has to be of type list or pd.Dataframe")
Beispiel #53
0
from bokeh.models.widgets.markups import Div
from urn import PolyaUrn
from explanation import explanation_text, explanation_text_2

a, b, n, s = 5, 2, 50, 10

doc = curdoc()
U = PolyaUrn(a, b, n)

WalkPanel_xrange = (0, a + n + 1)
WalkPanel_yrange = (0, n)
WalkPanel = figure(
    name="WalkPanel",
    width=325,
    height=325,
    x_range=WalkPanel_xrange,
    y_range=WalkPanel_yrange,
    toolbar_location=None,
    x_axis_label="Number of White Balls in the Urn",
    y_axis_label="Number of Draws from the Urn",
)
WalkSource = ColumnDataSource({"x": np.zeros(n + 1), "y": np.zeros(n + 1)})
WalkPanel.line(x="x", y="y", source=WalkSource)

DensityPanel_xrange = (0, a + n + 1)
DensityPanel_yrange = (0, 10)
DensityPanel = figure(
    name="DensityPanel",
    width=325,
    height=325,
    x_range=DensityPanel_xrange,
    y_range=DensityPanel_yrange,
Beispiel #54
0
                    # torch.nn.init.constant_(param.data, 1.0)
                    init.xavier_uniform_(param.data)
                elif 'weight_hh' in name:
                    # torch.nn.init.constant_(param.data, 0.0)
                    init.xavier_uniform_(param.data)
                elif 'bias' in name:
                    param.data.fill_(0)


source = ColumnDataSource(data={
    "epochs": [],
    "trainlosses": [],
    "vallosses": []
})

plot = figure()
plot.line(x="epochs",
          y="trainlosses",
          color="green",
          alpha=0.8,
          legend="Train loss",
          line_width=2,
          source=source)
plot.line(x="epochs",
          y="vallosses",
          color="red",
          alpha=0.8,
          legend="Val loss",
          line_width=2,
          source=source)
Beispiel #55
0
def test_plot():
    from bokeh.plotting import figure
    test_plot = figure()
    test_plot.circle([1, 2], [2, 3])
    return test_plot
Beispiel #56
0
    def __init__(self, bokeh_doc_name, monitor_channels=None, open_browser=False,
                 server_url='http://localhost:5006/',
                 colors=colors):
        """
        Initialize a Bokeh plot!

        Parameters
        ----------
        bokeh_doc_name : str
            The name of the Bokeh document. Use a different name for each
            experiment if you are storing your plots.
        monitor_channels : list(MonitorsChannel or Monitor)
            The monitor channels and monitors that you want to plot. The
            monitors within a :class:`MonitorsChannel` will be plotted together in a single
            figure.
        open_browser : bool, optional
            Whether to try and open the plotting server in a browser window.
            Defaults to ``True``. Should probably be set to ``False`` when
            running experiments non-locally (e.g. on a cluster or through SSH).
        server_url : str, optional
            Url of the bokeh-server. Ex: when starting the bokeh-server with
            ``bokeh-server --ip 0.0.0.0`` at ``alice``, server_url should be
            ``http://alice:5006``. When not specified the default configured
            to ``http://localhost:5006/``.
        colors : list(str)
            The list of string hex codes for colors to cycle through when creating new lines on the same figure.
        """
        # Make sure Bokeh is available
        if BOKEH_AVAILABLE:
            monitor_channels = raise_to_list(monitor_channels)
            if monitor_channels is None:
                monitor_channels = []

            self.channels = monitor_channels
            self.colors = colors
            self.bokeh_doc_name = bokeh_doc_name
            self.server_url = server_url
            output_server(self.bokeh_doc_name, url=self.server_url)

            # Create figures for each group of channels
            self.plots = {}
            self.figures = []
            self.figure_indices = {}
            self.figure_color_indices = []

            # add a potential plot for train_cost
            self.figures.append(figure(title='{} #{}'.format(bokeh_doc_name, TRAIN_COST_KEY),
                                       logo=None,
                                       toolbar_location='right'))
            self.figure_color_indices.append(0)
            self.figure_indices[TRAIN_COST_KEY] = 0

            for i, channel in enumerate(self.channels):
                idx = i+1  # offset by 1 because of the train_cost figure
                assert isinstance(channel, MonitorsChannel) or isinstance(channel, Monitor), \
                    "Need channels to be type MonitorsChannel or Monitor. Found %s" % str(type(channel))
                # create the figure
                self.figures.append(figure(title='{} #{}'.format(bokeh_doc_name, channel.name),
                                           x_axis_label='iterations',
                                           y_axis_label='value',
                                           logo=None,
                                           toolbar_location='right'))
                self.figure_color_indices.append(0)
                # for each monitor in this channel, assign this figure to the monitor (and train/valid/test variants)
                if isinstance(channel, MonitorsChannel):
                    for monitor in channel.monitors:
                        self.figure_indices[COLLAPSE_SEPARATOR.join([channel.name, monitor.name])] = idx
                        if monitor.train_flag:
                            self.figure_indices[
                                COLLAPSE_SEPARATOR.join([channel.name, monitor.name, TRAIN_MARKER])
                            ] = idx
                        if monitor.valid_flag:
                            self.figure_indices[
                                COLLAPSE_SEPARATOR.join([channel.name, monitor.name, VALID_MARKER])
                            ] = idx
                        if monitor.test_flag:
                            self.figure_indices[
                                COLLAPSE_SEPARATOR.join([channel.name, monitor.name, TEST_MARKER])
                            ] = idx
                else:
                    self.figure_indices[channel.name] = idx
                    if channel.train_flag:
                        self.figure_indices[
                            COLLAPSE_SEPARATOR.join([channel.name, TRAIN_MARKER])
                        ] = idx
                    if channel.valid_flag:
                        self.figure_indices[
                            COLLAPSE_SEPARATOR.join([channel.name, VALID_MARKER])
                        ] = idx
                    if channel.test_flag:
                        self.figure_indices[
                            COLLAPSE_SEPARATOR.join([channel.name, TEST_MARKER])
                        ] = idx

            log.debug("Figure indices for monitors: %s" % str(self.figure_indices))

            if open_browser:
                show(self.figures)
Beispiel #57
0
    xstop = j * dx;
    int1 = numerically_integrate(0,xstop,dx,f1,td);
    int2 = numerically_integrate(0,xstop,dx,f2,td);
    factor = 2 * mni / td * Math.exp(-Math.pow(xstop/td,2));
    L = factor * ((epni-epco) * int1 + epco * int2) / (4.*3.14*Math.pow(distance,2));
    y[j] = -2.5 * Math.log10(L*wav/c)-48.3;
    x[j] = (dx*(1+redshift)) * j + T;
}
source.change.emit();
""")

plot = figure(
    plot_height=400,
    plot_width=400,
    title="Super cool blackbody curve thing",
    tools="crosshair,pan,reset,save,wheel_zoom",
    x_range=[np.min(photometry_time) - 20,
             np.max(photometry_time) + 100],
    y_range=[np.max(photometry_mag),
             np.min(photometry_mag)])

plot.line('x', 'y', source=source, line_width=3, line_alpha=0.6)
#plot.line('x', 'yB', source=source, line_width=3, line_alpha=0.6, color="pink")
#plot.line('x', 'yr', source=source, line_width=3, line_alpha=0.6, color="orange")
#plot.line('x', 'yi', source=source, line_width=3, line_alpha=0.6, color="blue")
#plot.line('x', 'yV', source=source, line_width=3, line_alpha=0.6, color="turquoise")
#plot.line('x', 'yU', source=source, line_width=3, line_alpha=0.6, color="purple")

arrayoftimes = np.array(photometry_time)

text = TextInput(title="title", value='my parabola', callback=callback2)
Beispiel #58
0
def display_matrix(M, base_size=600):
    '''
    Renders the matrix M as a heatmap.

    Args:
        M (numpy's matrix) Matrix to render.
        base_size (int) Default size (in pixels, I think) of
            larger dimension.
    '''
    # Work with the underlying array.
    m = np.asarray(M)
    n = len(m.flatten())

    # Get value range for color computation.
    min_val = m.min()
    max_val = m.max()

    # Massage data into format for plotting a bunch of rectangles.
    xvals = []
    yvals = []
    vals = []
    colors = []
    text_colors = []
    for i in range(m.shape[0]):
        for j in range(m.shape[1]):
            datum = m[i][j]

            # Turn the index into plotting coordinates.
            x = j
            y = m.shape[0] - i
            xvals += [x]
            yvals += [y]

            # Change display based on numerical type for
            # cleaner look.
            if type(datum) is np.int64:
                vals += [str(datum)]
            else:
                vals += ['%0.2f' % (datum)]

            # Get the background and text color for the cell.
            bg, txt = get_color(min_val, max_val, n, datum)
            colors += [bg]
            text_colors += [txt]

    # This is the format we stick it in for bokeh plotting.
    source = ColumnDataSource(data=dict(
        xvals=xvals,
        yvals=yvals,
        colors=colors,
    ))

    # Create a figure and remove tje default plotting crap. (Not all of this
    # may be necessary.)
    p = figure(tools='', )
    p.grid.grid_line_color = None
    p.axis.axis_line_color = None
    p.axis.major_tick_line_color = None
    p.axis.minor_tick_line_color = None
    p.axis.major_label_text_font_size = '0pt'
    p.axis[0].ticker.num_minor_ticks = 0
    p.toolbar_location = None

    # Shrink size if n_rows != n_cols. Enforce a minimum of 50px so that the
    # values are visible.
    n_rows, n_cols = m.shape[0], m.shape[1]
    rc_ratio = float(n_rows) / n_cols
    w, h = base_size, base_size
    if n_rows > n_cols:
        w = max(50.0 * n_cols, (1.0 / rc_ratio) * base_size)
        h = max(50.0 * n_rows, rc_ratio * w)
    elif n_cols > n_rows:
        h = max(50.0 * n_rows, rc_ratio * base_size)
        w = max(50.0 * n_cols, (1.0 / rc_ratio) * h)
    p.plot_width = int(w)
    p.plot_height = int(h)

    # Plot and display.
    p.rect('xvals', 'yvals', 0.9, 0.9, source=source, color='colors')
    p.text(np.array(xvals) - 0.25,
           np.array(yvals) - 0.25,
           vals,
           text_color=text_colors)
    show(p)
Beispiel #59
0
def plot_picture(dates,
                 states,
                 var_values,
                 confidence_values,
                 save_path,
                 name_dict,
                 s_size=0.1):
    ## Fig 생성
    fig = figure(title=name_dict['title'],
                 x_axis_label='Timeline',
                 x_axis_type='datetime',
                 y_axis_label='score',
                 plot_width=2000,
                 plot_height=500)

    fig.y_range = Range1d(start=min(var_values), end=max(var_values))
    fig.line(dates,
             var_values,
             line_width=2,
             color=name_dict['var_color'],
             legend_label=name_dict['var_name'])

    if states is not None and len(dates) > 0:
        temp_start = dates[0]
        temp_state = states[0]

        temp_date = dates[0]
        for xc, value in zip(dates, states):
            if temp_state != value:
                if temp_state == 'prognosis':
                    fig.add_layout(
                        BoxAnnotation(left=temp_start,
                                      right=temp_date,
                                      fill_alpha=0.2,
                                      fill_color='blue'))
                if temp_state == 'abnormal':
                    fig.add_layout(
                        BoxAnnotation(left=temp_start,
                                      right=temp_date,
                                      fill_alpha=0.2,
                                      fill_color='orange'))
                temp_start = xc
                temp_state = value
            temp_date = xc

        if temp_state == 'prognosis':
            fig.add_layout(
                BoxAnnotation(left=temp_start,
                              right=xc,
                              fill_alpha=0.2,
                              fill_color='blue'))
        if temp_state == 'abnormal':
            fig.add_layout(
                BoxAnnotation(left=temp_start,
                              right=xc,
                              fill_alpha=0.2,
                              fill_color='orange'))

    if confidence_values is not None:
        fig.extra_y_ranges = {
            "var": Range1d(start=-1, end=max(confidence_values) + 1)
        }
        fig.add_layout(LinearAxis(y_range_name="var"), 'right')
        fig.line(dates,
                 confidence_values,
                 legend_label=name_dict['confidence_name'],
                 line_width=2,
                 y_range_name='var',
                 color=name_dict['confidence_color'],
                 line_alpha=.3)

    fig.legend.click_policy = 'hide'
    output_file(filename=save_path)
    save(fig)
Beispiel #60
0
def assembly_chart(df, complements):
    """function to assembly the chart"""
    print('starting the plot...')

    # specify the output file name
    output_file("movigrama_chart.html")
    # force to show only one plot when multiples executions of the code occur
    # otherwise the plots will append each time one new calling is done
    reset_output()

    # create ColumnDataSource objects directly from Pandas data frames
    source = ColumnDataSource(df)

    # use the column DT as index
    df.set_index('DT', inplace=True)

    ###########################################################################
    #
    #  Movigrama Plot
    #
    ###########################################################################

    # build figure of the plot
    p = figure(x_axis_type='datetime',
               x_axis_label='days of moviment',
               y_axis_label='unities movimented',
               plot_width=1230,
               plot_height=500,
               active_scroll='wheel_zoom')

    # TODO Specify X range (not all plots have 365 days of moviment)

    # build the Stock Level bar
    r1 = p.vbar(x='DT',
                bottom=0,
                top='STOCK',
                width=pd.Timedelta(days=1),
                fill_alpha=0.4,
                color='paleturquoise',
                source=source)

    # build the OUT bar
    p.vbar(x='DT',
           bottom=0,
           top='SOMA_SAI',
           width=pd.Timedelta(days=1),
           fill_alpha=0.8,
           color='crimson',
           source=source)

    # build the IN bar
    p.vbar(x='DT',
           bottom=0,
           top='SOMA_ENTRA',
           width=pd.Timedelta(days=1),
           fill_alpha=0.8,
           color='seagreen',
           source=source)

    # edit title
    # adds warehouse title
    p.add_layout(
        Title(text=complements['warehouse'],
              text_font='helvetica',
              text_font_size='10pt',
              text_color='orangered',
              text_alpha=0.5,
              align='center',
              text_font_style="italic"), 'above')
    # adds product title
    p.add_layout(
        Title(text=complements['product'],
              text_font='helvetica',
              text_font_size='10pt',
              text_color='orangered',
              text_alpha=0.5,
              align='center',
              text_font_style="italic"), 'above')
    # adds main title
    p.add_layout(
        Title(text='Movigrama Endicon',
              text_font='helvetica',
              text_font_size='16pt',
              text_color='orangered',
              text_alpha=0.9,
              align='center',
              text_font_style="bold"), 'above')

    # adds horizontal line
    hline = Span(location=0,
                 line_alpha=0.4,
                 dimension='width',
                 line_color='gray',
                 line_width=3)
    p.renderers.extend([hline])

    # adapt the range to the plot
    p.x_range.range_padding = 0.1
    p.y_range.range_padding = 0.1

    # format the plot's outline
    p.outline_line_width = 4
    p.outline_line_alpha = 0.1
    p.outline_line_color = 'orangered'

    # format major labels
    p.axis.major_label_text_color = 'gray'
    p.axis.major_label_text_font_style = 'bold'

    # format labels
    p.axis.axis_label_text_color = 'gray'
    p.axis.axis_label_text_font_style = 'bold'

    #    p.xgrid.grid_line_color = None  # disable vertical bars
    #    p.ygrid.grid_line_color = None  # disable horizontal bars

    # change placement of minor and major ticks in the plot
    p.axis.major_tick_out = 10
    p.axis.minor_tick_in = -3
    p.axis.minor_tick_out = 6
    p.axis.minor_tick_line_color = 'gray'

    # format properly the X datetime axis
    p.xaxis.formatter = DatetimeTickFormatter(days=['%d/%m'],
                                              months=['%m/%Y'],
                                              years=['%Y'])

    # initiate hover object
    hover = HoverTool()
    hover.mode = "vline"  # activate hover by vertical line
    hover.tooltips = [("SUM-IN", "@SOMA_ENTRA"), ("SUM-OUT", "@SOMA_SAI"),
                      ("COUNT-IN", "@TRANSACT_ENTRA"),
                      ("COUNT-OUT", "@TRANSACT_SAI"), ("STOCK", "@STOCK"),
                      ("DT", "@DT{%d/%m/%Y}")]
    # use 'datetime' formatter for 'DT' field
    hover.formatters = {"DT": 'datetime'}
    hover.renderers = [r1]  # display tooltip only to one render
    p.add_tools(hover)

    ###########################################################################
    #
    #  Demand analysis
    #
    ###########################################################################

    # change to positive values
    df['out_invert'] = df['SOMA_SAI'] * -1
    # moving average with n=30 days
    df['MA30'] = df['out_invert'].rolling(30).mean().round(0)
    # moving standard deviation with n=30 days
    df['MA30_std'] = df['out_invert'].rolling(30).std().round(0)
    # lower control limit for 1 sigma deviation
    df['lcl_1sigma'] = (df['MA30'] - df['MA30_std'])
    # upper control limit for 1 sigma deviation
    df['ucl_1sigma'] = (df['MA30'] + df['MA30_std'])

    source = ColumnDataSource(df)

    p1 = figure(plot_width=1230,
                plot_height=500,
                x_range=p.x_range,
                x_axis_type="datetime",
                active_scroll='wheel_zoom')

    # build the Sum_out bar
    r1 = p1.vbar(x='DT',
                 top='out_invert',
                 width=pd.Timedelta(days=1),
                 color='darkred',
                 line_color='salmon',
                 fill_alpha=0.4,
                 source=source)

    # build the moving average line
    p1.line(x='DT', y='MA30', source=source)

    # build the confidence interval
    band = Band(base='DT',
                lower='lcl_1sigma',
                upper='ucl_1sigma',
                source=source,
                level='underlay',
                fill_alpha=1.0,
                line_width=1,
                line_color='black')
    p1.renderers.extend([band])

    # adds title
    p1.add_layout(
        Title(text='Demand Variability',
              text_font='helvetica',
              text_font_size='16pt',
              text_color='orangered',
              text_alpha=0.5,
              align='center',
              text_font_style="bold"), 'above')

    # adds horizontal line
    hline = Span(location=0,
                 line_alpha=0.4,
                 dimension='width',
                 line_color='gray',
                 line_width=3)
    p1.renderers.extend([hline])

    # format the plot's outline
    p1.outline_line_width = 4
    p1.outline_line_alpha = 0.1
    p1.outline_line_color = 'orangered'

    # format major labels
    p1.axis.major_label_text_color = 'gray'
    p1.axis.major_label_text_font_style = 'bold'

    # format labels
    p1.axis.axis_label_text_color = 'gray'
    p1.axis.axis_label_text_font_style = 'bold'

    # change placement of minor and major ticks in the plot
    p1.axis.major_tick_out = 10
    p1.axis.minor_tick_in = -3
    p1.axis.minor_tick_out = 6
    p1.axis.minor_tick_line_color = 'gray'

    # format properly the X datetime axis
    p1.xaxis.formatter = DatetimeTickFormatter(days=['%d/%m'],
                                               months=['%m/%Y'],
                                               years=['%Y'])

    # initiate hover object
    hover = HoverTool()
    hover.mode = "vline"  # activate hover by vertical line
    hover.tooltips = [("DEMAND", '@out_invert'), ("UCL 1σ", "@ucl_1sigma"),
                      ("LCL 1σ", "@lcl_1sigma"), ("M AVG 30d", "@MA30"),
                      ("DT", "@DT{%d/%m/%Y}")]
    # use 'datetime' formatter for 'DT' field
    hover.formatters = {"DT": 'datetime'}
    hover.renderers = [r1]  # display tooltip only to one render
    p1.add_tools(hover)

    ###########################################################################
    #
    #  Demand grouped by month
    #
    ###########################################################################

    resample_M = df.iloc[:, 0:6].resample('M').sum()  # resample to month
    # create column date as string
    resample_M['date'] = resample_M.index.strftime('%b/%y').values
    # moving average with n=3 months
    resample_M['MA3'] = resample_M['out_invert'].rolling(3).mean()

    resample_M['MA3'] = np.ceil(resample_M.MA3)  # round up the column MA3
    # resample to month with mean
    resample_M['mean'] = np.ceil(resample_M['out_invert'].mean())
    # resample to month with standard deviation
    resample_M['std'] = np.ceil(resample_M['out_invert'].std())
    # moving standard deviation with n=30 days
    resample_M['MA3_std'] = np.ceil(resample_M['out_invert'].rolling(3).std())
    # lower control limit for 1 sigma deviation
    resample_M['lcl_1sigma'] = resample_M['MA3'] - resample_M['MA3_std']
    # upper control limit for 1 sigma deviation
    resample_M['ucl_1sigma'] = resample_M['MA3'] + resample_M['MA3_std']

    source = ColumnDataSource(resample_M)

    p2 = figure(plot_width=1230,
                plot_height=500,
                x_range=FactorRange(factors=list(resample_M.date)),
                title='demand groupped by month')

    colors = factor_cmap('date',
                         palette=Category20_20,
                         factors=list(resample_M.date))

    p2.vbar(x='date',
            top='out_invert',
            width=0.8,
            fill_color=colors,
            fill_alpha=0.8,
            source=source,
            legend=value('OUT'))

    p2.line(x='date',
            y='MA3',
            color='red',
            line_width=3,
            line_dash='dotted',
            source=source,
            legend=value('MA3'))

    p2.line(x='date',
            y='mean',
            color='blue',
            line_width=3,
            line_dash='dotted',
            source=source,
            legend=value('mean'))

    band = Band(base='date',
                lower='lcl_1sigma',
                upper='ucl_1sigma',
                source=source,
                level='underlay',
                fill_alpha=1.0,
                line_width=1,
                line_color='black')

    labels1 = LabelSet(x='date',
                       y='MA3',
                       text='MA3',
                       level='glyph',
                       y_offset=5,
                       source=source,
                       render_mode='canvas',
                       text_font_size="8pt",
                       text_color='darkred')

    labels2 = LabelSet(x='date',
                       y='out_invert',
                       text='out_invert',
                       level='glyph',
                       y_offset=5,
                       source=source,
                       render_mode='canvas',
                       text_font_size="8pt",
                       text_color='gray')

    low_box = BoxAnnotation(
        top=resample_M['mean'].iloc[0] -
        resample_M['std'].iloc[0],  # analysis:ignore
        fill_alpha=0.1,
        fill_color='red')
    mid_box = BoxAnnotation(
        bottom=resample_M['mean'].iloc[0] -
        resample_M['std'].iloc[0],  # analysis:ignore
        top=resample_M['mean'].iloc[0] +
        resample_M['std'].iloc[0],  # analysis:ignore
        fill_alpha=0.1,
        fill_color='green')
    high_box = BoxAnnotation(
        bottom=resample_M['mean'].iloc[0] +
        resample_M['std'].iloc[0],  # analysis:ignore
        fill_alpha=0.1,
        fill_color='red')

    p2.renderers.extend([band, labels1, labels2, low_box, mid_box, high_box])
    p2.legend.click_policy = "hide"
    p2.legend.background_fill_alpha = 0.4

    p2.add_layout(
        Title(text='Demand Grouped by Month',
              text_font='helvetica',
              text_font_size='16pt',
              text_color='orangered',
              text_alpha=0.5,
              align='center',
              text_font_style="bold"), 'above')

    # adds horizontal line
    hline = Span(location=0,
                 line_alpha=0.4,
                 dimension='width',
                 line_color='gray',
                 line_width=3)
    p2.renderers.extend([hline])

    # format the plot's outline
    p2.outline_line_width = 4
    p2.outline_line_alpha = 0.1
    p2.outline_line_color = 'orangered'

    # format major labels
    p2.axis.major_label_text_color = 'gray'
    p2.axis.major_label_text_font_style = 'bold'

    # format labels
    p2.axis.axis_label_text_color = 'gray'
    p2.axis.axis_label_text_font_style = 'bold'

    # change placement of minor and major ticks in the plot
    p2.axis.major_tick_out = 10
    p2.axis.minor_tick_in = -3
    p2.axis.minor_tick_out = 6
    p2.axis.minor_tick_line_color = 'gray'

    # initiate hover object
    # TODO develop hoverTool
    #    hover = HoverTool()
    #    hover.mode = "vline"  # activate hover by vertical line
    #    hover.tooltips = [("SUM-IN", "@SOMA_ENTRA"),
    #                      ("SUM-OUT", "@SOMA_SAI"),
    #                      ("COUNT-IN", "@TRANSACT_ENTRA"),
    #                      ("COUNT-OUT", "@TRANSACT_SAI"),
    #                      ("STOCK", "@STOCK")]
    #    hover.renderers = [r1]  # display tooltip only to one render
    #    p2.add_tools(hover)

    ###########################################################################
    #
    #  Plot figures
    #
    ###########################################################################

    # put the results in a column and show
    show(column(p, p1, p2))

    # show(p)  # plot action

    print('plot finished')