def buildScatterPlot(word_happiness):
    wordList = []
    wordHappiness = []

    for word in word_happiness.keys():
        wordList.append(word)
        wordHappiness.append(word_happiness[word])

    datasource = {
        'x': range(1,
                   len(wordList) + 1),
        'y': wordHappiness,
        'labels': wordList
    }
    source = ColumnDataSource(datasource)
    print(len(wordList))
    hover = HoverTool(tooltips=[
        ("word", "@labels"),
    ])

    ###### attempt at regresssion line\
    regression = np.polyfit(source.data['x'], source.data['y'], 1)
    r_x, r_y = zip(*((i, i * regression[0] + regression[1])
                     for i in range(len(source.data['x']))))
    source.add(r_x, 'r_x')
    source.add(r_y, 'r_y')

    p = figure(plot_width=800, plot_height=800, tools=[hover])

    p.outline_line_width = 13
    p.outline_line_alpha = 0.3
    p.outline_line_color = "navy"
    p.line('x', 'y', source=source)
    p.line('r_x', 'r_y', source=source, color='red')
    return p
예제 #2
0
 def compute_data_source(self):
     source = ColumnDataSource(self.df.reset_index()[2:])
     source.add(
         self.df[2:].LogReturns.ge(0).map(
             lambda x: "steelblue" if x else "red"), 'LogReturnsColor')
     source.add(self.df[2:].DevolLogReturns / 2., 'y_mids')
     return source
    def get_analyzers_tables(
            self,
            analyzer: bt.analyzers.Analyzer) -> (Paragraph, List[DataTable]):
        """Return a header for this analyzer and one *or more* data tables."""
        if hasattr(analyzer, 'get_analysis_table'):
            title, table_columns_list = analyzer.get_analysis_table()
        else:
            # Analyzer does not provide a table function. Use our generic one
            title, table_columns_list = TableGenerator._get_analysis_table_generic(
                analyzer)

        param_str = get_params_str(analyzer.params)
        if len(param_str) > 0:
            title += f' ({param_str})'

        elems: List[DataTable] = []
        for table_columns in table_columns_list:
            cds = ColumnDataSource()
            columns = []
            for i, c in enumerate(table_columns):
                col_name = f'col{i}'
                cds.add(c[2:], col_name)
                columns.append(
                    TableColumn(field=col_name,
                                title=c[0],
                                formatter=self._get_formatter(c[1])))
            column_height = len(table_columns[0]) * 25
            elems.append(
                DataTable(source=cds,
                          columns=columns,
                          index_position=None,
                          height=column_height))
        return Paragraph(text=title, style={'font-size': 'large'}), elems
예제 #4
0
def get_grid(data_by_node, attributes):
    """Create the ColumnDataSource instance as used by Bokeh
    for plotting the grid. It transforms the pandas dataframe
    into the appropriate structure.

    Todo: link the node id to a list of articles IDs for further
    bindings to URIs in the database

    Parameters:
    -----------

    data_by_node: pandas dataframe
        Contains the node data with the list of nodes linking to
        the cluster ID and the main topics, and article hits

    attributes: dictionary
        Contains the main attributes of the data modelling session.
    """
    n_clusters = attributes["n_clusters"]
    k_shape = attributes["kshape"]
    colors = [
        "#%02x%02x%02x" % (np.floor(250. * (float(n) / n_clusters)), 100, 100)
        for n in xrange(n_clusters)
    ]
    colormap = {i: colors[i] for i in xrange(n_clusters)}
    source = ColumnDataSource(data_by_node)
    source.add([colormap[cl] for cl in source.data["cluster"]], 'color')

    x_range = [str(x) for x in xrange(k_shape[0])]
    y_range = [str(x) for x in xrange(k_shape[1])]
    return source, x_range, y_range
def plot_interactive_timeseries(x, y, data, title, hover_cols=None):
    hover_cols = hover_cols or list(data.columns)
    df = data[hover_cols].dropna(axis=0, how='any')
    source = ColumnDataSource(df)

    tooltips = []
    for col in df.columns:
        df[col].dtype
        if df[col].dtype == pd.np.dtype('datetime64[ns]'):
            # TODO: fix air_date is off by a day 
            # tz_localize('US/Eastern')
            source.add(df[col].map(lambda x: x.strftime('%x')), col + "_str")
            tooltips.append([col, "@" + col + "_str"])
        elif df[col].dtype == pd.np.dtype('float64'):
            tooltips.append([col, "@" + col + "{1.11}"])
        else:
            tooltips.append([col, "@" + col])
    
    p = figure(
        plot_width=bokeh.charts.defaults.width,
        plot_height=bokeh.charts.defaults.height,
        x_axis_type="datetime",
        title=title)

    p.axis[1].formatter.use_scientific = False

    hover = HoverTool(tooltips=tooltips)

    p.circle(x=x, y=y, line_width=2, source=source, size=5)
    p.add_tools(hover)
    p.toolbar.logo = None

    return p
예제 #6
0
def make_plot():
    # prepare data stuff - take the keys from the data in order of likelihood
    categories = list(reversed(probly.keys()))
    palette = [cc.rainbow[i * 15] for i in range(17)]
    x = linspace(-20, 110, 500)
    source = ColumnDataSource(data=dict(x=x))

    p = figure(y_range=categories, plot_width=900, x_range=(-5, 105), toolbar_location=None)

    for i, cat in enumerate(reversed(categories)):
        pdf = gaussian_kde(probly[cat])
        y = ridge(cat, pdf(x))
        source.add(y, cat)
        p.patch('x', cat, color=palette[i], alpha=0.6, line_color="black", source=source)

    p.outline_line_color = None
    p.background_fill_color = "#efefef"

    p.xaxis.ticker = FixedTicker(ticks=list(range(0, 101, 10)))
    p.xaxis.formatter = PrintfTickFormatter(format="%d%%")

    p.ygrid.grid_line_color = None
    p.xgrid.grid_line_color = "#dddddd"
    p.xgrid.ticker = p.xaxis[0].ticker

    p.axis.minor_tick_line_color = None
    p.axis.major_tick_line_color = None
    p.axis.axis_line_color = None

    p.y_range.range_padding = 0.12

    return p
예제 #7
0
def plot_coords(df, filename):
    lat = 'Latitude|"Degrees"|-180.0|180.0|10'
    long = 'Longitude|"Degrees"|-180.0|180.0|10'
    speed = 'Speed|"mph"|0.0|150.0|10'
    df.loc[df[lat] == 0, lat] = np.nan
    df.loc[df[long] == 0, long] = np.nan
    coord_source = ColumnDataSource(df)
    coord_source.add(df['Interval|"ms"|0|0|1'], name='Time')

    coord = figure(sizing_mode='scale_both',
                   width=700,
                   height=600,
                   title='GPS Data_{}'.format(filename))

    # TODO figure out why this is broken
    # mapper = linear_cmap(field_name='Speed"|"mph"|0.0|150.0|10', palette=Spectral6, low=min(speed), high=max(speed))

    coord.circle(x=lat, y=long, source=coord_source, size=3, color='darkcyan')

    # TODO figure out how to make the points be connected
    # coord.line(x=lat, y=long, source=coord_source, line_width=2, color='red')

    # Tools
    hover = HoverTool()
    hover.tooltips = [('Lat', '$x{0.000000}'), ('Long', '$y{0.000000}'),
                      ('Time', '@Time')]
    hover.point_policy = 'follow_mouse'
    coord.add_tools(hover)

    return coord
예제 #8
0
def plot_ridge(measured):
    all_times = [item for subl in measured.values() for item in subl]

    x = np.logspace(
        np.log10(min(all_times)) - 1,
        np.log10(max(all_times)) + 1, 500)
    source = ColumnDataSource(data=dict(x=x))

    p = bp.figure(
        title='Distribution of optimization times ({} measurements)'.format(
            len(all_times)),
        x_axis_type='log')
    for i, (model_type, these_times) in enumerate(measured.items()):
        if len(these_times) == 0:
            continue
        y = logx_kde(x, these_times) + 1
        source.add(y, model_type)
        p.patch('x',
                model_type,
                color=cmap[i],
                alpha=0.6,
                line_color="black",
                source=source)
        # p.output_backend = 'svg'

    p.y_range.range_padding = 0.12

    return p
def draw_plots(CDS_data):

    #			dict(x= xCoord, y = yCoord, names=labels,selected=selStatus)

    source = ColumnDataSource(data=dict())
    for p in CDS_data:
        source.add(CDS_data[p], name=p)
예제 #10
0
def get_grid(data_by_node, attributes):
    """Create the ColumnDataSource instance as used by Bokeh
    for plotting the grid. It transforms the pandas dataframe
    into the appropriate structure.

    Todo: link the node id to a list of articles IDs for further
    bindings to URIs in the database

    Parameters:
    -----------

    data_by_node: pandas dataframe
        Contains the node data with the list of nodes linking to
        the cluster ID and the main topics, and article hits

    attributes: dictionary
        Contains the main attributes of the data modelling session.
    """
    n_clusters = attributes["n_clusters"]
    k_shape = attributes["kshape"]
    colors = ["#%02x%02x%02x" % (np.floor(250.0 * (float(n) / n_clusters)), 100, 100) for n in xrange(n_clusters)]
    colormap = {i: colors[i] for i in xrange(n_clusters)}
    source = ColumnDataSource(data_by_node)
    source.add([colormap[cl] for cl in source.data["cluster"]], "color")

    x_range = [str(x) for x in xrange(k_shape[0])]
    y_range = [str(x) for x in xrange(k_shape[1])]
    return source, x_range, y_range
예제 #11
0
def ridge_plots(model_df):
    models = list(model_df.keys())
    models.reverse()
    for i, model in enumerate(models):
        if 'name' in model:
            models.pop(i)

    palette = [cc.rainbow[i * 15] for i in range(len(models))]

    x = np.linspace(-20, 110, 500)

    source = ColumnDataSource(data=dict(x=x))

    p = figure(y_range=models,
               plot_width=900,
               x_range=(0, 5),
               toolbar_location=None)

    for i, model in enumerate(models):
        if 'name' in model:
            continue
        pdf = gaussian_kde(model_df[model].dropna())
        y = ridge(model, pdf(x))
        source.add(y, model)
        p.patch('x',
                model,
                color=palette[i],
                alpha=0.6,
                line_color="black",
                source=source)

    p.outline_line_color = None
    p.background_fill_color = "#efefef"

    p.xaxis.ticker = FixedTicker(
        ticks=list(range(int(model_df.min().min()), 5, 1)))
    # p.xaxis.formatter = PrintfTickFormatter(format="%d%%")

    p.ygrid.grid_line_color = None
    p.xgrid.grid_line_color = "#dddddd"
    p.xgrid.ticker = p.xaxis[0].ticker

    p.axis.minor_tick_line_color = None
    p.axis.major_tick_line_color = None
    p.axis.axis_line_color = None

    p.y_range.range_padding = 2

    base = Span(location=1,
                dimension='height',
                line_color='black',
                line_dash='dashed',
                line_width=3)
    p.add_layout(base)

    st.bokeh_chart(p)
    return
예제 #12
0
def source_from_dataframe(dataframe, settings, current_selection):
    """"""
    source = ColumnDataSource(dataframe)
    embeddings_names = list(settings['embeddings'].keys())
    selected_name = embeddings_names[current_selection]
    selected_column_x = settings['embeddings'][selected_name][0]
    selected_column_y = settings['embeddings'][selected_name][1]
    # Create empty columns to put selected coordinate data into
    source.add(dataframe[selected_column_x], name='x')
    source.add(dataframe[selected_column_y], name='y')
    return source
예제 #13
0
def source_from_dataframe(dataframe, settings, current_selection):
    """"""
    source = ColumnDataSource(dataframe)
    embeddings_names = list(settings['embeddings'].keys())
    selected_name = embeddings_names[current_selection]
    selected_column_x = settings['embeddings'][selected_name][0]
    selected_column_y = settings['embeddings'][selected_name][1]
    # Create empty columns to put selected coordinate data into
    source.add(dataframe[selected_column_x], name='x')
    source.add(dataframe[selected_column_y], name='y')
    return source
예제 #14
0
class DataHandler(object):
    """

    Parameters
    ----------
    data : pandas DataFrame

    """
    def __init__(self, data):

        self.source = ColumnDataSource(data)
        self.source.add(data.index, "index")
예제 #15
0
    def generate_optresult_model(self,
                                 optresult: List[List[bt.OptReturn]],
                                 columns=None) -> Model:
        """Generates and returns an interactive model"""
        #o = list(self._options.keys())
        #selector = Select(title="Result:", value="result", options=o)

        cds = ColumnDataSource()
        tab_columns = []

        for idx, strat in enumerate(optresult[0]):
            # add suffix when dealing with more than 1 strategy
            strat_suffix = ''
            if len(optresult[0]):
                strat_suffix = f' [{idx}]'

            for name, val in strat.params._getitems():
                tab_columns.append(
                    TableColumn(field=f"{idx}_{name}",
                                title=f'{name}{strat_suffix}'))

                # get value for the current param for all results
                pvals = []
                for res in optresult:
                    pvals.append(res[idx].params._get(name))
                cds.add(pvals, f"{idx}_{name}")

        # add user columns specified by parameter 'columns'
        if columns is not None:
            for k, v in columns.items():
                ll = [str(v(x)) for x in optresult]
                cds.add(ll, k)
                tab_columns.append(TableColumn(field=k, title=k))

        selector = DataTable(source=cds,
                             columns=tab_columns,
                             width=1600,
                             height=160)

        model = column(
            [selector, self.plot_and_generate_model(optresult[idx])])

        def update(name, old, new):
            if len(new['1d']['indices']) == 0:
                return

            stratidx = new['1d']['indices'][0]
            model.children[-1] = self.plot_and_generate_model(
                optresult[stratidx])

        cds.on_change('selected', update)
        return model
def get_source_geo_and_count_us_continent(state_count_experience_selector_dict,
                                          state_count_careerarea_selector_dict,
                                          states_map):
    states = {code: state for code, state in states_map.items()}
    states_sort_by_name = states.values()
    states_sort_by_name = sorted(states_sort_by_name, key=lambda x: x['name'])
    # sort states' geo by its name, it helps decide the order of count data. cause .csv data is already sorted by state name

    state_xs = [state["lons"] for state in states_sort_by_name]
    state_ys = [state["lats"] for state in states_sort_by_name]
    state_names = [state["name"] for state in states_sort_by_name]

    source = ColumnDataSource(
        data=dict(x=state_xs,
                  y=state_ys,
                  name=[name + ", United States" for name in state_names]))

    state_count_total = np.zeros(
        len(list(state_count_experience_selector_dict.values())[0]))
    for name, state_count in state_count_experience_selector_dict.items():
        state_count_total = [
            sum(x) for x in zip(state_count_total, state_count)
        ]
        source.add(data=state_count, name='count' + name)
    source.add(data=state_count_total, name='count_all')
    source.add(data=state_count_total, name='count')

    for experience_selector_name, state_count_careerarea in state_count_careerarea_selector_dict.items(
    ):
        careerarea_selector_name_initial = 'count' + experience_selector_name
        for careerarea_name, state_count in state_count_careerarea.items():
            source.add(data=state_count,
                       name=careerarea_selector_name_initial + careerarea_name)

    return source
예제 #17
0
	def create_milage_chart(self):
		# DataFrameの値を Bokeh用セット
		source = ColumnDataSource(self.df)
		source.add(self.df.index, 'index')
		
		# チャートのツールを設定
		tools = "pan,box_zoom,reset,save"

		# チャート内のツールチップのツールチップを設定
		milage_hover_tool = HoverTool(
				tooltips=[
					('日付', "@index{%F}"),
					('当日走行距離', '@Milage'+' (km)'),
					('合計走行距離', '@Sum_milage'+'( km)'),
					('目標距離', '@Sum_target'+' (km)')],
				formatters={
					'@index': 'datetime',
					},
				mode='mouse')

		# figureオブジェクトを生成
		# figureオブジェクトのlineプロパティに値を追加する
		milage_plot = figure(
				plot_width=self.width,
				plot_height=self.height,
				x_axis_type="datetime",
				x_axis_label = "date",
				y_axis_label = "distance(km)",
				title='Milage Line_Chart',
				tools=[milage_hover_tool, tools]
			)
		milage_plot.line(
				x = "index",
				y = "Sum_milage",
				source = source,
				legend = "走行距離",
				color = "blue",
				line_width = 2
			)
		milage_plot.line(
				x = "index",
				y = "Sum_target",
				source = source,
				legend = "目標値",
				color = "red",
				line_width = 2
			)
		milage_plot.add_layout(milage_plot.legend[0], 'below')

		return milage_plot
예제 #18
0
def construct_categorical_data(data_frame: pd.DataFrame,
                               c_col: str = None,
                               v_col: str = None,
                               color_col: str = None,
                               text_col: str = None):

    source = ColumnDataSource(data={
        'category': data_frame[c_col].values,
        'value': data_frame[v_col].values
    })
    if text_col is not None:
        source.add(data_frame[text_col].values, 'text')

    return source
예제 #19
0
def build_viz_withparam(df, filterBird='LIAK11EG12'):
    #print(filterState)
    gps = getArtox_gps_data()
    
    ## filter the dataset to keep only ports of the given state
    if (filterBird!='LIAK11EG12') :
        if (filterBird=='Unknown') :
            df = df[df.bird_id.isnull() ]
        else :
            df = df[df.bird_id.eq(filterBird) ]
    
    ## Build the map
    p = figure(x_range=(-9587947, 1113194), y_range=(3503549, 13195489),
               x_axis_type="mercator", y_axis_type="mercator")

    tile_provider = get_provider(CARTODBPOSITRON)
    p.add_tile(tile_provider)

    msource = ColumnDataSource(df)
    # https://docs.bokeh.org/en/latest/docs/reference/palettes.html
    color_mapper = CategoricalColorMapper(palette=["blue", "pink"], factors=["M", "F"])

    ## Filter GPS data with the choosen bird
    gpsnumber = df.loc[df['bird_id']==filterBird, 'clean_glsid'].values[0]
    gpsnumber #'148'
    msourceGPS = ColumnDataSource(gps.loc[gps['id']==gpsnumber,])

    #process the time dimension
    thisbirdtimes = gps.loc[gps['id']==gpsnumber, 'timestampgps'].values
    thisbirdtimes = pd.to_datetime(thisbirdtimes) #transform string into datetime type

    #First solution for points color : time on a continuous scale
    t = np.array([xi.timestamp()  for xi in thisbirdtimes])  #transform datetime into float type
    msourceGPS.add(t, 'timeasreal')
    point_mapper = linear_cmap(field_name='timeasreal', palette=GnBu[9], low=min(t), high=max(t))
    #OK for time on a continuous scale, you can also use the palette PiYG11

    ## Afficher les coordonnées GPS de cet oiseau
    #https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.loc.html

    #p.line(df.iloc[3, 2], df.iloc[3, 3], color='red', line_width=2)
    p.line(df.loc[df['bird_id']==filterBird, 'x_path_coordinates'].values[0], 
            df.loc[df['bird_id']==filterBird, 'y_path_coordinates'].values[0], 
            color='red', 
            line_width=1)

    p.circle(x='x', y='y', size=7, source=msourceGPS, fill_color=point_mapper, fill_alpha=1, line_alpha=0)

    return p
예제 #20
0
파일: table_widget.py 프로젝트: oly13/davil
 def init_table(view):
     """Generates the info table"""
     dimension_values_df = view.get_dimension_values_df()
     source = ColumnDataSource(dimension_values_df)
     source.add(dimension_values_df.index, name='name')
     columns = [
         TableColumn(field=field, title=field)
         for field in dimension_values_df.columns.values
     ]
     columns.insert(0, TableColumn(field='name', title='name'))
     data_table = DataTable(source=source,
                            columns=columns,
                            width=1000,
                            height=600)
     return data_table
예제 #21
0
def colorce():
    import colorcet as cc
    from numpy import linspace
    from scipy.stats.kde import gaussian_kde

    from bokeh.io import output_file, show
    from bokeh.models import ColumnDataSource, FixedTicker, PrintfTickFormatter
    from bokeh.plotting import figure
    from bokeh.sampledata.perceptions import probly

    def ridge(category, data, scale=20):
        return list(zip([category]*len(data), scale*data))

    cats = list(reversed(probly.keys()))

    palette = [cc.rainbow[i*15] for i in range(17)]

    x = linspace(-20,110, 500)

    source = ColumnDataSource(data=dict(x=x))

    p = figure(y_range=cats, plot_width=900, x_range=(-5, 105), toolbar_location=None)

    for i, cat in enumerate(reversed(cats)):
        pdf = gaussian_kde(probly[cat])
        y = ridge(cat, pdf(x))
        source.add(y, cat)
        p.patch('x', cat, color=palette[i], alpha=0.6, line_color="black", source=source)

    p.outline_line_color = None
    p.background_fill_color = "#efefef"

    p.xaxis.ticker = FixedTicker(ticks=list(range(0, 101, 10)))
    p.xaxis.formatter = PrintfTickFormatter(format="%d%%")

    p.ygrid.grid_line_color = None
    p.xgrid.grid_line_color = "#dddddd"
    p.xgrid.ticker = p.xaxis.ticker

    p.axis.minor_tick_line_color = None
    p.axis.major_tick_line_color = None
    p.axis.axis_line_color = None

    p.y_range.range_padding = 0.12
    return p
예제 #22
0
    def asbokeh_scatter(
            self,
            hover_names=None,
            tools="pan,box_zoom,wheel_zoom,reset,hover,save,zoom_in,zoom_out",
            colors=None):
        from bokeh.models import (ColumnDataSource, HoverTool, LogColorMapper)
        from bokeh.io import show, save
        from bokeh.plotting import figure, output_file
        from bokeh.embed import components
        from bokeh.models import LinearAxis, Range1d, Span

        p = figure(title=self.name, tools=tools)
        if colors == None: colors = ['red', 'blue', 'green', 'gray', 'orange']
        for i in range(len(self.ax.collections)):
            col = self.ax.collections[i]
            source = ColumnDataSource(data=dict(
                x=[x[0] for x in col.get_offsets()],
                y=[x[1] for x in col.get_offsets()],
            ))
            if len(hover_names) == len(self.ax.collections):
                #print(type(source.data))
                #source.data[hover_names[i][0]]=hover_names[i][1]
                source.add(hover_names[i][1], name=hover_names[i][0])
                pass
            p.circle('x',
                     'y',
                     source=source,
                     color=colors[i],
                     legend=col.get_label())
            continue

        p.xaxis.axis_label = self.ax.get_xlabel()
        p.yaxis.axis_label = self.ax.get_ylabel()

        hover = p.select_one(HoverTool)
        hover.point_policy = "follow_mouse"
        hover.tooltips = [
            ('x', '@x'),
            ('y', '@y'),
        ]
        if len(hover_names) == len(self.ax.collections):
            hover.tooltips.append((hover_names[0][0], '@' + hover_names[0][0]))
            pass

        return p
예제 #23
0
def get_States_Sal(states_dict):
    # call get_Data() function to get salary data
    salStateData = get_data()

    # extract states lat and lon information for generating map
    states = {code: state for code, state in states_dict.items()}

    # sort the data by state names
    states_Name = sorted(states.values(), key=lambda x: x['name'])

    state_xs = [state["lons"] for state in states_Name]
    state_ys = [state["lats"] for state in states_Name]
    state_names = [state["name"] for state in states_Name]

    # create column data source
    source = ColumnDataSource(data=dict(
        x=state_xs, y=state_ys, stateN=[name for name in state_names]))

    # get average of salary occupation group in each state
    salStateAgg = pd.DataFrame(
        salStateData.groupby(
            ['STATECODE', 'stateName'], axis=0,
            as_index=False)['SALARYAVERAGE',
                            'SALARYREALTIMEAVERAGE'].mean()).reset_index()

    # Create colorMap dictionary
    keys = tuple(pd.unique(salStateAgg["SALARYREALTIMEAVERAGE"]))
    values = tuple([
        "#000000", "#FFFF00", "#1CE6FF", "#FF34FF", "#FF4A46", "#008941",
        "#006FA6", "#A30059", "#FFDBE5", "#7A4900", "#0000A6", "#63FFAC",
        "#B79762", "#004D43", "#8FB0FF", "#997D87", "#5A0007", "#809693",
        "#FEFFE6", "#1B4400", "#4FC601", "#3B5DFF", "#4A3B53", "#FF2F80",
        "#61615A", "#BA0900", "#6B7900", "#00C2A0", "#FFAA92", "#FF90C9",
        "#B903AA", "#D16100", "#DDEFFF", "#000035", "#7B4F4B", "#A1C299",
        "#300018", "#0AA6D8", "#013349", "#00846F", "#372101", "#FFB500",
        "#C2FFED", "#A079BF", "#CC0744", "#C0B9B2", "#C2FF99", "#001E09",
        "#00489C", "#6F0062", "#0CBD66", "#EEC3FF"
    ])

    colorMap = dict(itertools.izip(keys, values))

    # add values to the source
    source.add(data=[str(x) for x in salStateAgg["STATECODE"]],
               name='statecode')
    source.add(data=[str(x) for x in salStateAgg["SALARYAVERAGE"]],
               name='salAvg')
    source.add(data=[str(x) for x in salStateAgg["SALARYREALTIMEAVERAGE"]],
               name='salRealAvg')
    source.add(
        data=[colorMap[x] for x in salStateAgg["SALARYREALTIMEAVERAGE"]],
        name='type_color')

    return source
예제 #24
0
    def get_tables(self, analyzer):
        '''
        Return a header for this analyzer and one *or more* data tables.
        '''
        if hasattr(analyzer, 'get_analysis_table'):
            title, table_columns_list = analyzer.get_analysis_table()
        else:
            # Analyzer does not provide a table function. Use our generic one
            title, table_columns_list = __class__._get_table_generic(analyzer)

        # don't add empty analyzer
        if len(table_columns_list[0][0]) == 2:
            return None, None

        param_str = get_params_str(analyzer.params)
        if len(param_str) > 0:
            title += f' ({param_str})'

        elems = []
        for table_columns in table_columns_list:
            cds = ColumnDataSource()
            columns = []
            for i, c in enumerate(table_columns):
                col_name = f'col{i}'
                cds.add(c[2:], col_name)
                columns.append(
                    TableColumn(field=col_name,
                                title=c[0],
                                formatter=self._get_formatter(c[1])))
            # define height of column by multiplying count of rows
            # with ROW_HEIGHT
            column_height = len(table_columns[0]) * ROW_HEIGHT
            elems.append(
                DataTable(
                    source=cds,
                    columns=columns,
                    index_position=None,
                    height=column_height,
                    width=0,  # set width to 0 so there is no min_width
                    sizing_mode='stretch_width',
                    fit_columns=True))
        return Paragraph(text=title, css_classes=['table-title']), elems
예제 #25
0
	def create_elevation_chart(self):
		# DataFrameの値を Bokeh用セット
		source = ColumnDataSource(self.df)
		source.add(self.df.index, 'index')
		
		# チャートのツールを設定
		tools = "pan,box_zoom,reset,save"

		# チャート内のツールチップのツールチップを設定
		elevation_hover_tool = HoverTool(
				tooltips=[
					('日付', "@index{%F}"),
					('当日獲得標高', "@Elevation"+' (m)'),
					('合計獲得標高', '@Sum_elevation'+' (m)')],
				formatters={
					'@index': 'datetime',
					},
				mode='mouse')

		# figureオブジェクトを生成
		# figureオブジェクトのlineプロパティに値を追加する
		elevation_plot = figure(
				plot_width=300,
				plot_height=300,
				x_axis_type="datetime",
				x_axis_label = "date",
				y_axis_label = "height(m)",
				title='Elevation Line_Chart',
				tools=[elevation_hover_tool, tools]
			)
		elevation_plot.line(
				x = "index",
				y = "Sum_elevation",
				source = source,
					legend = "獲得標高",
				color = "blue",
				line_width = 2
			)
		elevation_plot.add_layout(elevation_plot.legend[0], 'below')

		return elevation_plot
예제 #26
0
def create_plot(N, func1, func2, color):
    N = 300
    x = np.linspace(0, 4 * np.pi, N)
    y1 = np.sin(x)
    y2 = np.cos(x)

    source = ColumnDataSource()
    source.add(data=x, name='x')
    source.add(data=y1, name='y1')
    source.add(data=y2, name='y2')

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

    s1 = plt.figure(tools=TOOLS, plot_width=350, plot_height=350)
    s1.scatter('x', 'y1', source=source, fill_color=color)

    s2 = plt.figure(tools=TOOLS, plot_width=350, plot_height=350)
    s2.scatter('x', 'y2', source=source, fill_color=color)

    p = plt.gridplot([[s1, s2]])
    return p
예제 #27
0
 def get_table(self, data):
     table = [['Name'], ['Value']]
     cds = ColumnDataSource()
     columns = []
     for n, v in data.items():
         table[0].append(n)
         table[1].append(v)
     for i, c in enumerate(table):
         col_name = f'col{i}'
         cds.add(c[1:], col_name)
         columns.append(TableColumn(field=col_name, title=c[0]))
     column_height = len(table[0]) * ROW_HEIGHT
     dtable = DataTable(
         source=cds,
         columns=columns,
         index_position=None,
         height=column_height,
         width=0,  # set width to 0 so there is no min_width
         sizing_mode='stretch_width',
         fit_columns=True)
     return dtable
예제 #28
0
def create_plot(N, func1, func2, color):
    N = 300
    x = np.linspace(0, 4*np.pi, N)
    y1 = np.sin(x)
    y2 = np.cos(x)

    source = ColumnDataSource()
    source.add(data=x, name='x')
    source.add(data=y1, name='y1')
    source.add(data=y2, name='y2')

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

    s1 = plt.figure(tools=TOOLS, plot_width=350, plot_height=350)
    s1.scatter('x', 'y1', source=source, fill_color=color)

    s2 = plt.figure(tools=TOOLS, plot_width=350, plot_height=350)
    s2.scatter('x', 'y2', source=source, fill_color=color)

    p = plt.gridplot([[s1,s2]])
    return p
예제 #29
0
    def _make_edge_source(self, node_source=None):
        """ Collect Bokeh DataSource for graph edges
        """
        G = self.graph
        if node_source is None:
            node_source = self._make_node_source()

        winner, loser, match_data = zip(*G.edges(data=True))
        
        # transfer data from networkx graph
        edge_source = ColumnDataSource()
        edge_source.add(winner, 'winner')
        edge_source.add(loser, 'loser')
        for varname in ['round', 'win_score', 'los_score']:
            edge_source.add([m[varname] for m in match_data], varname)
        
        # collect start and end point for each match
        node_data = node_source.to_df()[node_source.to_df()['round']==1].set_index('team')
        # node_data = node_source.to_df().set_index('index')
        x_vals = []
        y_vals = []
        for w, l in zip(winner, loser):
            x_vals.append([node_data.loc[w]['x'], node_data.loc[l]['x']])
            y_vals.append([node_data.loc[w]['y'], node_data.loc[l]['y']])
        edge_source.add(x_vals, 'x_vals')
        edge_source.add(y_vals, 'y_vals')
        
        # calculate position of markers for winning team
        x_diamond = []
        y_diamond = []
        for xs, ys in zip(x_vals, y_vals):
            norm = np.sqrt((xs[1] - xs[0])**2 + (ys[1]-ys[0])**2)
            unit_vec_x = (xs[1] - xs[0]) / norm
            unit_vec_y = (ys[1] - ys[0]) / norm
            x_diamond.append(xs[0] + 0.2 * unit_vec_x)
            y_diamond.append(ys[0] + 0.2 * unit_vec_y)
        edge_source.add(x_diamond, 'x_diamond')
        edge_source.add(y_diamond, 'y_diamond')

        return edge_source
예제 #30
0
    def plot_time_series(data, fig, fig_size=[800, 350], title="", legend="", labels=["Date", ""],
                         linewidth=1, color="blue", linestyle="solid", alpha=1):

        fig.plot_width = fig_size[0]
        fig.plot_height = fig_size[1]

        source = ColumnDataSource()
        source.add(data.index, name="date")
        source.add(data.values, name="values")
        source.add(data.index.strftime("%Y-%m-%d %H:%M:%S"), "date_formatted")

        # create a line plot
        fig.line(source=source, x="date", y="values",
                 legend=legend, line_color=color, line_dash=linestyle, line_alpha=alpha, line_width=linewidth)

        fig.title.text = title
        fig.title.text_font = 'Helvetica'
        fig.title.text_font_size = '18px'
        fig.title.align = 'center'

        fig.legend.background_fill_alpha = 0.6
        fig.legend.label_text_font = 'Helvetica'
        fig.legend.location = 'bottom_right'

        fig.xaxis.axis_label = labels[0]
        fig.yaxis.axis_label = labels[1]

        hover = HoverTool(tooltips=[("Value: ", "@values"), ("Timestamp: ", "@date_formatted")])
        hover.formatters = {'Timestamp': "datetime"}
        fig.add_tools(hover)
        fig.toolbar_location = "above"

        return fig
예제 #31
0
    def _plot_unique_value(data, figsize):

        f = figure(x_range=list(data.index), tools="box_select, pan, reset, save")
        f.plot_width = figsize[0]
        f.plot_height = figsize[1]

        # Background settings
        f.background_fill_color = '#859dcd'
        f.background_fill_alpha = 0.05

        # Title settings
        f.title.text = 'Number of Unique Values Histogram'
        f.title.text_font = 'Helvetica'
        f.title.text_font_size = '24px'
        f.title.align = 'center'
        f.title.text_font_style = "italic"

        # Axis settings
        f.xaxis.axis_label = 'Unique Values'
        f.xaxis.major_label_orientation = np.pi / 3
        f.yaxis.axis_label = 'Frequency'
        f.axis.axis_label_text_font_size = '16px'

        f.xgrid.grid_line_color = None

        source = ColumnDataSource()
        source.add(data.index, 'features')
        source.add(data['nunique'], 'nunique')

        f.vbar(x='features', top='nunique', source=source,
               alpha=0.7, width=0.9, color='#3399c1')

        hover = HoverTool(tooltips=[('Feature', '@features'),
                                    ('# Values', '@nunique')])
        f.add_tools(hover)

        show(f)
예제 #32
0
    def _plot_word_freq(frequencies_dist, plot_n, figsize):
        tab_list = []
        for label in frequencies_dist.keys():

            freqdist = frequencies_dist[label]
            df = DataFrame({'word': list(freqdist.keys()),
                            'count': list(freqdist.values())})
            df.sort_values('count', inplace=True, ascending=False)
            df.reset_index(inplace=True, drop=True)

            source = ColumnDataSource(data=df[:plot_n])
            source.add(df.index[:plot_n], 'index')

            f = figure(x_range=list(df['word'])[:plot_n],
                       tools="box_select, pan, reset, save")
            f.plot_width = figsize[0]
            f.plot_height = figsize[1]

            f.title.text = 'Word frequency for "%s"' % label
            f.title.text_font = 'Helvetica'
            f.title.text_font_size = '24px'
            f.title.align = 'center'

            f.xaxis.axis_label = 'Samples'
            f.yaxis.axis_label = 'Count'
            f.xaxis.major_label_orientation = np.pi / 2

            f.line(source=source, x='word', y='count')

            hover = HoverTool(tooltips=[("Word", "@word"), ("Count", "@count")], mode='vline')
            f.add_tools(hover)

            tab = Panel(child=f, title=label)
            tab_list.append(tab)

        tabs = Tabs(tabs=tab_list)
        show(tabs)
예제 #33
0
    def get_analyzers_tables(
            self, analyzer: bt.analyzers.Analyzer, strategy: bt.Strategy,
            params: Optional[bt.AutoInfoClass]
    ) -> (Paragraph, List[DataTable]):
        if hasattr(analyzer, 'get_analysis_table'):
            title, table_columns_list = analyzer.get_analysis_table()
        else:
            # Analyzer does not provide a table function. Use our generic one
            title, table_columns_list = TableGenerator._get_analysis_table_generic(
                analyzer)

        # if we have multiple strategies in the mix, add the name of the involved one
        if len(strategy.env.strats) > 0:
            title += f' ({get_strategy_label(strategy, params)})'

        elems: List[DataTable] = []
        for table_columns in table_columns_list:
            cds = ColumnDataSource()
            columns = []
            for i, c in enumerate(table_columns):
                col_name = f'col{i}'
                cds.add(c[2:], col_name)
                columns.append(
                    TableColumn(field=col_name,
                                title=c[0],
                                formatter=TableGenerator._get_formatter(c[1])))
            column_height = len(table_columns[0]) * 25
            elems.append(
                DataTable(source=cds,
                          columns=columns,
                          width=self._scheme.table_width,
                          height=column_height,
                          row_headers=False))
        return Paragraph(text=title,
                         width=self._scheme.table_width,
                         style={'font-size': 'large'}), elems
예제 #34
0
파일: viz.py 프로젝트: AlJohri/iem-scraper
def plot_interactive_timeseries(df, col):

    # https://github.com/bokeh/bokeh/pull/3883

    hover = HoverTool(tooltips=[
        ("y (%s)" % col, "$y{1.11}"),
        ("Date", "@DateStr"),
        ("LastPrice", "@LastPrice{1.11}"),
        ("LowPrice", "@LowPrice{1.11}"),
        ("HighPrice", "@HighPrice{1.11}"),
        # ("AvgPrice", "@AvgPrice{1.11}"),
        ("Units", "@Units{int}"),
        ("Volume", "@Volume{1.11}")
    ])

    p = figure(
        plot_width=bokeh.charts.defaults.width, 
        plot_height=bokeh.charts.defaults.height, 
        x_axis_type="datetime",
        title="PRES16_WTA: Date vs %s" % col)

    for contract, group in df.groupby('Contract'):
        source = ColumnDataSource(group[[x for x in group.columns if x != "AvgPrice"]])
        source.add(group.Date.map(lambda x: x.strftime('%x')), 'DateStr')
        color = "blue" if contract == "DEM16_WTA" else ("red" if contract == "REP16_WTA" else "black")
        p.line(x='Date', y=col, color=color, legend=contract,
               line_width=2, 
               source=source)
    p.add_tools(hover)

    p.xaxis.axis_label = "Date"
    p.yaxis.axis_label = col
    p.legend.location = "top_left"
    p.logo = None

    return p
예제 #35
0
def stackedBar(self, source, x, y, **kwargs):
    '''
    A stacked barchart for categorical vs. categorical data.
    '''
    if not isinstance(source, pd.core.groupby.DataFrameGroupBy):
        msg = "source has to be a pandas.DataFrameGroupyBy. Received " + str(
            type(df)
        ) + " Use df.groupy([" + x + "," + y + "]) to obtain valid input."
        raise TypeError(msg)

    # make sure we have a quantitative variable that is used in source.describe()
    cds = ColumnDataSource(source)
    cds.add(source.count().index.get_level_values(1), 'labels')
    factors = list(source[x].count().index.levels[0])

    self.vbar(x=x + '_' + y,
              top='mycnt_count',
              width=1,
              source=cds,
              line_color='white')

    labels = LabelSet(x=x + '_' + y,
                      y='mycnt_count',
                      text='labels',
                      level='glyph',
                      text_align='center',
                      text_font_size='6pt',
                      y_offset=3,
                      source=cds,
                      render_mode='canvas')

    self.y_range.start = 0
    self.xgrid.grid_line_color = None
    self.xaxis.major_label_orientation = 1.2
    self.outline_line_color = None
    self.add_layout(labels)
예제 #36
0
파일: plotter.py 프로젝트: Vanova/PyNNier

    cats = list(reversed(probly.keys()))

    palette = [cc.rainbow[i * 15] for i in range(17)]

    x = linspace(-20, 110, 500)

    source = ColumnDataSource(data=dict(x=x))

    p = figure(y_range=cats, plot_width=700, x_range=(-5, 105), toolbar_location=None)

    for i, cat in enumerate(reversed([cats[0]])):
        pdf = gaussian_kde(probly[cat])
        y = joy(cat, pdf(x))
        source.add(y, cat)
        p.patch('x', cat, color=palette[i], alpha=0.6, line_color="black", source=source)

        source2 = ColumnDataSource(data=dict(x=x))
        pdf = gaussian_kde(probly[cats[3]])
        y2 = joy(cat, pdf(x), scale=30)
        source2.add(y2, cat)
        p.patch('x', cat, color=palette[(2*i) % 17], alpha=0.3, line_color="black", source=source2)

        # x = [1, 3, 2]
        # y = [(cat, 3),
        #      (cat, 2),
        #      (cat, 1)]
        # p.patch(x, y, color=palette[8], alpha=0.4, line_color="black")

    p.outline_line_color = None
예제 #37
0
# The plot server must be running
# Go to http://localhost:5006/bokeh to view this plot

import numpy as np
from bokeh.plotting import *
from bokeh.models import ColumnDataSource

output_server("linked_brushing")

N = 300
x = np.linspace(0, 4*np.pi, N)
y1 = np.sin(x)
y2 = np.cos(x)

source = ColumnDataSource()
source.add(data=x, name='x')
source.add(data=y1, name='y1')
source.add(data=y2, name='y2')

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

s1 = figure(tools=TOOLS, plot_width=350, plot_height=350)
s1.scatter('x', 'y1', source=source)

# Linked brushing in Bokeh is expressed by sharing data sources between
# renderers. Note below that s2.scatter is called with the `source`
# keyword argument, and supplied with the same data source from s1.scatter
s2 = figure(tools=TOOLS, plot_width=350, plot_height=350)
s2.scatter('x', 'y2', source=source)

p = gridplot([[s1,s2]])
예제 #38
0
    return list(zip([category]*len(data), scale*data))

cats = list(reversed(probly.keys()))

palette = [cc.rainbow[i*15] for i in range(17)]

x = linspace(-20,110, 500)

source = ColumnDataSource(data=dict(x=x))

p = figure(y_range=cats, plot_width=700, x_range=(-5, 105), toolbar_location=None)

for i, cat in enumerate(reversed(cats)):
    pdf = gaussian_kde(probly[cat])
    y = ridge(cat, pdf(x))
    source.add(y, cat)
    p.patch('x', cat, color=palette[i], alpha=0.6, line_color="black", source=source)

p.outline_line_color = None
p.background_fill_color = "#efefef"

p.xaxis.ticker = FixedTicker(ticks=list(range(0, 101, 10)))
p.xaxis.formatter = PrintfTickFormatter(format="%d%%")

p.ygrid.grid_line_color = None
p.xgrid.grid_line_color = "#dddddd"
p.xgrid.ticker = p.xaxis[0].ticker

p.axis.minor_tick_line_color = None
p.axis.major_tick_line_color = None
p.axis.axis_line_color = None
예제 #39
0
fig.add_tools(HoverTool(renderers=[states], tooltips=[("State", "@state"), ("Total", "@total"), ("Drunk Percent", "@perc_drunk"), ("Speeding Percent",  "@perc_speeding")]))

# -------------------------------------------------

from bokeh.io import output_file, show
from bokeh.layouts import column
from bokeh.models.widgets import Select
from bokeh.palettes import Reds9

output_file("final_bokeh.html")

select = Select(title="Option:", value="Default",
        options=["Other", "Speeding", "Drunk", "Default"])

border_source.add("white", name="color")

fig = Figure(plot_width=1100, plot_height=650,
x_range=(-13000000, -7000000), y_range=(2750000, 6250000),
tools=["wheel_zoom", "pan"], active_scroll="wheel_zoom", webgl=True)

fig.axis.visible = False

STAMEN_TONER_BACKGROUND = WMTSTileSource(
url='http://tile.stamen.com/toner-background/{Z}/{X}/{Y}.png',
attribution=(
'Map tiles by <a href="http://stamen.com">Stamen Design</a>, '
'under <a href="http://creativecommons.org/licenses/by/3.0">CC BY -3.0</a>.'
'Data by <a href="http://openstreetmap.org">OpenStreetMap</a>, '
'under <a href="http://www.openstreetmap.org/copyright">ODbL</a>'
)
예제 #40
0
 def compute_data_source(self):
     source = ColumnDataSource(self.df.reset_index()[2:])
     source.add(self.df[2:].LogReturns.ge(0).map(lambda x: "steelblue" if x else "red"), 'LogReturnsColor')
     source.add(self.df[2:].DevolLogReturns / 2., 'y_mids')
     return source
예제 #41
0
    # example: { ..., ('user47', 'da_bjoerni', {'weight': 3}), ... }
    for u, v, data in _network.edges(data=True):
        d['xs'].append([_layout[u][0], _layout[v][0]])
        d['ys'].append([_layout[u][1], _layout[v][1]])
        d['alphas'].append(calc_alpha(data['weight']))
    return d


lines_source = ColumnDataSource(get_edges_specs(network, layout))
r_lines = plot.multi_line('xs', 'ys', line_width=1.5, alpha='alphas', color='navy',
                          source=lines_source)

centrality = networkx.algorithms.centrality.degree_centrality(network)
# first element, are nodes again
_, nodes_centrality = zip(*sorted(centrality.items()))
nodes_source.add([7 + 10 * t / max(nodes_centrality) for t in nodes_centrality], 'centrality')

partition = community.best_partition(network)
p_, nodes_community = zip(*sorted(partition.items()))
nodes_source.add(nodes_community, 'community')
community_colors = ['#e41a1c','#377eb8','#4daf4a','#984ea3','#ff7f00','#ffff33','#a65628', '#b3cde3','#ccebc5','#decbe4','#fed9a6','#ffffcc','#e5d8bd','#fddaec','#1b9e77','#d95f02','#7570b3','#e7298a','#66a61e','#e6ab02','#a6761d','#666666']
nodes_source.add([community_colors[t % len(community_colors)]
                  for t in nodes_community], 'community_color')

r_circles.glyph.size = 'centrality'
r_circles.glyph.fill_color = 'community_color'


def remove_node():
    idx = nodes_source.selected['1d']['indices'][0]
예제 #42
0
def create_sparkline(obj):
    sparkline_toolset = "box_select"

    # Generate a figure container
    plot = plotting.figure(
        height=150, width=PLOTS_WIDTH, tools=sparkline_toolset,
        x_axis_location="above", y_axis_label='Adj. Close Price',
        # title=obj.selected_symbol,
        x_axis_type="datetime", toolbar_location=None,
        outline_line_color=None,
        name="small_plot"
    )
    plot.min_border_bottom = plot.min_border_top = 0
    plot.background_fill = '#EEEEEE'
    plot.border_fill = "white"

    # Create source and glyphs for the P&D orange boxes
    psource = ColumnDataSource(obj.intervals_source.data)

    glyph = Quad(top='values', bottom='bottom', left='start', right='end',
                 fill_color='orange', fill_alpha=0.3, line_alpha=0)
    empty_glyph = Quad(top='values', bottom='bottom', left='start', right='end',
                 fill_color='orange', fill_alpha=0.3, line_alpha=0)
    plot.add_glyph(
            psource, glyph,
            selection_glyph=glyph,
            nonselection_glyph=empty_glyph
        )
    # psource.tags = ['pump_and_dumps']

    # Create source and glyphs for the light blue boxes showed
    # when an interval is selected
    selection_source = ColumnDataSource()
    for k in ['end', 'values', 'start', 'bottom']:
        selection_source.add([], k)
    plot.quad(top='values', bottom='bottom', left='start', right='end',
              source=selection_source, color='#c6dbef', fill_alpha=0.5)

    for k in ['scatter', 'line']:
        plot = factories.makers[k](
            'dt', ['price'], source=obj.source, colors=['#666666'],
            p=plot
        )
    obj.source.tags = ['min_source']

    # Customize select tool
    select_tool = plot.select(dict(type=BoxSelectTool))
    select_tool.dimensions = ['width']
    zoom_tool = plot.select(dict(type=BoxZoomTool))
    zoom_tool.dimensions = ['width']

    maxval = max(obj.source.data['price'])

    objs = {
        # TODO: PASSING A PLOT OR ITS RANGE TO A CB MAKES IT BREAK EVT TAPTOOL!!!!!
        'spark_source': obj.source,
        'selection_source': selection_source,
        'evts_source': obj._plugins[0].evts_source,
        'spam_source': obj.spam_source,
        'sec_source': obj.sec_source,

    }
    callback = Callback(args=objs, code=callbacks.small_selection_plot % maxval)
    obj.source.callback = callback

    plot.ygrid.grid_line_color = None

    style_axis(plot)
    plot.tags = ['small_plot']
    add_evt_plugins(obj, plot, copy_source=True)
    return plot
예제 #43
0
파일: content.py 프로젝트: Vanova/PyNNier
    palette = [cc.rainbow[i * 15] for i in range(len(cats))]
    bins = np.linspace(0., 1., N_HIST)
    delta = (bins[1] - bins[0])
    center = (bins[:-1] + bins[1:]) / 2
    xr = np.linspace(-0.5, 1.5, 100)

    plots = []
    for ld in lang_dirs:
        p = figure(x_range=(0., 1.), y_range=cats, plot_width=400, plot_height=500, toolbar_location=None, title='Language: %s' % ld)
        nframes = stats_store[ld][Stats.len] * 3600. / 10e-3
        h = stats_store[ld][Stats.hist] / nframes
        source = ColumnDataSource(data=dict(x=xr))
        for at_id, at in enumerate(ATTRIBUTES_CLS[attrib_type]):
            pdf = gaussian_kde(h[at_id, :])
            y = joy(at, pdf(xr), scale=0.2)
            source.add(y, at)
            p.patch('x', at, color=palette[at_id], alpha=0.6, line_color="black", source=source)
        p.y_range.range_padding = 0.12
        plots.append(p)

    bio.show(bl.column(*plots))

    # ===
    # Violin Figures
    # ===
    fig, axs = plt.subplots(len(lang_dirs), 1, figsize=(10, 30), facecolor='w', edgecolor='k')
    fig.subplots_adjust(hspace=0.01, wspace=.5)
    axs = axs.ravel()
    xp = np.linspace(0., 1.1, 100)

    for i, ld in enumerate(lang_dirs):
예제 #44
0
from bokeh.models import ColumnDataSource
from bokeh.plotting import *

import numpy as np

output_file("static_plot.html")

N = 300
x = np.linspace(0, 4 * np.pi, N)
y1 = np.sin(x)
y2 = np.cos(x)

source = ColumnDataSource()
source.add(data=x, name="x")
source.add(data=y1, name="y1")
source.add(data=y2, name="y2")

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

s1 = figure(tools=TOOLS, plot_width=350, plot_height=350)
s1.scatter("x", "y1", source=source)

s2 = figure(tools=TOOLS, plot_width=350, plot_height=350)
s2.scatter("x", "y2", source=source)

p = gridplot([[s1, s2]])
show(p)