def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): sc_co = LinearScale() sc_co2 = LinearScale() ax_y = Axis(label='Bollinger b1', scale=sc_co, orientation='vertical') ax_y2 = Axis(label='Bollinger b2', scale=sc_co2, orientation='vertical', side='right') new_line = Lines(x=stock.datetime.to_array(), y=stock['out0'].to_array(), scales={ 'x': dt_scale, 'y': sc_co }, colors=[CATEGORY20[color_id[0]]]) new_line2 = Lines(x=stock.datetime.to_array(), y=stock['out1'].to_array(), scales={ 'x': dt_scale, 'y': sc_co2 }, colors=[CATEGORY20[(color_id[0] + 1) % len(CATEGORY20)]]) new_fig = Figure(marks=[new_line, new_line2], axes=[ax_y, ax_y2]) new_fig.layout.height = indicator_figure_height new_fig.layout.width = figure_width figs = [new_line, new_line2] add_new_indicator(new_fig) return figs
def __init__(self, **kwargs): self._mark = Lines(scales={ 'x': LinearScale(), 'y': LinearScale() }, colors=['red']) super().__init__(**kwargs) self.update_mark()
def process(self, inputs): """ Plot the lines from the input dataframe. The plotted lines are the columns in the input dataframe which are specified in the `lines` of node's `conf` The plot title is defined in the `title` of the node's `conf` Arguments ------- inputs: list list of input dataframes. Returns ------- Figure """ input_df = inputs[self.INPUT_PORT_NAME] num_points = self.conf['points'] stride = max(len(input_df) // num_points, 1) date_co = DateScale() linear_co = LinearScale() yax = Axis(label='', scale=linear_co, orientation='vertical') xax = Axis(label='Time', scale=date_co, orientation='horizontal') panzoom_main = PanZoom(scales={'x': [date_co]}) lines = [] for line in self.conf['lines']: col_name = line['column'] label_name = line['label'] color = line['color'] if (isinstance(input_df, cudf.DataFrame) or isinstance(input_df, dask_cudf.DataFrame)): line = Lines(x=input_df['datetime'][::stride].to_array(), y=input_df[col_name][::stride].to_array(), scales={ 'x': date_co, 'y': linear_co }, colors=[color], labels=[label_name], display_legend=True) else: line = Lines(x=input_df['datetime'][::stride], y=input_df[col_name][::stride], scales={ 'x': date_co, 'y': linear_co }, colors=[color], labels=[label_name], display_legend=True) lines.append(line) new_fig = Figure(marks=lines, axes=[yax, xax], title=self.conf['title'], interaction=panzoom_main) return {self.OUTPUT_PORT_NAME: new_fig}
def process(self, inputs): """ Plot the P & L graph from the `strategy_returns` column. `label` in the `conf` defines the stock symbol name Arguments ------- inputs: list list of input dataframes. Returns ------- Figure """ input_df = inputs[self.INPUT_PORT_NAME] if isinstance(input_df, dask_cudf.DataFrame): input_df = input_df.compute() # get the computed value label = 'stock' if 'label' in self.conf: label = self.conf['label'] num_points = self.conf['points'] stride = max(len(input_df) // num_points, 1) date_co = DateScale() linear_co = LinearScale() yax = Axis(label='Cumulative return', scale=linear_co, orientation='vertical') xax = Axis(label='Time', scale=date_co, orientation='horizontal') panzoom_main = PanZoom(scales={'x': [date_co]}) if (isinstance(input_df, cudf.DataFrame) or isinstance(input_df, dask_cudf.DataFrame)): line = Lines( x=input_df['datetime'][::stride].to_array(), y=(input_df['strategy_returns'].cumsum())[::stride].to_array(), scales={ 'x': date_co, 'y': linear_co }, colors=['blue'], labels=[label], display_legend=True) else: line = Lines(x=input_df['datetime'][::stride], y=(input_df['strategy_returns'].cumsum())[::stride], scales={ 'x': date_co, 'y': linear_co }, colors=['blue'], labels=[label], display_legend=True) new_fig = Figure(marks=[line], axes=[yax, xax], title='P & L', interaction=panzoom_main) return {self.OUTPUT_PORT_NAME: new_fig}
def __init__(self): self.threads = [] self.tick_server_process = None self.context = None self.socket = None self.df = pd.DataFrame(data={'AAPL': [], 'SMA1': [], 'SMA2': []}) self.x_sc = DateScale() self.y_sc = LinearScale() self.line = Lines(x=[], y=[], scales={ 'x': self.x_sc, 'y': self.y_sc }, stroke_width=2.5, display_legend=True, labels=['Asset Price'], colors=['dodgerblue']) self.sma1 = Lines(x=[], y=[], scales={ 'x': self.x_sc, 'y': self.y_sc }, stroke_width=1.5, display_legend=True, labels=['SMA1'], colors=['darkorange']) self.sma2 = Lines(x=[], y=[], scales={ 'x': self.x_sc, 'y': self.y_sc }, stroke_width=1.5, display_legend=True, labels=['SMA2'], colors=['limegreen']) self.ax_x = Axis(scale=self.x_sc, grid_lines='solid', label='Time') self.ax_y = Axis(scale=self.y_sc, orientation='vertical', tick_format='0.2f', grid_lines='solid', label='Price') self.fig = Figure(marks=[self.line, self.sma1, self.sma2], axes=[self.ax_x, self.ax_y], title='Streaming Data', legend_location='top-left', layout=Layout(flex='1 1 auto', width='100%')) display(HBox([self.fig]).add_class('theme-dark'))
def __init__(self, obj, function, x_label="x", y_label="y", title=None): """ Function takes an object, and returns (x,y) point. """ self.obj = obj self.x_label = x_label self.y_label = y_label self.function = function self.x_values = [] self.y_values = [] self.title = title x_sc = LinearScale() y_sc = LinearScale() line = Lines(x=[], y=[], scales={ "x": x_sc, "y": y_sc }, stroke_width=3, colors=["red"]) ax_x = Axis(scale=x_sc, label=x_label) ax_y = Axis(scale=y_sc, orientation="vertical", label=y_label) self.widget = Figure(marks=[line], axes=[ax_x, ax_y], title=self.title)
def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): line = Lines(x=stock.datetime.to_array(), y=stock['out'].to_array(), scales={'x': dt_scale, 'y': sc}, colors=[CATEGORY20[color_id[0]]]) figs = [line] f.marks = f.marks + figs return figs
def create_lineplot(self): return Lines( x=self.years, y=[], scales={ "x": self.sc_x, "y": self.sc_y }, display_legend=True, )
def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): sc_co = LinearScale() ax_y = Axis(label='RSI', scale=sc_co, orientation='vertical') new_line = Lines(x=stock.datetime, y=stock['out'], scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]]) new_fig = Figure(marks=[new_line], axes=[ax_y]) new_fig.layout.height = indicator_figure_height new_fig.layout.width = figure_width figs = [new_line] # add new figure add_new_indicator(new_fig) return figs
def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): sc_co = LinearScale() sc_co2 = LinearScale() sc_co3 = LinearScale() sc_co4 = LinearScale() sc_co5 = LinearScale() sc_co6 = LinearScale() sc_co7 = LinearScale() ax_y = Axis(label='PPSR PP', scale=sc_co, orientation='vertical') ax_y2 = Axis(label='PPSR R1', scale=sc_co2, orientation='vertical', side='right') ax_y3 = Axis(label='PPSR S1', scale=sc_co3, orientation='vertical', side='right') ax_y4 = Axis(label='PPSR R2', scale=sc_co4, orientation='vertical', side='right') ax_y5 = Axis(label='PPSR S2', scale=sc_co5, orientation='vertical', side='right') ax_y6 = Axis(label='PPSR R3', scale=sc_co6, orientation='vertical', side='right') ax_y7 = Axis(label='PPSR S3', scale=sc_co7, orientation='vertical', side='right') new_line = Lines(x=stock.datetime.to_array(), y=stock['out0'].to_array(), scales={'x': dt_scale, 'y': sc_co}, colors=[CATEGORY20[color_id[0]]]) new_line2 = Lines(x=stock.datetime.to_array(), y=stock['out1'].to_array(), scales={'x': dt_scale, 'y': sc_co2}, colors=[CATEGORY20[(color_id[0] + 1) % len(CATEGORY20)]]) new_line3 = Lines(x=stock.datetime.to_array(), y=stock['out2'].to_array(), scales={'x': dt_scale, 'y': sc_co3}, colors=[CATEGORY20[(color_id[0] + 2) % len(CATEGORY20)]]) new_line4 = Lines(x=stock.datetime.to_array(), y=stock['out3'].to_array(), scales={'x': dt_scale, 'y': sc_co4}, colors=[CATEGORY20[(color_id[0] + 3) % len(CATEGORY20)]]) new_line5 = Lines(x=stock.datetime.to_array(), y=stock['out4'].to_array(), scales={'x': dt_scale, 'y': sc_co5}, colors=[CATEGORY20[(color_id[0] + 4) % len(CATEGORY20)]]) new_line6 = Lines(x=stock.datetime.to_array(), y=stock['out5'].to_array(), scales={'x': dt_scale, 'y': sc_co6}, colors=[CATEGORY20[(color_id[0] + 5) % len(CATEGORY20)]]) new_line7 = Lines(x=stock.datetime.to_array(), y=stock['out6'].to_array(), scales={'x': dt_scale, 'y': sc_co7}, colors=[CATEGORY20[(color_id[0] + 6) % len(CATEGORY20)]]) new_fig = Figure(marks=[new_line, new_line2, new_line3, new_line4, new_line5, new_line6, new_line7], axes=[ax_y, ax_y2, ax_y3, ax_y4, ax_y5, ax_y6, ax_y7]) new_fig.layout.height = indicator_figure_height new_fig.layout.width = figure_width figs = [new_line, new_line2, new_line3, new_line4, new_line5, new_line6, new_line7] add_new_indicator(new_fig) return figs
def __init__(self): self.niveau = Dropdown(options=[('Niveau {}'.format(i), i) for i in RushHour.niveaux()]) self.niveau.observe(lambda widget: self.change_niveau(widget.owner.value)) self.voiture = Dropdown(options=[]) self.modele = Plateau(1) self.vue = Figure(scale_x = LinearScale(min=0, max=self.modele.dimension), scale_y = LinearScale(min=self.modele.dimension, max=0)) self.vue.layout.width="75ex" self.vue.layout.width="75ex" self.vue.layout.height=self.vue.layout.width; self.vue.vue_voitures = {} for lettre, couleur in couleurs.items(): vue_voiture = Lines(x=[], y=[], scales={'x':self.vue.scale_x, 'y':self.vue.scale_y}, fill='inside', colors=[couleurs[lettre]], visible=False, tooltip=Tooltip(fields=["lettre"],show_labels=False), ) vue_voiture.lettre = "coucou" # lettre vue_voiture.on_click(lambda vue_voiture, _: self.choix_voiture(vue_voiture.lettre)) self.vue.vue_voitures[lettre] = vue_voiture self.vue.marks = list(self.vue.vue_voitures.values()) boutton_solution = Button(description="Solution") boutton_solution.on_click(self.montre_solution) VBox.__init__(self, [HBox([self.niveau, boutton_solution]), self.vue, self.boutton_direction('U'), HBox([self.boutton_direction('L'), self.voiture, self.boutton_direction('R')]), self.boutton_direction('D') ]) self.layout.align_items = 'center' self.change_niveau(1)
def __init__(self, colors='red', **kwargs): if isinstance(colors, str): colors = [colors] scales = { 'x': LinearScale(allow_padding=False), 'y': LinearScale(allow_padding=False, orientation='vertical'), } mark = Lines(x=np.zeros((2, )), y=np.zeros((2, )), scales=scales, colors=colors) super().__init__(mark=mark, **kwargs)
def process(self, inputs): """ Plot the ROC curve Arguments ------- inputs: list list of input dataframes. Returns ------- Figure """ input_df = inputs[self.INPUT_PORT_NAME] if isinstance(input_df, dask_cudf.DataFrame): input_df = input_df.compute() # get the computed value label_col = input_df[self.conf['label']].values pred_col = input_df[self.conf['prediction']].values if isinstance(input_df, cudf.DataFrame): fpr, tpr, _ = metrics.roc_curve(label_col.get(), pred_col.get()) else: fpr, tpr, _ = metrics.roc_curve(label_col, pred_col) auc_value = metrics.auc(fpr, tpr) out = {} if self.outport_connected(self.OUTPUT_PORT_NAME): linear_x = LinearScale() linear_y = LinearScale() yax = Axis(label='True Positive Rate', scale=linear_x, orientation='vertical') xax = Axis(label='False Positive Rate', scale=linear_y, orientation='horizontal') panzoom_main = PanZoom(scales={'x': [linear_x]}) curve_label = 'ROC (area = {:.2f})'.format(auc_value) line = Lines(x=fpr, y=tpr, scales={'x': linear_x, 'y': linear_y}, colors=['blue'], labels=[curve_label], display_legend=True) new_fig = Figure(marks=[line], axes=[yax, xax], title='ROC Curve', interaction=panzoom_main) out.update({self.OUTPUT_PORT_NAME: new_fig}) if self.outport_connected(self.OUTPUT_VALUE_NAME): out.update({self.OUTPUT_VALUE_NAME: float(auc_value)}) return out
def create_figure(stock, dt_scale, sc, color_id, f, indicator_figure_height, figure_width, add_new_indicator): sc_co = LinearScale() ax_y = Axis(label='MACD', scale=sc_co, orientation='vertical') new_line = Lines(x=stock.datetime.to_array(), y=[stock['out0'].to_array(), stock['out1'].to_array(), stock['out2'].to_array()], scales={'x': dt_scale, 'y': sc_co}) new_fig = Figure(marks=[new_line], axes=[ax_y]) new_fig.layout.height = indicator_figure_height new_fig.layout.width = figure_width figs = [new_line] # add new figure add_new_indicator(new_fig) return figs
def create_fig(self, ts): ts.sort_index(inplace=True) df = ts.reset_index() # time = ts.Time self.xd = df[self.xlabel] self.yd = df[self.cols].T # line_style # {‘solid’, ‘dashed’, ‘dotted’, ‘dash_dotted’} – Line style. line = Lines(x=self.xd, y=self.yd, scales={ 'x': self.xScale, 'y': self.yScale }, labels=self.legends, display_legend=True, line_style='solid', marker='circle', selected_style={'opacity': '1'}, unselected_style={ 'opacity': '0.2' }) # enable_hover=True) # axes_options=axes_options) x_axis = Axis(scale=self.xScale, label=self.xlabel, grid_lines='none') y_axis = Axis(scale=self.yScale, label=self.ylabel, orientation='vertical', grid_lines='none') margin = dict(top=0, bottom=30, left=50, right=50) self.fig = Figure(marks=[line], axes=[x_axis, y_axis], legend_location='top-right', fig_margin=margin) # {'top':50,'left':60}) self.deb = HTML() self.deb2 = HTML()
def get_final_plot(self, quad_funcs=[np.abs, np.angle]): if not self.done.is_set(): raise Exception( "Cannot get final plot since plotter is not done or was not run." ) from bqplot import LinearScale, ColorScale, ColorAxis, Axis, Lines, Figure, Tooltip, HeatMap from bqplot.toolbar import Toolbar from ipywidgets import VBox, HBox if self.final_buffer is None: self.final_buffer = self._final_buffer.get() if self.plot_dims.value == 2: raise NotImplementedError( "2 dimensional get_final_plot not yet implemented.") elif self.plot_dims.value == 1: figs = [] for quad_func in quad_funcs: sx = LinearScale() sy = LinearScale() ax = Axis(label=self.axis_label(-1), scale=sx) ay = Axis( label= f"{self.descriptor.data_name} ({self.descriptor.data_unit})", scale=sy, orientation='vertical') line = Lines(x=self.x_values, y=quad_func(self.final_buffer), scales={ 'x': sx, 'y': sy }) fig = Figure(marks=[line], axes=[ax, ay], title=self.filter_name) figs.append(fig) if len(figs) <= 2: return HBox(figs) elif len(figs) == 4: return VBox([HBox([figs[0], figs[1]]), HBox([figs[2], figs[3]])]) elif len(figs) == 3 or len(figs) > 4: raise Exception("Please use 1, 2, or 4 quadrature functions.")
class CircleArtist(Artist): center = Array() radius = Float(1.) def __init__(self, **kwargs): self._mark = Lines(scales={ 'x': LinearScale(), 'y': LinearScale() }, colors=['red']) super().__init__(**kwargs) self.update_mark() @default('center') def _default_center(self): return np.zeros((2, )) def update_mark(self): x = self.center[0] + np.cos(np.linspace(0, 2 * np.pi, 100)) * self.radius y = self.center[1] + np.sin(np.linspace(0, 2 * np.pi, 100)) * self.radius with self._mark.hold_sync(): self._mark.x = x self._mark.y = y @observe('center', 'radius') def _observe_center_and_radius(self, change): self.update_mark() def _add_to_canvas(self, canvas): self._mark.scales = { 'x': canvas.figure.axes[0].scale, 'y': canvas.figure.axes[1].scale } canvas.figure.marks = [self._mark] + canvas.figure.marks @property def limits(self): return [(self.center[0] - self.radius, self.center[0] + self.radius), (self.center[1] - self.radius, self.center[1] + self.radius)]
def __init__(self, model, key): param = model.params[key] if type(param.value) == np.ndarray and key != 'T13': self.n = len(param.value) else: self.n = 1 os = LinearScale() ls = LinearScale() ax_x = Axis(scale=os, grid_lines='solid', label='Iterations') ax_y = Axis(scale=ls, orientation='vertical', tick_format='0.2f', grid_lines='solid', label=key) colors = [ '#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf' ] self.lines = [] for k in range(self.n): self.lines.append( Lines(x=np.array([]), y=np.array([]), scales={ 'x': os, 'y': ls }, colors=[colors[k]], stroke_width=2, display_legend=True, labels=['{}_{}'.format(key, k)])) super().__init__(marks=self.lines, axes=[ax_x, ax_y], title=key, legend_location='bottom-right')
def gradient_descent(): line_params = {"b": 0, "m": 0, "iter": 1} sc_x = LinearScale(min=-100, max=100) sc_y = LinearScale(min=-100, max=100) scat = Scatter(x=[], y=[], scales={ "x": sc_x, "y": sc_y }, colors=["orange"], enable_move=True) lin = Lines(x=[], y=[], scales={"x": sc_x, "y": sc_y}, colors=["blue"]) ax_x = Axis(scale=sc_x, tick_format="0.0f", label="x") ax_y = Axis(scale=sc_y, tick_format="0.0f", orientation="vertical", label="y") fig_function = Figure(marks=[scat, lin], axes=[ax_x, ax_y]) sc_x_cost = LinearScale(min=0, max=100) sc_y_cost = LinearScale(min=0, max=100) lin_cost = Lines(x=[], y=[], scales={"x": sc_x_cost, "y": sc_y_cost}) ax_x_cost = Axis(scale=sc_x_cost, tick_format="0.0f", label="iteration") ax_y_cost = Axis( scale=sc_y_cost, tick_format="0.0f", orientation="vertical", label="Mean Squared Error", ) fig_cost = Figure(marks=[lin_cost], axes=[ax_x_cost, ax_y_cost]) def draw_line(): x = np.linspace(-100, 100) y = line_params["b"] + line_params["m"] * x with lin.hold_sync(): lin.x = x lin.y = y play_button = widgets.Play( interval=100, value=0, min=0, max=100, step=1, repeat=True, description="Run gradient descent", disabled=False, ) year_slider = widgets.IntSlider(min=0, max=100, step=1, description="Step", value=0, disabled=True) def mse(): b = line_params["b"] m = line_params["m"] return (((scat.x * m + b) - scat.y)**2).mean() def play_change(change): b = line_params["b"] m = line_params["m"] b_gradient = 0 m_gradient = 0 n = len(scat.x) learning_rate = 0.0001 for i in range(0, len(scat.x)): b_gradient += -(2 / n) * (scat.y[i] - ((m * scat.x[i]) + b)) m_gradient += -(2 / n) * scat.x[i] * (scat.y[i] - ((m * scat.x[i]) + m)) b = b - (learning_rate * 500 * b_gradient) m = m - (learning_rate * m_gradient) line_params["b"] = b line_params["m"] = m lin_cost.x = np.append(np.array(lin_cost.x), np.array([line_params["iter"]])) lin_cost.y = np.append(np.array(lin_cost.y), mse()) sc_x_cost.min = np.min(lin_cost.x) sc_x_cost.max = np.max(lin_cost.x) sc_y_cost.min = 0 sc_y_cost.max = np.max(lin_cost.y) line_params["iter"] = line_params["iter"] + 1 draw_line() play_button.observe(play_change, "value") widgets.jslink((play_button, "value"), (year_slider, "value")) # reset reset_button reset_button = widgets.Button(description="Reset") def on_button_clicked(change=None): x, y = fake_datasets("Linear") with scat.hold_sync(): scat.x = x.flatten() scat.y = y.flatten() with lin_cost.hold_sync(): lin_cost.x = [] lin_cost.y = [] line_params["b"] = (np.random.random() - 0.5) * 100 line_params["m"] = np.random.random() - 0.5 line_params["iter"] = 1 draw_line() on_button_clicked() reset_button.on_click(on_button_clicked) return VBox(( widgets.HTML("<h1>Gradient Descent</h1>"), reset_button, HBox((Label("Run gradient descent"), play_button, year_slider)), HBox((fig_function, fig_cost)), ))
def cost_display(n_days=7): users = widgets.IntText(value=8, description='Number of total users') storage_per_user = widgets.IntText(value=10, description='Storage per user (GB)') mem_per_user = widgets.IntText(value=2, description="RAM per user (GB)") machines = widgets.Dropdown( description='Machine', options=machines_list['Machine type'].values.tolist()) persistent = widgets.Dropdown(description="Persistent Storage?", options={ 'HDD': 'hdd', 'SSD': 'ssd' }, value='hdd') autoscaling = widgets.Checkbox(value=False, description='Autoscaling?') text_avg_num_machine = widgets.Text(value='', description='Average # Machines:') text_cost_machine = widgets.Text(value='', description='Machine Cost:') text_cost_storage = widgets.Text(value='', description='Storage Cost:') text_cost_total = widgets.Text(value='', description='Total Cost:') hr = widgets.HTML(value="---") # Define axes limits y_max = 100. date_stop, date_range = create_date_range(n_days) # Create axes and extra variables for the viz xs_hd = DateScale( min=date_start, max=date_stop, ) ys_hd = LinearScale(min=0., max=y_max) # Shading for weekends is_weekend = np.where([ii in [6, 7] for ii in date_range.dayofweek], 1, 0) is_weekend = is_weekend * (float(y_max) + 50.) is_weekend[is_weekend == 0] = -10 line_fill = Lines(x=date_range, y=is_weekend, scales={ 'x': xs_hd, 'y': ys_hd }, colors=['black'], fill_opacities=[.2], fill='bottom') # Set up hand draw widget line_hd = Lines(x=date_range, y=10 * np.ones(len(date_range)), scales={ 'x': xs_hd, 'y': ys_hd }, colors=['#E46E2E']) line_users = Lines(x=date_range, y=10 * np.ones(len(date_range)), scales={ 'x': xs_hd, 'y': ys_hd }, colors=['#e5e5e5']) line_autoscale = Lines(x=date_range, y=10 * np.ones(len(date_range)), scales={ 'x': xs_hd, 'y': ys_hd }, colors=['#000000']) handdraw = HandDraw(lines=line_hd) xax = Axis(scale=xs_hd, label='Day', grid_lines='none', tick_format='%b %d') yax = Axis(scale=ys_hd, label='Numer of Users', orientation='vertical', grid_lines='none') # FIXME add `line_autoscale` when autoscale is enabled fig = Figure(marks=[line_fill, line_hd, line_users], axes=[xax, yax], interaction=handdraw) def _update_cost(change): # Pull values from the plot max_users = max(handdraw.lines.y) max_buffer = max_users * 1.05 # 5% buffer line_users.y = [max_buffer] * len(handdraw.lines.y) if max_users > users.value: users.value = max_users autoscaled_users = autoscale(handdraw.lines.y) line_autoscale.y = autoscaled_users # Calculate costs active_machine = machines_list[machines_list['Machine type'] == machines.value] machine_cost = active_machine['Price (USD / hr)'].values.astype( float) * 24 # To make it cost per day users_for_cost = autoscaled_users if autoscaling.value is True else [ max_buffer ] * len(handdraw.lines.y) num_machines = calculate_machines_needed(users_for_cost, mem_per_user.value, active_machine) avg_num_machines = np.mean(num_machines) cost_machine = integrate_cost(num_machines, machine_cost) cost_storage = integrate_cost( num_machines, storage_cost[persistent.value] * storage_per_user.value) cost_total = cost_machine + cost_storage # Set the values for iwidget, icost in [(text_cost_machine, cost_machine), (text_cost_storage, cost_storage), (text_cost_total, cost_total), (text_avg_num_machine, avg_num_machines)]: if iwidget is not text_avg_num_machine: icost = locale.currency(icost, grouping=True) else: icost = '{:.2f}'.format(icost) iwidget.value = icost # Set the color if autoscaling.value is True: line_autoscale.colors = ['#000000'] line_users.colors = ['#e5e5e5'] else: line_autoscale.colors = ['#e5e5e5'] line_users.colors = ['#000000'] line_hd.observe(_update_cost, names='y') # autoscaling.observe(_update_cost) # FIXME Uncomment when we implement autoscaling persistent.observe(_update_cost) machines.observe(_update_cost) storage_per_user.observe(_update_cost) mem_per_user.observe(_update_cost) # Show it fig.title = 'Draw your usage pattern over time.' # FIXME autoscaling when it's ready display(users, machines, mem_per_user, storage_per_user, persistent, fig, hr, text_cost_machine, text_avg_num_machine, text_cost_storage, text_cost_total) return fig
def simple_optimazation_app(): population_cnt = 20 itter_time = 50 crossover_rate = 0.1 drop_rate = 0.5 mutation_rate = 0.1 i = 0 best_score = 0 best_ind = [] best_ind_ready = [] population = [] ''' dynamic figure ''' X = np.linspace(0, 1, 1000) y = np.array([target_function(x) for x in X]) x_sc = LinearScale() y_sc = LinearScale() ref = Lines(x=X, y=y, scales={'x': x_sc, 'y': y_sc}) # scatter = Scatter(x=[population], y=np.array([target_function(ind) for ind in population]), # scales={'x': x_sc, 'y': y_sc}, # colors=['DarkOrange'], stroke='red', # stroke_width=0.4, default_size=20) scatter = Scatter(x=[], y=[], scales={ 'x': x_sc, 'y': y_sc }, colors=['DarkOrange'], stroke='red', stroke_width=0.4, default_size=20) x_ax = Axis(label='X', scale=x_sc) y_ax = Axis(label='Y', scale=y_sc, orientation='vertical') x_ax.min = 0 x_ax.max = 1 x_ax.num_ticks = 7 x_ax.grid_color = 'orangered' fig = Figure(marks=[ref, scatter], title='A Figure', axes=[x_ax, y_ax], animation_duration=1000) # display(fig) # %% run_itter_slider = population_slider = widgets.IntSlider( value=50, description='#Iteration', min=1, max=100, step=1) run_btn = widgets.Button(description='Run', icon='play', disabled=True) population_cnt_slider = widgets.IntSlider(value=30, description='#Population', min=0, max=100, step=10) init_population_btn = widgets.Button(description='Initialize Population') descriptor1 = widgets.Label('crossover_rate') crossover_rate_slider = widgets.FloatSlider(value=0.1, description='', min=0, max=1.0, step=0.1) descriptor2 = widgets.Label('drop_rate') drop_rate_slider = widgets.FloatSlider(value=0.5, description='', min=0, max=1.0, step=0.1) descriptor3 = widgets.Label('mutation_rate') mutation_rate_slider = widgets.FloatSlider(value=0.3, description='', min=0, max=1.0, step=0.1) patch1 = widgets.HBox([descriptor1, crossover_rate_slider]) patch2 = widgets.HBox([descriptor2, drop_rate_slider]) patch3 = widgets.HBox([descriptor3, mutation_rate_slider]) blank = widgets.Label('') run_out = widgets.Output(layout={ 'border': '1px solid black', 'height': '50px' }) row1 = widgets.VBox([population_cnt_slider, init_population_btn]) row2 = widgets.HBox([patch1, patch2, patch3]) row_n = widgets.VBox([run_itter_slider, run_btn]) app = widgets.VBox([row1, blank, row2, blank, row_n, run_out, fig]) # %% def initialize(): nonlocal population, i population = np.random.rand(population_cnt_slider.value) scatter.x = population scatter.y = get_scores(scatter.x) i = 0 fig.title = f'迭代{i}次\n' @run_out.capture() def update(itter_time=itter_time, crossover_rate=crossover_rate, drop_rate=drop_rate, mutation_rate=mutation_rate): nonlocal scatter, fig, best_score, best_ind_ready, best_ind, i for j in range(itter_time): new_population = select_and_crossover( population, crossover_rate=crossover_rate, drop_rate=drop_rate) new_population_ready = encode_all(new_population) new_population_ready = mutatie_all(new_population_ready, mutation_rate=mutation_rate) new_population = decode_all(new_population_ready) ind, score = get_best(new_population) if score > best_score: best_ind = ind best_score = score best_ind_ready = encode(best_ind) i += 1 scatter.x = new_population scatter.y = get_scores(new_population) fig.title = f'迭代{i}次' # + f'最优个体为: {best_ind_ready}; 函数值为:{best_score}' clear_output(wait=True) display(f'最优个体为: {best_ind_ready}; 函数值为:{best_score}') # %% # update() # %% def on_click_init(change): initialize() run_btn.disabled = False def on_click_run(change): update(itter_time=run_itter_slider.value, crossover_rate=crossover_rate_slider.value, drop_rate=drop_rate_slider.value, mutation_rate=mutation_rate_slider.value) init_population_btn.on_click(on_click_init) run_btn.on_click(on_click_run) return app
def plot_pulse_files(metafile, time=True, backend='bqplot'): ''' plot_pulse_files(metafile) Helper function to plot a list of AWG files. A jupyter slider widget allows choice of sequence number. ''' #If we only go one filename turn it into a list with open(metafile, 'r') as FID: meta_info = json.load(FID) fileNames = [] for el in meta_info["instruments"].values(): # Accomodate seq_file per instrument and per channel if isinstance(el, str): fileNames.append(el) elif isinstance(el, dict): for file in el.values(): fileNames.append(file) line_names, num_seqs, data_dicts = extract_waveforms(fileNames, time=time) localname = os.path.split(fileNames[0])[1] sequencename = localname.split('-')[0] if backend == 'matplotlib': import matplotlib.pyplot as plt from ipywidgets import interact, IntSlider def update_plot(seq_ind): for line_name in line_names: dat = data_dicts[f"{line_name}_{seq_ind}"] plt.plot(dat['x'], dat['y'], label=line_name, linewidth=1.0) interact(update_plot, seq_ind=IntSlider(min=1, max=num_seqs, step=1, value=1, description="Sequence Number")) elif backend == 'bqplot': from bqplot import DateScale, LinearScale, Axis, Lines, Figure, Tooltip from bqplot.colorschemes import CATEGORY10, CATEGORY20 from ipywidgets import interact, IntSlider, VBox sx = LinearScale() sy = LinearScale(min=-1.0, max=2 * len(line_names) - 1.0) if time: ax = Axis(label='Time (ns)', scale=sx) else: ax = Axis(label="Samples", scale=sx) ay = Axis(label='Amplitude', scale=sy, orientation='vertical') colors = CATEGORY10 if len(line_names) < 10 else CATEGORY20 lines = [] tt = Tooltip(fields=['name'], labels=['Channel']) x_mult = 1.0e9 if time else 1 for i, line_name in enumerate(line_names): dat = data_dicts[f"{line_name}_1"] lines.append( Lines(labels=[line_name], x=x_mult * dat['x'], y=dat['y'], scales={ 'x': sx, 'y': sy }, tooltip=tt, animate=False, colors=[colors[i]])) slider = IntSlider(min=1, max=num_seqs, step=1, description='Segment', value=1) def segment_changed(change): for line, line_name in zip(lines, line_names): dat = data_dicts[f"{line_name}_{slider.value}"] line.x = x_mult * dat['x'] line.y = dat['y'] slider.observe(segment_changed, 'value') fig = Figure(marks=lines, axes=[ax, ay], title='Waveform Plotter', animation_duration=50) return VBox([slider, fig])
'x': x_sc, 'y': y_sc, 'color': c_sc, 'size': size_sc }, default_size=4112, tooltip=tt, animate=True, stroke='Black', unhovered_style={'opacity': 0.5}) # %% {"collapsed": true} nation_line = Lines(x=data['income'][0], y=data['lifeExpectancy'][0], colors=['Gray'], scales={ 'x': x_sc, 'y': y_sc }, visible=False) # %% [markdown] # #### Creating the Figure # %% {"collapsed": true} time_interval = 10 # %% {"collapsed": true} fig = Figure(marks=[wealth_scat, year_label, nation_line], axes=[ax_x, ax_y], title='Health and Wealth of Nations', animation_duration=time_interval)
file_box.layout.align_itmes = 'stretch' control_box1 = VBox([HBox(m),HBox(params_box+[sound_chk, sound_btn]), HBox([add_btn, art_slt, delete_btn, replace_btn, play_all_btn])]) fig_margin_default = {'top':40, 'bottom':40, 'left':40, 'right':40} min_height_default = 10 min_width_default = 10 # Create Sound Wave plot container x_time = LinearScale(min=0., max=100) y_sound = LinearScale(min=-.5, max=.5) ax_sound_y = Axis(label='Amplitude', scale=y_sound, orientation='vertical', side='left', grid_lines='solid') ax_time_x = Axis(label='Time', scale=x_time, grid_lines='solid') #Initialization sound_line = Lines(x=[], y=[], colors=['Blue'], scales={'x': x_time, 'y': y_sound}, visible=True) fig_sound = plt.figure(marks=[sound_line], axes=[ax_time_x, ax_sound_y], title='Sound wave', fig_margin = fig_margin_default, min_height = min_height_default, min_widht = min_width_default, preserve_aspect=True) # Create Articulator Position Evolution Container y_art = LinearScale(min=-3., max=3.) ax_art_y = Axis(label='Position', scale=y_art, orientation='vertical', side='left', grid_lines='solid') # ax_time_x = Axis(label='Time', scale=x_time, grid_lines='solid') #Initialization art_lines = Lines(x=[], y=[], #colors=['Blue'], scales={'x': x_time, 'y': y_art}, visible=True) fig_art = plt.figure(marks=[art_lines], axes=[ax_time_x, ax_art_y], title='Articulators', fig_margin = fig_margin_default, min_height = min_height_default, min_widht = min_width_default) # Create Formants Evolution Container
def polynomial_regression(): """Polynomial regression example""" regression_config = {"degree": 1} sc_x = LinearScale(min=-100, max=100) sc_y = LinearScale(min=-100, max=100) scat = Scatter( x=[], y=[], scales={"x": sc_x, "y": sc_y}, colors=["orange"], enable_move=True ) lin = Lines( x=[], y=[], scales={"x": sc_x, "y": sc_y}, line_style="dotted", colors=["blue"] ) def update_line(change=None): if len(scat.x) == 0 or len(scat.y) == 0 or scat.x.shape != scat.y.shape: lin.x = [] lin.y = [] return pipe = make_pipeline( PolynomialFeatures(degree=regression_config["degree"]), LinearRegression() ) pipe.fit(scat.x.reshape(-1, 1), scat.y) with lin.hold_sync(): if len(lin.x) == 0: lin.x = np.linspace(sc_x.min, sc_x.max) lin.y = pipe.predict(np.linspace(sc_x.min, sc_x.max).reshape(-1, 1)) update_line() # update line on change of x or y of scatter scat.observe(update_line, names=["x", "y"]) with scat.hold_sync(): scat.enable_move = False scat.interactions = {"click": "add"} ax_x = Axis(scale=sc_x, tick_format="0.0f", label="x") ax_y = Axis(scale=sc_y, tick_format="0.0f", orientation="vertical", label="y") fig = Figure(marks=[scat, lin], axes=[ax_x, ax_y]) # reset reset_button reset_button = widgets.Button(description="Reset") def on_button_clicked(change=None): with scat.hold_sync(): scat.x = [] scat.y = [] dropdown_w.value = None reset_button.on_click(on_button_clicked) # polynomial degree slider degree = widgets.IntSlider( value=regression_config["degree"], min=1, max=5, step=1, description="Degree" ) def degree_change(change): regression_config["degree"] = change["new"] update_line() degree.observe(degree_change, names="value") # dropdown for dataset selection dropdown_w = widgets.Dropdown( options=fake_datasets(ndim=2), value=None, description="Dataset:" ) def dropdown_on_change(change): if change["type"] == "change" and change["name"] == "value": if change["new"] is not None: x, y = fake_datasets(name=change["new"]) with scat.hold_sync(): scat.x = x.flatten() scat.y = y.flatten() dropdown_w.observe(dropdown_on_change) return VBox( ( widgets.HTML("<h1>Polynomial regression</h1>"), reset_button, dropdown_w, degree, fig, ) )
def init_dashboard(self): from bqplot import DateScale, LinearScale, DateScale, Axis, Lines, Figure, Tooltip from bqplot.colorschemes import CATEGORY10, CATEGORY20 from bqplot.toolbar import Toolbar from ipywidgets import VBox, Tab from IPython.display import display from tornado import gen cpu_sx = LinearScale() cpu_sy = LinearScale() cpu_x = Axis(label='Time (s)', scale=cpu_sx) cpu_y = Axis(label='CPU Usage (%)', scale=cpu_sy, orientation='vertical') mem_sx = LinearScale() mem_sy = LinearScale() mem_x = Axis(label='Time (s)', scale=mem_sx) mem_y = Axis(label='Memory Usage (MB)', scale=mem_sy, orientation='vertical') thru_sx = LinearScale() thru_sy = LinearScale() thru_x = Axis(label='Time (s)', scale=thru_sx) thru_y = Axis(label='Data Processed (MB)', scale=thru_sy, orientation='vertical') colors = CATEGORY20 tt = Tooltip(fields=['name'], labels=['Filter Name']) self.cpu_lines = { str(n): Lines(labels=[str(n)], x=[0.0], y=[0.0], colors=[colors[i]], tooltip=tt, scales={ 'x': cpu_sx, 'y': cpu_sy }) for i, n in enumerate(self.other_nodes) } self.mem_lines = { str(n): Lines(labels=[str(n)], x=[0.0], y=[0.0], colors=[colors[i]], tooltip=tt, scales={ 'x': mem_sx, 'y': mem_sy }) for i, n in enumerate(self.other_nodes) } self.thru_lines = { str(n): Lines(labels=[str(n)], x=[0.0], y=[0.0], colors=[colors[i]], tooltip=tt, scales={ 'x': thru_sx, 'y': thru_sy }) for i, n in enumerate(self.other_nodes) } self.cpu_fig = Figure(marks=list(self.cpu_lines.values()), axes=[cpu_x, cpu_y], title='CPU Usage', animation_duration=50) self.mem_fig = Figure(marks=list(self.mem_lines.values()), axes=[mem_x, mem_y], title='Memory Usage', animation_duration=50) self.thru_fig = Figure(marks=list(self.thru_lines.values()), axes=[thru_x, thru_y], title='Data Processed', animation_duration=50) tab = Tab() tab.children = [self.cpu_fig, self.mem_fig, self.thru_fig] tab.set_title(0, 'CPU') tab.set_title(1, 'Memory') tab.set_title(2, 'Throughput') display(tab) perf_queue = Queue() self.exit_perf = Event() def wait_for_perf_updates(q, exit, cpu_lines, mem_lines, thru_lines): while not exit.is_set(): messages = [] while not exit.is_set(): try: messages.append(q.get(False)) except queue.Empty as e: time.sleep(0.05) break for message in messages: filter_name, time_val, cpu, mem_info, processed = message mem = mem_info[0] / 2.**20 vmem = mem_info[1] / 2.**20 proc = processed / 2.**20 cpu_lines[filter_name].x = np.append( cpu_lines[filter_name].x, [time_val.total_seconds()]) cpu_lines[filter_name].y = np.append( cpu_lines[filter_name].y, [cpu]) mem_lines[filter_name].x = np.append( mem_lines[filter_name].x, [time_val.total_seconds()]) mem_lines[filter_name].y = np.append( mem_lines[filter_name].y, [mem]) thru_lines[filter_name].x = np.append( thru_lines[filter_name].x, [time_val.total_seconds()]) thru_lines[filter_name].y = np.append( thru_lines[filter_name].y, [proc]) for n in self.other_nodes: n.perf_queue = perf_queue self.perf_thread = Thread(target=wait_for_perf_updates, args=(perf_queue, self.exit_perf, self.cpu_lines, self.mem_lines, self.thru_lines)) self.perf_thread.start()
def create_fig(self, ts): if self.ptype != 'PCA' and self.dims == None: ts.sort_index(inplace=True) df = ts.reset_index() # time = ts.Time else: df = ts self.xd = df[self.xlabel] self.yd = df[self.cols].T if self.ptype == 'PCA' or self.dims is not None: pplt = Scatter(x=self.xd.values.ravel(), y=self.yd.values.ravel(), scales={'x': self.xScale, \ 'y': self.yScale, 'color': ColorScale(scheme=self.scheme)}, selected_style={'opacity': '1'}, \ unselected_style={'opacity': '0.2'},color = self.colors, default_size=32) elif not self.ptype: pplt = Lines(x=self.xd, y=self.yd, scales={'x': self.xScale, 'y': self.yScale}, labels=self.legends, display_legend=True, line_style=self.linestyle, stroke_width = 1, marker = 'circle', \ interpolation = self.interp) # {‘linear’, ‘basis’, ‘cardinal’, ‘monotone’} else: pplt = Lines(x=self.xd, y=self.yd, scales={'x': self.xScale, 'y': self.yScale}, labels=self.legends, \ display_legend=True, line_style=self.linestyle, selected_style={'opacity': '1'}, \ unselected_style={'opacity': '0.2'},interpolation=self.interp) # enable_hover=True) # axes_options=axes_options) x_axis = Axis(scale=self.xScale, label=self.xlabel, grid_lines='none') y_axis = Axis(scale=self.yScale, label=self.ylabel, orientation='vertical', grid_lines='none') c_axis = ColorAxis(scale=ColorScale(scheme=self.scheme), orientation='vertical', side='right') axis = [x_axis, y_axis, c_axis] if isinstance( pplt, Scatter) else [x_axis, y_axis] if self.debug: margin = dict(top=0, bottom=40, left=50, right=50) else: margin = dict(top=0, bottom=50, left=50, right=50) self.fig = Figure(marks=[pplt], axes=axis, legend_location='top-right', fig_margin=margin) # {'top':50,'left':60}) if self.debug: self.deb = HTML() y = getattr(self, "vbox", None) if y is not None: box_layout = Layout(display='flex', flex_flow='column', align_items='stretch') if self.debug: self.vbox = VBox( [self.selection_interacts, self.fig, self.deb], layout=box_layout) else: self.vbox = VBox([self.selection_interacts, self.fig], layout=box_layout)
def __init__(self): #the model restricts changing step size self.steps = 1 / 52 # Line chart and histo self.x_sc = LinearScale() self.y_sc = LinearScale() self.x_sc_2 = LinearScale() self.y_sc_2 = LinearScale() self.ax_x = Axis(label='Weeks', scale=self.x_sc, grid_lines='dashed') self.ax_y = Axis(label='Rate', scale=self.y_sc, orientation='vertical', grid_lines='dashed') self.ax_x_2 = Axis(label='Rate', scale=self.x_sc_2, grid_lines='none') self.ax_y_2 = Axis(label='Count', scale=self.y_sc_2, orientation='vertical', grid_lines='dashed') #HW1F Charts self.line1 = Lines(x=[], y=[[], []], scales={ 'x': self.x_sc, 'y': self.y_sc }, stroke_width=3, colors=['red', 'green']) self.line2 = Lines(x=[], y=[[]], scales={ 'x': self.x_sc, 'y': self.y_sc }, labels=['MC']) self.hist1 = Hist(sample=[], scales={ 'sample': self.x_sc_2, 'count': self.y_sc_2 }, bins=0) self.fig1 = Figure(axes=[self.ax_x, self.ax_y], marks=[self.line1, self.line2], title='Hull White 1 Factor Dynamics') self.fig2 = Figure(axes=[self.ax_x_2, self.ax_y_2], marks=[self.hist1], title='Final Distribution of Rates') #HW2F Charts self.line3 = Lines(x=[], y=[[], []], scales={ 'x': self.x_sc, 'y': self.y_sc }, stroke_width=3, colors=['red', 'green']) self.line4 = Lines(x=[], y=[[]], scales={ 'x': self.x_sc, 'y': self.y_sc }) self.hist2 = Hist(sample=[], scales={ 'sample': self.x_sc_2, 'count': self.y_sc_2 }, bins=0) self.fig3 = Figure(axes=[self.ax_x, self.ax_y], marks=[self.line3, self.line4], title='Hull White 2 Factor Dynamics') self.fig4 = Figure(axes=[self.ax_x_2, self.ax_y_2], marks=[self.hist2], title='Final Distribution of Rates') # Input widgets self.ZC1W = ipw.FloatText(description='1W', value=2.07, layout=ipw.Layout(width='17%', height='100%')) self.ZC3M = ipw.FloatText(description='3M', value=2.29, layout=ipw.Layout(width='17%', height='100%')) self.ZC6M = ipw.FloatText(description='6M', value=2.45, layout=ipw.Layout(width='17%', height='100%')) self.ZC1Y = ipw.FloatText(description='1Y', value=2.7, layout=ipw.Layout(width='17%', height='100%')) self.ZC2Y = ipw.FloatText(description='2Y', value=3.02, layout=ipw.Layout(width='17%', height='100%')) self.ZC6Y = ipw.FloatText(description='6Y', value=4, layout=ipw.Layout(width='17%', height='100%')) self.ZC10Y = ipw.FloatText(description='10Y', value=4.7, layout=ipw.Layout(width='17%', height='100%')) self.normalVol = ipw.FloatSlider(value=100, min=0, max=1000, description='Normal Vol (bps)') self.normalVol2 = ipw.FloatSlider(value=100, min=0, max=1000, description='Normal Vol 2 (bps)') self.meanRev = ipw.FloatSlider(value=1, min=0.0001, max=10, steps=0.01, description='Mean Reversion') self.meanRev2 = ipw.FloatSlider(value=3, min=0.0001, max=10, steps=0.01, description='Mean Reversion 2') self.numPaths = ipw.IntSlider(value=50, min=1, max=500, step=1, description='Paths ') self.showPaths = ipw.IntSlider(value=5, min=0, max=100, step=1, description='Display Paths ') self.correlation = ipw.FloatSlider(value=.1, min=-1, max=1, steps=0.01, description='Correlation') # Layout with tabs self.tab = ipw.Tab() self.tab_contents = [0, 1] self.children = [ ipw.VBox([ ipw.HBox([ self.normalVol, self.meanRev, self.numPaths, self.showPaths ]), ipw.HBox([self.fig1, self.fig2]) ]), ipw.VBox([ ipw.HBox([ self.normalVol, self.normalVol2, self.meanRev, self.meanRev2 ]), ipw.HBox([self.correlation, self.numPaths, self.showPaths]), ipw.HBox([self.fig3, self.fig4]) ]) ] self.tab.children = self.children self.tab.set_title(0, 'HW1F') self.tab.set_title(1, 'HW2F') #Observers self.ZC1W.observe(self.process_wrapper, 'value') self.ZC3M.observe(self.process_wrapper, 'value') self.ZC6M.observe(self.process_wrapper, 'value') self.ZC1Y.observe(self.process_wrapper, 'value') self.ZC2Y.observe(self.process_wrapper, 'value') self.ZC6Y.observe(self.process_wrapper, 'value') self.ZC10Y.observe(self.process_wrapper, 'value') self.meanRev.observe(self.process_wrapper, 'value') self.meanRev2.observe(self.process_wrapper, 'value') self.normalVol.observe(self.process_wrapper, 'value') self.normalVol2.observe(self.process_wrapper, 'value') self.numPaths.observe(self.process_wrapper, 'value') self.showPaths.observe(self.process_wrapper, 'value') self.correlation.observe(self.process_wrapper, 'value') self.paths = self.numPaths.value self.form = ipw.VBox([ ipw.HBox([ self.ZC1W, self.ZC3M, self.ZC6M, self.ZC1Y, self.ZC2Y, self.ZC6Y, self.ZC10Y ], layout={'width': '80%'}), self.tab ]) display(self.form)
# %% import numpy as np import matplotlib.pyplot as plt from bqplot import pyplot as bqplt from bqplot import LinearScale, Scatter, Axis, Figure, Lines def target_function(x): return np.exp(-(x-0.1) ** 2) * np.sin(6 * np.pi * x ** (3 / 4)) ** 2 X = np.linspace(0, 1, 1000) y = np.array([target_function(x) for x in X]) population = np.random.rand(30) x_sc = LinearScale() y_sc = LinearScale() ref = Lines(x=X, y=y, scales={'x': x_sc, 'y': y_sc}) scatter = Scatter(x=population, y=np.array([target_function(ind) for ind in population]), scales={'x': x_sc, 'y': y_sc}, colors=['DarkOrange'], stroke='red', stroke_width=0.4, default_size=20) x_ax = Axis(label='X', scale=x_sc) y_ax = Axis(label='Y', scale=y_sc, orientation='vertical') x_ax.min = 0 x_ax.max = 1 x_ax.num_ticks = 7 x_ax.grid_color = 'orangered' fig = Figure(marks=[ref, scatter], title='A Figure', axes=[x_ax, y_ax], animation_duration=1000)
def create_fig(self, ts): ts.sort_index(inplace=True) df = ts.reset_index() # time = ts.Time self.xd = df[self.xlabel] self.yd = df[self.cols].T if self.ptype == 'PCA': pplt = Scatter(x=self.xd, y=self.yd, scales={ 'x': self.xScale, 'y': self.yScale }, color=self.colors) #labels=self.legends, #display_legend=True, line_style='solid', stroke_width = 0, marker = 'circle') elif not self.ptype: pplt = Lines(x=self.xd, y=self.yd, scales={ 'x': self.xScale, 'y': self.yScale }, labels=self.legends, display_legend=True, line_style='solid', stroke_width=0, marker='circle') else: pplt = Lines(x=self.xd, y=self.yd, scales={ 'x': self.xScale, 'y': self.yScale }, labels=self.legends, display_legend=True, line_style='solid', selected_style={'opacity': '1'}, unselected_style={ 'opacity': '0.2' }) # enable_hover=True) # axes_options=axes_options) x_axis = Axis(scale=self.xScale, label=self.xlabel, grid_lines='none') y_axis = Axis(scale=self.yScale, label=self.ylabel, orientation='vertical', grid_lines='none') if self.debug: margin = dict(top=0, bottom=40, left=50, right=50) else: margin = dict(top=0, bottom=50, left=50, right=50) self.fig = Figure(marks=[pplt], axes=[x_axis, y_axis], legend_location='top-right', fig_margin=margin) # {'top':50,'left':60}) if self.debug: self.deb = HTML() # self.deb2 = HTML() y = getattr(self, "vbox", None) if y is not None: box_layout = Layout(display='flex', flex_flow='column', align_items='stretch') if self.debug: self.vbox = VBox( [self.selection_interacts, self.fig, self.deb], layout=box_layout) else: self.vbox = VBox([self.selection_interacts, self.fig], layout=box_layout)