def __init__(self): subprocess.call("nrnivmodl") warnings.filterwarnings('ignore') self.RB = widgets.RadioButtons(options=[]) self.RB1 = widgets.RadioButtons(description='Select mod file', options=['default', 'local'], style={'description_width': 'initial'}) self.RB1.disabled = True self.RBHPC = widgets.RadioButtons( description='Run on:', options=['NSG', 'Service Account - NSG']) self.RBHPC.disabled = True self.RBM = widgets.RadioButtons( options=['all_traces', 'singletrace', 'demo'], description='run') self.RBM.disabled = True self.file_widget = widgets.FileUpload() self.KEY = 'Application_Fitting-DA5A3D2F8B9B4A5D964D4D2285A49C57' self.TOOL = 'NEURON77_TG' self.create_folder("GUI") os.chdir("GUI") self.prepare_transfer_folder() self.create_cell_selection() self.create_mod_radio() self.create_submission_panel()
def _stack(self, network: str, node: str): """ Display stack graphics. Manage user interaction with scn slider and prod, cons choices. :param network: network name :param node: node name :return: """ def changes(scn, prod, cons): display( go.FigureWidget( self.plotting.network(network).node(node).stack( scn=scn, prod_kind=prod, cons_kind=cons))) scn = widgets.IntSlider(value=0, min=0, description='scn', max=self.plotting.agg.nb_scn - 1, continuous_update=False, disabled=False) cons = widgets.RadioButtons(options=['asked', 'given'], value='asked', description='Consumption') prod = widgets.RadioButtons(options=['avail', 'used'], value='used', description='Production') hbox = widgets.HBox([scn, cons, prod]) inter = interactive_output(changes, { 'scn': scn, 'prod': prod, 'cons': cons }) return widgets.VBox([hbox, inter])
def __init__(self, path=tumblrsPath): self.path = path self.AC = AccountCollection(path) self.A = self.AC[random.randint(0, len(self.AC))] self.accountSelector = widgets.Dropdown( options=self.AC.names, value=self.A.name, description='Account:', ) self.tagsSelector = widgets.Dropdown( options=[f'{len(self.A)} None'] + self.A.sortedTags(count=True), value=f'{len(self.A)} None', description='tags:', ) self.typesSelector = widgets.RadioButtons( options=self.A.postTypes, value=self.A.currentType, description='Post type:', ) self.postSlider = widgets.IntSlider(min=0, max=len(self.A) - 1, value=0, description=str(len(self.A)) + ' posts') self.mainCaption = widgets.HTML(value=self.A(0)) self.nextButton = widgets.Button(description="Next") self.previousButton = widgets.Button(description="Previous") self.tagSearchEnable = widgets.Button(description="Enable tag search") self.globalTagSelector = widgets.RadioButtons( options=['None'], value='None', description='Global tag filter:', disabled=True, display=False, ) self.controls = HBox([ VBox([ HBox([self.accountSelector, self.tagsSelector]), HBox([self.postSlider, self.previousButton, self.nextButton]) ]), self.typesSelector ])
def plot_timeseries(datamart, rows_df=None, plot_fcst=False, use_log_values=False): """Plot meter readings vs time interactively.""" if use_log_values: fact_column = 'fact_log' leak_column = 'leak_log' target_column = 'target_log' fcst_column = 'fcst_log' else: fact_column = 'fact' leak_column = 'leak' target_column = 'target' fcst_column = 'fcst' if plot_fcst: cols = [target_column, fcst_column] else: cols = [leak_column, fact_column, target_column] df_to_plot = datamart.loc[:, ['meter', 'building_id', 'timestamp'] + cols] if rows_df is None: rows_df = datamart[['meter', 'building_id', 'site_id']].drop_duplicates() else: rows_df = rows_df.reset_index()[['meter', 'building_id', 'site_id']] df_to_plot = df_to_plot.merge(rows_df, on=['meter', 'building_id']) df_to_plot.set_index('timestamp', inplace=True) meter_widget = widgets.RadioButtons( options=[('Electricity (0)', 0), ('Chilled water (1)', 1), ('Steam (2)', 2), ('Hot water (3)', 3)]) building_id_widget = widgets.Select() def update_buildings_list(*args): building_id_widget.options = [ (f"{row['building_id']}, site {row['site_id']}", row['building_id']) for _, row in rows_df[ rows_df.meter == meter_widget.value].iterrows() ] meter_widget.observe(update_buildings_list, 'value') update_buildings_list() def plot_meter(meter, building_id): df_to_plot_selected = df_to_plot[(df_to_plot['meter'] == meter) & ( df_to_plot['building_id'] == building_id)][cols] if df_to_plot_selected[cols[0]].isna().all(): df_to_plot_selected.loc['01.01.2016 00:00', cols[0]] = 0 plot = df_to_plot_selected.iplot( asFigure=True, kind='scatter', width=1, theme='ggplot', dimensions=(None, None), margin=(0, 0, 30, 30), # l,r,b,t ) plot['layout']['legend_orientation'] = 'h' display(plot) interact(plot_meter, meter=meter_widget, building_id=building_id_widget)
def preview(self): #figure, axis = plt.subplots() [height, width] = np.shape(self.images_array[0]) text_y = 0.1 * height text_x = 0.6 * width def display_selected_image(index, text_x, text_y, pre_text, post_text, color): font = { 'family': 'serif', 'color': color, 'weight': 'normal', 'size': 16 } fig = plt.figure(figsize=(15, 10)) gs = gridspec.GridSpec(1, 1) ax = plt.subplot(gs[0, 0]) im = ax.imshow(self.images_array[index], interpolation='nearest') plt.title("image index {}".format(index)) plt.text(text_x, text_y, "{} {:.2f}{}".format(pre_text, self.list_time_offset[index], post_text), fontdict=font) fig.colorbar(im) plt.show() return { 'text_x': text_x, 'text_y': text_y, 'pre_text': pre_text, 'post_text': post_text, 'color': color } self.preview = interact( display_selected_image, index=widgets.IntSlider(min=0, max=len(self.list_files), continuous_update=False), text_x=widgets.IntSlider(min=0, max=width, value=text_x, description='Text x_offset', continuous_update=False), text_y=widgets.IntSlider(min=0, max=height, value=text_y, description='Text y_offset', continuous_upadte=False), pre_text=widgets.Text(value='Time Offset', description='Pre text'), post_text=widgets.Text(value='(s)', description='Post text'), color=widgets.RadioButtons( options=['red', 'blue', 'white', 'black', 'yellow'], value='red', description='Text Color'))
def create_search_params(self): start_date = widgets.DatePicker(description="Pick a start date", style={"description_width": "initial"}) end_date = widgets.DatePicker(description="Pick an end date", style={"description_width": "initial"}) sensors = widgets.RadioButtons( options=["pleiades", "spot"], value="pleiades", description="Sensor", # ) max_cloudcover = widgets.IntSlider( value=20, min=0, max=100, step=1, description="Max Cloud Cover (%)", style={"description_width": "initial"}, ) limit = widgets.IntSlider( value=10, min=1, max=500, step=1, description="Limit", ) button = widgets.Button(description="Save search params!") def create_search_params(start_date, end_date, sensors, max_cloudcover, limit): assert self.ensure_variables( (self.catalog, self.aoi)), "Please select an AOI and/or authenticate!" search_parameters = self.catalog.construct_parameters( geometry=self.aoi, start_date=start_date.value, end_date=end_date.value, sensors=[sensors.value], max_cloudcover=max_cloudcover.value, sortby="cloudCoverage", limit=limit.value, ) search_parameters["query"]["deliveryTime"] = {"in": ["MINUTES"]} display(search_parameters) self.search_parameters = search_parameters self.sensors = sensors.value self.process_template( [start_date, end_date, sensors, max_cloudcover, limit], button, create_search_params, start_date=start_date, end_date=end_date, sensors=sensors, max_cloudcover=max_cloudcover, limit=limit, )
def create_mcq(description, options, correct_answer, hint): if correct_answer not in options: options.append(correct_answer) correct_answer_index = options.index(correct_answer) radio_options = [(words, i) for i, words in enumerate(options)] alternativ = widgets.RadioButtons( options=radio_options, description='', layout={'width': 'max-content'}, disabled=False, indent=False, align='center', ) description_out = widgets.Output(layout=Layout(width='auto')) with description_out: print(description) feedback_out = widgets.Output() def check_selection(b): a = int(float(alternativ.value)) if a == correct_answer_index: s = '\x1b[6;30;42m' + "correct" + '\x1b[0m' + "\n" else: s = '\x1b[5;30;41m' + "try again" + '\x1b[0m' + "\n" with feedback_out: feedback_out.clear_output() print(s) return check = widgets.Button(description="check") check.on_click(check_selection) # hint_out = widgets.Output() # def hint_selection(b): # with hint_out: # print(hint) # with feedback_out: # feedback_out.clear_output() # print(hint) #hintbutton = widgets.Button(description="hint") #hintbutton.on_click(hint_selection) return widgets.VBox( [description_out, alternativ, widgets.HBox([check]), feedback_out], layout=Layout(display='flex', flex_flow='column', align_items='stretch', width='auto'))
def RadioButtons(question, options=['1', '2', '3', '4', '5']): start_time = time.time() widget = widgets.RadioButtons(options=options, description='Answer:', disabled=False) display(widget) def on_value_change(change): # Appends to the dictionary answer Answer_Dict[question].append(change["new"]) widget.observe(on_value_change, names='value') button(question, start_time)
def with_or_without_roi(self): label1 = widgets.Label( "Do you want to select a region of interest (ROI) that will make sure that the " + "sample background matches the OB background") label2 = widgets.Label( "-> Make sure your selection do not overlap your sample!") box = widgets.HBox([ widgets.Label("With or Without ROI?"), widgets.RadioButtons(options=['yes', 'no'], value='yes', layout=widgets.Layout(width='50%')) ]) self.with_or_without_radio_button = box.children[1] vertical = widgets.VBox([label1, label2, box]) display(vertical)
def _generate_widgets(self): data = [ { 'x': self.eng_strain, 'y': self.eng_stress / 1e6, 'name': self.meta.get('name') or '', 'line': { 'color': DEFAULT_PLOTLY_COLORS[0], }, }, ] layout = { 'title': 'Tensile test', 'width': TensileTest.FIG_WIDTH, 'height': TensileTest.FIG_HEIGHT, 'margin': TensileTest.FIG_MARG, 'xaxis': { 'title': 'Engineering strain, ε', 'range': [ -TensileTest.FIG_PAD[0], TensileTest.FIG_PAD[0] + self.max_strain ], }, 'yaxis': { 'title': 'Engineering stress, σ / MPa', 'range': [ -TensileTest.FIG_PAD[1], TensileTest.FIG_PAD[1] + self.max_stress / 1e6 ], }, } fig_wig = go.FigureWidget(data=data, layout=layout) widget_ss_type = widgets.RadioButtons( options=['Engineering', 'True'], description='Stress/strain:', value='Engineering', ) widget_ss_type.observe(self._update_widgets_stress_strain_type, names='value') widget_dict = { 'figure': fig_wig, 'stress_strain_type': widget_ss_type, } return widget_dict
def _radioGraphStyle(self): label = widgets.Label(value="Axe Type", layout=Layout(width="95%")).add_class('space') rad = widgets.RadioButtons(options=[ 'Single Axe X/Y', 'Double X Axe (twinx)', 'Double Y Axe (twiny)' ], value='Single Axe X/Y', disabled=False, layout=Layout( width="98%", justify_content="space-between", align_self="center")) rad.observe(self.changed, names="value") self._y2Label.layout.visibility = 'hidden' self._x2Label.layout.visibility = 'hidden' return widgets.VBox([label, rad], layout=Layout(width="99%", justify_content="space-between", align_items="flex-start"))
def how_to_combine(self): _file = open("__docs/combine_images/geometric_mean.png", 'rb') _geo_image = _file.read() geo_box = widgets.HBox([widgets.Label("Geometric Mean", layout=widgets.Layout(width='20%')), widgets.Image(value=_geo_image, format='png')]) _file = open("__docs/combine_images/algebric_mean.png", 'rb') _alge_image = _file.read() alge_box = widgets.HBox([widgets.Label("Arithmetic Mean", layout=widgets.Layout(width='20%')), widgets.Image(value=_alge_image, format='png')]) self.combine_method = widgets.RadioButtons(options=['add', 'arithmetic mean', 'geometric mean'], value='arithmetic mean') vertical = widgets.VBox([alge_box, geo_box, self.combine_method]) display(vertical)
def __init__(self, on_interact=None, output=None, overwrite_previous_output=True, feedback=False, run=True, action_kws={}, *args, **kwargs): super().__init__(on_interact=on_interact, output=output, overwrite_previous_output=overwrite_previous_output, feedback=feedback, action_kws=action_kws) self.widget = widgets.RadioButtons(*args, **kwargs) if run: self.run()
def plot_derivatives(datamart, target_col, derivatives_cols): """Plot derivatives interactively.""" cols = [target_col] + derivatives_cols df_to_plot = datamart.loc[:, ['meter', 'site_id', 'building_id', 'timestamp'] + cols] df_to_plot.set_index('timestamp', inplace=True) rows_df = datamart[['meter', 'building_id', 'site_id']].drop_duplicates() meter_widget = widgets.RadioButtons( options=[('Electricity (0)', 0), ('Chilled water (1)', 1), ('Steam (2)', 2), ('Hot water (3)', 3)]) building_id_widget = widgets.Select() def update_buildings_list(*args): building_id_widget.options = [ (f"{row['building_id']}, site {row['site_id']}", row['building_id']) for _, row in rows_df[ rows_df.meter == meter_widget.value].iterrows() ] meter_widget.observe(update_buildings_list, 'value') update_buildings_list() def plot_meter(meter, building_id): df_to_plot_selected = df_to_plot[(df_to_plot['meter'] == meter) & ( df_to_plot['building_id'] == building_id)][cols] if df_to_plot_selected[cols[0]].isna().all(): df_to_plot_selected.loc['01.01.2016 00:00', cols[0]] = 0 plot = df_to_plot_selected.iplot( asFigure=True, kind='scatter', width=1, theme='ggplot', dimensions=(None, None), margin=(0, 0, 30, 30), # l,r,b,t ) plot['layout']['legend_orientation'] = 'h' display(plot) interact(plot_meter, meter=meter_widget, building_id=building_id_widget)
def gaussian(self, plot): """ Plot gaussian graphics manage user interactions with time ans scn sliders :param plot: plotElement to use :return: """ def change(choice, time_v, scn_v): if choice == 'time': scn.disabled = True time.disabled = False display(go.FigureWidget(plot.gaussian(t=time_v))) if choice == 'scn': scn.disabled = False time.disabled = True display(go.FigureWidget(plot.gaussian(scn=scn_v))) choice = widgets.RadioButtons(options=['time', 'scn'], value='time', description='') time = widgets.IntSlider(value=0, min=0, description='time', max=self.plotting.agg.horizon - 1, continuous_update=False, disabled=False) scn = widgets.IntSlider(value=0, min=0, description='scn', max=self.plotting.agg.nb_scn - 1, continuous_update=False, disabled=True) hbox = widgets.HBox([choice, time, scn]) inter = interactive_output(change, { 'choice': choice, 'time_v': time, 'scn_v': scn }) return widgets.VBox([hbox, inter])
def seismic_app(): v1 = widgets.FloatSlider(description="v1", min=300, max=2000, step=1, continuous_update=False, value=400) v2 = widgets.FloatSlider(description="v2", min=300, max=5000, step=1, continuous_update=False, value=1000) v3 = widgets.FloatSlider(description="v3", min=300, max=5000, step=1, continuous_update=False, value=1500) z1 = widgets.FloatSlider(description="z1", min=5, max=50, step=1, continuous_update=False, value=5) z2 = widgets.FloatSlider(description="z2", min=5, max=50, step=1, continuous_update=False, value=10) x_loc = widgets.FloatSlider( description="offset", min=1, max=100, step=0.5, continuous_update=False, value=80, ) t_star = widgets.FloatSlider( description="time", min=0.001, max=0.25, step=0.001, continuous_update=False, value=0.1, orientation="vertical", readout_format=".3f", ) show = widgets.RadioButtons( description="plot", options=["direct", "reflection", "refraction1", "refraction2", "all"], value="all", disabled=False, ) out = widgets.interactive_output( interact_refraction, { "v1": v1, "v2": v2, "v3": v3, "z1": z1, "z2": z2, "x_loc": x_loc, "t_star": t_star, "show": show, }, ) left = widgets.VBox( [t_star], layout=widgets.Layout(width="10%", height="400px", margin="300px 0px 0px 0px"), ) right = widgets.VBox( [show, v1, v2, v3, z1, z2], layout=widgets.Layout(width="50%", height="400px", margin="20px 0px 0px 0px"), ) image = widgets.VBox( [out, x_loc], layout=widgets.Layout(width="70%", height="600px", margin="0px 0px 0px 0px"), ) return widgets.HBox([left, image, right])
probs = {} for lbl in counts.keys(): probs[lbl] = str(int(counts[lbl] / total * 100)) + "%" return probs if __name__ == '__main__': my_tree = build_tree(training_data1) print_tree(my_tree) #following is a 2-D array #loan id text0=widgets.Text(description="Loan ID:",placeholder='Enter Loan ID') display(text0) #gender w0=widgets.RadioButtons( options=['Male', 'Female'], description='\nGender:\n', layout=Layout(width='100%', height='100%'), disabled=False ) def on_change(change): if change['type'] == 'change' and change['name'] == 'value': print(change['new']) w0.observe(on_change) display(w0) #marital status w1=widgets.RadioButtons( options=['Yes', 'No'], description='\nMarried?\n', disabled=False ) def on_change(change):
def test_workflow(self): selected_blocks = widgets.RadioButtons( options=[ ["oneatlas-pleiades-fullscene", "pansharpen"], ["oneatlas-pleiades-display", "data-conversion-dimap"], ["oneatlas-pleiades-aoiclipped"], ["oneatlas-spot-fullscene", "pansharpen"], ["oneatlas-spot-display", "data-conversion-dimap"], ["oneatlas-spot-aoiclipped"], ], value=["oneatlas-pleiades-fullscene", "pansharpen"], layout={"width": "max-content"}, description="Blocks to use", ) button = widgets.Button(description="Run test queries!") def test_workflow(selected_blocks): assert self.ensure_variables( (self.full_coverage, self.catalog)), "Please run steps before (optimize coverage)!" self.project = up42.initialize_project() self.project.update_project_settings(max_concurrent_jobs=10) self.workflow = self.project.create_workflow("mosaicking", use_existing=True) blocks = up42.get_blocks(basic=True) self.workflow.add_workflow_tasks( [blocks[selected] for selected in selected_blocks.value]) # Test workflow & availability of sections parameters = [] for _, row in self.full_coverage.iterrows(): test_parameters = self.workflow.construct_parameters( geometry=row.geometry, geometry_operation="intersects", scene_ids=[row["sceneId"]], ) parameters.append(test_parameters) test_jobs = self.workflow.test_jobs_parallel( parameters, name="mosaicking_tests") test_jobs_df = {} for i, test_job in enumerate(test_jobs): estimation = self.workflow.estimate_job(parameters[i]) test_df = test_job.get_results_json(as_dataframe=True) test_df["minEstimatedCredits"] = sum([ block["blockConsumption"]["credit"]["min"] + block["machineConsumption"]["credit"]["min"] for block in estimation.values() ]) test_df["maxEstimatedCredits"] = sum([ block["blockConsumption"]["credit"]["max"] + block["machineConsumption"]["credit"]["max"] for block in estimation.values() ]) display(test_df) test_jobs_df[test_job.job_id] = test_df test_jobs_df = pd.concat(test_jobs_df.values(), keys=test_jobs_df.keys()) display(test_jobs) print("=======================================================") print("Generating this mosaic is estimated to cost:") print( f"{test_jobs_df['minEstimatedCredits'].sum()} - {test_jobs_df['maxEstimatedCredits'].sum()} " "UP42 credits") print("=======================================================") self.selected_blocks = selected_blocks.value print("finished") self.process_template([selected_blocks], button, test_workflow, selected_blocks=selected_blocks)
def which_math(self): self.math_method = widgets.RadioButtons(options=['substract', 'add'], value='substract') display(self.math_method)
def _calculate_sample_size_interactive(metric): style = {'description_width': 'initial'} desc_layout = widgets.Layout(width='50%') if metric == 'continuous': mde_widget = widgets.FloatText( value=0.01, description='', ) mde_desc = widgets.HTML(""" <small> This is the smallest absolute difference in averages that any of your comparisons can detect at the given statistical rigour. </small> """, layout=desc_layout) baseline_title = widgets.HTML("<strong>Baseline variance</strong>") baseline_widget = widgets.BoundedFloatText( value=1.0, min=0.00001, max=1000000000.0, description='', ) baseline_desc = widgets.HTML(""" <small> This is the expected variance of the metric among users in your control group. </small> """, layout=desc_layout) elif metric == 'binomial': mde_widget = widgets.FloatLogSlider(value=0.003, base=10, min=-4, max=np.log10(0.5), step=0.001, description='', readout_format='.4f') mde_desc = widgets.HTML(""" <small> This is the smallest absolute difference (percentage point / 100) that any of your comparisons can detect at the given statistical rigour. </small> """, layout=desc_layout) baseline_title = widgets.HTML("<strong>Baseline " "proportion</strong>") baseline_widget = widgets.FloatSlider(value=0.5, min=0.00001, max=0.99999, step=0.01, description='') baseline_desc = widgets.HTML(""" <small> This is the expected value of the metric among users in your control group. </small> """, layout=desc_layout) else: raise ValueError('metric must be `continuous` or `binomial`') alpha_widget = widgets.FloatSlider(value=0.05, min=0.001, max=0.10, step=0.001, description=r'\(\alpha\)', readout_format='.3f') power_widget = widgets.FloatSlider(value=0.85, min=0.8, max=0.99, step=0.01, description=r'Power, \( 1-\beta\)') treatments_widget = widgets.IntSlider( value=2, min=2, max=20, step=1, description='Groups (including control)', style=style) comparisons_widget = widgets.RadioButtons( options=['Control vs. All', 'All vs. All'], value='Control vs. All', description='Groups to compare', style=style) control_group_widget = widgets.FloatLogSlider( value=1, step=0.1, base=10, min=0, max=4, description='Control group advantage', readout=False, style=style, ) control_group_description = widgets.HTML(""" <small> Sometime we want the control group to be bigger than what is strictly optimal. This can be either because we can collect samples quickly enough anyway or because we believe the treatment variants are riskier. Boosting the size of the control group comes at the cost of an increased total required sample. </small> """, layout=desc_layout) bonferroni_widget = widgets.Checkbox( value=False, description='Apply Bonferroni correction') risk_reset_btn = widgets.Button(description=' ', disabled=False, button_style='', tooltip='Reset variant risk', icon='repeat', layout=widgets.Layout(width="40px")) def reset_widget(b): control_group_widget.value = 1 risk_reset_btn.on_click(reset_widget) ui = widgets.VBox([ widgets.HTML('<h4>Target metric</h4>'), widgets.VBox(children=[ widgets.HTML("<strong>Minimal Detectable Effect " "size</strong>"), mde_widget, mde_desc ], ), widgets.VBox( children=[baseline_title, baseline_widget, baseline_desc], ), widgets.HTML('<h4>Statistical rigour</h4>'), alpha_widget, power_widget, bonferroni_widget, widgets.HTML('<h4>Treatment groups</h4>'), treatments_widget, comparisons_widget, widgets.VBox(children=[ widgets.HBox([control_group_widget, risk_reset_btn]), control_group_description ]) ]) def show_samplesize(mde, baseline, alpha, power, treatments, comparisons_readable, bonferroni_correction, relative_risk): if comparisons_readable == 'Control vs. All': comparisons = 'control_vs_all' else: comparisons = 'all_vs_all' treatment_costs = np.ones(treatments) treatment_costs[1:] = relative_risk treatment_allocations = None if metric == 'continuous': n_optimal, _, _ = SampleSize.continuous( mde, baseline, alpha, power, treatments, comparisons, None, treatment_allocations, bonferroni_correction) n_tot, n_cell, prop_cell = SampleSize.continuous( mde, baseline, alpha, power, treatments, comparisons, treatment_costs, treatment_allocations, bonferroni_correction) code_html = widgets.HTML( "<pre><code>" f"SampleSize.continuous(average_absolute_mde={ mde },\n" f" baseline_variance={ baseline },\n" f" alpha={ alpha },\n" f" power={ power },\n" f" treatments={ treatments },\n" f" comparisons=" f"'{ comparisons }',\n" f" treatment_costs=" f"{ list(treatment_costs) },\n" f" treatment_allocations=None,\n" f" bonferroni_correction=" f"{ bonferroni_correction })" "<code></pre>") else: n_tot, n_cell, prop_cell = SampleSize.binomial( mde, baseline, alpha, power, treatments, comparisons, treatment_costs, treatment_allocations, bonferroni_correction) n_optimal, _, _ = SampleSize.binomial(mde, baseline, alpha, power, treatments, comparisons, None, treatment_allocations, bonferroni_correction) code_html = widgets.HTML( "<pre><code>" f"SampleSize.binomial(absolute_percentage_mde={ mde },\n" f" baseline_proportion=" f"{ baseline },\n" f" alpha={ alpha },\n" f" power={ power },\n" f" treatments={ treatments },\n" f" comparisons=" f"'{ comparisons }',\n" f" treatment_costs=" f"{ list(treatment_costs) },\n" f" treatment_allocations=None,\n" f" bonferroni_correction=" f"{ bonferroni_correction })" "<code></pre>") def compare_against_optimal(current, optimal): if current == optimal: return '' else: return (f"<br><small><em>{current/optimal:.1f}x " f"optimal group allocation of {optimal:,}." f"</em></small>") display( widgets.HTML(f"<h4>Required sample size</h4>" f"<strong>Total:</strong><br>{n_tot:,}" f"{compare_against_optimal(n_tot, n_optimal)}")) cell_str = '<strong>Sample size in each cell</strong>' for i in range(len(n_cell)): if i == 0: treatment = 'Control' else: treatment = 'Variant ' + str(i) cell_str += (f"<br><em>{treatment}:</em> " f"{n_cell[i]:,} ({prop_cell[i]*100:.1f}%)") display(widgets.HTML(cell_str)) display(code_html) out = widgets.interactive_output( show_samplesize, { 'mde': mde_widget, 'baseline': baseline_widget, 'alpha': alpha_widget, 'power': power_widget, 'treatments': treatments_widget, 'comparisons_readable': comparisons_widget, 'bonferroni_correction': bonferroni_widget, 'relative_risk': control_group_widget }) display(ui, out)
def _generate_widgets_macro_stress_strain(self): data = [{ 'x': self.exp_tensile_test.eng_strain, 'y': self.exp_tensile_test.eng_stress, 'name': 'Experimental', 'line': { 'color': DEFAULT_PLOTLY_COLORS[0], }, }, { 'x': [self.exp_tensile_test.plastic_range[0]] * 2 + [None] + [self.exp_tensile_test.plastic_range[1]] * 2, 'y': [ -HardeningLawFitter.FIG_PAD[1], HardeningLawFitter.FIG_PAD[1] + self.exp_tensile_test.max_stress, None, -HardeningLawFitter.FIG_PAD[1], HardeningLawFitter.FIG_PAD[1] + self.exp_tensile_test.max_stress, ], 'mode': 'lines', 'line': { 'color': '#888', 'width': 2, }, 'showlegend': False, }] layout = { 'title': 'Experimental Data', 'width': HardeningLawFitter.FIG_WIDTH, 'height': HardeningLawFitter.FIG_HEIGHT, 'margin': HardeningLawFitter.FIG_MARG, 'xaxis': { 'title': 'Engineering strain, ε', 'range': [ -HardeningLawFitter.FIG_PAD[0], HardeningLawFitter.FIG_PAD[0] + self.exp_tensile_test.max_strain ], }, 'yaxis': { 'title': 'Engineering stress, σ / MPa', 'range': [ -HardeningLawFitter.FIG_PAD[1], HardeningLawFitter.FIG_PAD[1] + self.exp_tensile_test.max_stress ], }, } widget_ss_type = widgets.RadioButtons( options=['Engineering', 'True'], description='Stress/strain:', value='Engineering', ) plastic_range_widget = widgets.FloatRangeSlider( value=self.exp_tensile_test.plastic_range, step=0.005, min=self.exp_tensile_test.min_true_strain, max=self.exp_tensile_test.max_true_strain, description='Plastic range:', disabled=False, continuous_update=False, orientation='horizontal', readout_format='.4f', layout=widgets.Layout(width='90%'), ) widget_ss_type.observe(self._update_widgets_stress_strain_type, names='value') plastic_range_widget.observe(self._update_widgets_plastic_range, names='value') out = { 'fig': go.FigureWidget(data=data, layout=layout), 'fig_trace_idx': { 'macro_stress_strain': [0], 'plastic_range_boundaries': [1], }, 'controls': { 'stress_strain_type': widget_ss_type, 'plastic_range': plastic_range_widget, }, } return out
def build_layout(self, dset_id: str): """ :param dset_id: :return: """ all_fields = list(self.get_data(dset_id=dset_id).keys()) try: field_reference = self.skd[dset_id].attrs('target') except: field_reference = all_fields[0] fields_comparison = [all_fields[1]] # chart type widget self.register_widget( chart_type=widgets.RadioButtons( options=['individual', 'grouped'], value='individual', description='Chart Type:' ) ) # bins widget self.register_widget( bins=IntSlider( description='Bins:', min=2, max=10, value=2, continuous_update=False ) ) # fields comparison widget self.register_widget( xs=widgets.SelectMultiple( description='Xs:', options=[f for f in all_fields if not f == field_reference], value=fields_comparison ) ) # field reference widget self.register_widget( y=widgets.Dropdown( description='Y:', options=all_fields, value=field_reference ) ) # used to internal flow control y_changed = [False] self.register_widget( box_filter_panel=widgets.VBox([ self._('y'), self._('xs'), self._('bins') ]) ) # layout widgets self.register_widget( table=widgets.HTML(), chart=widgets.HTML() ) self.register_widget(vbox_chart=widgets.VBox([ self._('chart_type'), self._('chart') ])) self.register_widget( tab=widgets.Tab( children=[ self._('box_filter_panel'), self._('table'), self._('vbox_chart') ] ) ) self.register_widget(dashboard=widgets.HBox([self._('tab')])) # observe hooks def w_y_change(change: dict): """ When y field was changed xs field should be updated and data table and chart should be displayed/updated. :param change: :return: """ # remove reference field from the comparison field list _xs = [ f for f in all_fields if not f == change['new'] ] y_changed[0] = True # flow control variable _xs_value = list(self._('xs').value) if change['new'] in self._('xs').value: _xs_value.pop(_xs_value.index(change['new'])) if not _xs_value: _xs_value = [_xs[0]] self._('xs').options = _xs self._('xs').value = _xs_value self._display_result(y=change['new'], dset_id=dset_id) y_changed[0] = False # flow control variable # widgets registration # change tab settings self._('tab').set_title(0, 'Filter') self._('tab').set_title(1, 'Data') self._('tab').set_title(2, 'Chart') # data panel self._('table').value = '...' # chart panel self._('chart').value = '...' # create observe callbacks self._('bins').observe( lambda change: ( self._display_result(bins=change['new'], dset_id=dset_id) ), 'value' ) self._('y').observe(w_y_change, 'value') # execute display result if 'y' was not changing. self._('xs').observe( lambda change: ( self._display_result(xs=change['new'], dset_id=dset_id) if not y_changed[0] else None ), 'value' ) self._('chart_type').observe( lambda change: ( self._display_result(chart_type=change['new'], dset_id=dset_id) ), 'value' )
def interact_plot_model_prism(self): plot = widgets.RadioButtons( options=["field", "model"], value="field", description="plot", disabled=False, ) component = widgets.RadioButtons( options=["Bt", "Bx", "By", "Bz"], value="Bt", description="field", disabled=False, ) inclination = widgets.FloatSlider(description="I", continuous_update=False, min=-90, max=90, step=1, value=90) declination = widgets.FloatSlider(description="D", continuous_update=False, min=-180, max=180, step=1, value=0) length = widgets.FloatSlider( description="length", continuous_update=False, min=2, max=200, step=1, value=72, ) dx = widgets.FloatSlider( description="data spacing", continuous_update=False, min=0.1, max=15, step=0.1, value=2, ) kappa = widgets.FloatText(description="$\kappa$", value=0.1) B0 = widgets.FloatText(description="B$_0$", value=56000) depth = widgets.FloatSlider( description="depth", continuous_update=False, min=0, max=50, step=1, value=10, ) profile = widgets.RadioButtons( options=["East", "North", "None"], value="East", description="profile", disabled=False, ) fixed_scale = widgets.Checkbox(value=False, description="fixed scale", disabled=False) show_halfwidth = widgets.Checkbox(value=False, description="half width", disabled=False) prism_dx = widgets.FloatText(description="$\\triangle x$", value=1) prism_dy = widgets.FloatText(description="$\\triangle y$", value=1) prism_dz = widgets.FloatText(description="$\\triangle z$", value=1) prism_inclination = widgets.FloatSlider( description="I$_{prism}$", continuous_update=False, min=-90, max=90, step=1, value=0, ) prism_declination = widgets.FloatSlider( description="D$_{prism}$", continuous_update=False, min=0, max=180, step=1, value=0, ) out = widgets.interactive_output( self.magnetic_prism_applet, { "plot": plot, "component": component, "inclination": inclination, "declination": declination, "length": length, "dx": dx, "kappa": kappa, "B0": B0, "depth": depth, "profile": profile, "fixed_scale": fixed_scale, "show_halfwidth": show_halfwidth, "prism_dx": prism_dx, "prism_dy": prism_dy, "prism_dz": prism_dz, "prism_inclination": prism_inclination, "prism_declination": prism_declination, }, ) left = widgets.VBox( [plot, component, profile], layout=Layout(width="20%", height="400px", margin="60px 0px 0px 0px"), ) right = widgets.VBox( [ inclination, declination, length, dx, B0, kappa, depth, prism_dx, prism_dy, prism_dz, prism_inclination, prism_declination, fixed_scale, show_halfwidth, ], layout=Layout(width="50%", height="400px", margin="20px 0px 0px 0px"), ) widgets.VBox([out], layout=Layout(width="70%", height="400px", margin="0px 0px 0px 0px")) return widgets.HBox([left, out, right])
def hyperExplore(df,initial_axis,initial_surface_axis,legend_group,hover_items): data = df.assign(x=df[initial_axis[0]],y=df[initial_axis[1]])\ .sort_values(legend_group)\ .reset_index(drop=True) group_ops = data[legend_group].sort_values().unique() num_groups = len(group_ops) axis_ops = data.columns.values lenSlide = '500px' fig = px.scatter(data, x="x", y="y", color=legend_group,hover_data=hover_items, log_x=True, title='Hyperparameter Exploration',height=600) fig.update_layout( legend=dict( orientation="v", yanchor="top", y=1.02, xanchor="left", x=1), xaxis=dict(title=initial_axis[0], titlefont=dict(size=14)), yaxis=dict(title=initial_axis[1], titlefont=dict(size=14)) ) fig.update_traces(marker=dict(size=20,line=dict(width=1.5, color='DarkSlateGrey')), selector=dict(mode='markers')) fig.update_layout(plot_bgcolor='rgba(0,0,0,0)') fig.update_xaxes(showgrid=True, gridwidth=.1, gridcolor='lightgrey') fig.update_yaxes(showgrid=True, gridwidth=.1, gridcolor='lightgrey') param_drop1 = Dropdown( value='None', options=np.insert(axis_ops,0,'None'), description='Parameter 1:' ) slider1 = widgets.SelectionSlider( options=['Select Parameter'], value='Select Parameter', layout=Layout(width=lenSlide), continuous_update=True ) size_drop = Dropdown( value='None', options=np.insert(axis_ops,0,'None'), description='Size:' ) size_slider = widgets.IntSlider( value=20, min=10, max=50, step=1, disabled=False, continuous_update=True, orientation='horizontal', layout=Layout(width=lenSlide), readout=True, readout_format='d' ) slider_group1 = widgets.HBox([param_drop1, slider1]) slider_group2 = widgets.HBox([size_drop, size_slider]) xaxis = Dropdown( value=initial_axis[0], options=axis_ops, description='X-axis:' ) yaxis = Dropdown( value=initial_axis[1], options=axis_ops, description='Y-axis:' ) container = widgets.VBox(children=[slider_group1,slider_group2,xaxis,yaxis]) g = go.FigureWidget(data=fig, layout=go.Layout( title=dict( text='Hyperparameter Exploration' ) )) x_surface = Dropdown( value=initial_surface_axis[0], options=axis_ops, description='X-axis' ) y_surface = Dropdown( value=initial_surface_axis[1], options=axis_ops, description='Y-axis' ) z_surface = Dropdown( value=initial_surface_axis[2], options=axis_ops, description='Z-axis' ) surface_buttons = widgets.RadioButtons( options=group_ops, value=group_ops[0], # Defaults to 'pineapple' description=legend_group+":", disabled=False ) z_vals = data.query('{} == "{}"'\ .format(legend_group,surface_buttons.value))[[x_surface.value,y_surface.value,z_surface.value]]\ .groupby([x_surface.value,y_surface.value])\ .median().reset_index()\ .pivot(index=x_surface.value,columns=y_surface.value,values=z_surface.value) fig2 = go.Figure(data=[go.Surface(z=z_vals)]) fig2.update_layout(title='Hyperparameter Surface: '+surface_buttons.value, autosize=False, margin=dict(l=65, r=50, b=65, t=90), height=600) layout = go.Layout( scene = dict( xaxis = dict( title = initial_surface_axis[0]), yaxis = dict( title = initial_surface_axis[1]), zaxis = dict( title = initial_surface_axis[2]), )) fig2.update_layout(layout) container2 = widgets.HBox(children=[surface_buttons,x_surface,y_surface,z_surface]) g2 = go.FigureWidget(data=fig2, layout=go.Layout( title=dict( text='Hyperparameter Surface: '+surface_buttons.value ) )) def axis_response(change): with g.batch_update(): #Gets the widget that was altered modified = change.owner.description if modified == xaxis.description: for i in range(num_groups): #Get data for legend group filtered_data = data.query("{} == '{}'".format(legend_group,g.data[i].name)) #Query filtered data for slider specs query_filt(filtered_data,i) g.layout.xaxis.title = xaxis.value elif modified == yaxis.description: for i in range(num_groups): #Get data for legend group filtered_data = data.query("{} == '{}'".format(legend_group,g.data[i].name)) #Query filtered data for slider specs query_filt(filtered_data,i) g.layout.yaxis.title = yaxis.value def slider1_response(change): with g.batch_update(): for i in range(num_groups): #Get data for legend group filtered_data = data.query("{} == '{}'".format(legend_group,g.data[i].name))#make key var that iters #Query filtered data for slider specs query_filt(filtered_data,i) def query_filt(filtered_data,i): #Query filtered data for slider specs # filt_bool = (filtered_data.learning_rate == lr_slider.value)#make learning_rate var if param_drop1.value == 'None': #Assign data to graph g.data[i].x = filtered_data[xaxis.value] g.data[i].y = filtered_data[yaxis.value] else: filt_bool = (filtered_data[param_drop1.value] == slider1.value)#make learning_rate var #Filter out data xfilt = [v if b else None for v,b in zip(filtered_data[xaxis.value],filt_bool)] yfilt = [v if b else None for v,b in zip(filtered_data[yaxis.value],filt_bool)] #Assign data to graph g.data[i].x = xfilt g.data[i].y = yfilt def create_slider_options(drop_value): if drop_value == 'None': slide_ops = ['Select Parameter'] else: slide_ops = data[drop_value].sort_values().unique() return slide_ops def param_update(change): #everytime we change param, update the slider options and current value slider1.options = create_slider_options(param_drop1.value) slider1.value = slider1.options[0] def size_response(change): with g.batch_update(): if size_drop.value == 'None': g.update_traces(marker=dict(size=size_slider.value)) else: sizeFig = px.scatter(data, x="x", y="y", color="model", size=size_drop.value, size_max=size_slider.value) traceSizes = [x.marker.size for x in sizeFig.data] for i in range(num_groups): g.data[i].marker.size = traceSizes[i] g.data[i].marker.sizeref = sizeFig.data[0].marker.sizeref g.data[i].marker.sizemode = sizeFig.data[0].marker.sizemode g.data[i].marker.sizemin = 4 def surface_response(change): with g.batch_update(): z_vals = data.query('{} == "{}"'\ .format(legend_group,surface_buttons.value))[[x_surface.value,y_surface.value,z_surface.value]]\ .groupby([x_surface.value,y_surface.value])\ .median().reset_index()\ .pivot(index=x_surface.value,columns=y_surface.value,values=z_surface.value) g2.data[0].z = z_vals.values layout = go.Layout( scene = dict( xaxis = dict( title = x_surface.value), yaxis = dict( title = y_surface.value), zaxis = dict( title = z_surface.value), ), title=dict( text='Hyperparameter Surface: '+surface_buttons.value )) g2.update_layout(layout) surface_buttons.observe(surface_response,"value") x_surface.observe(surface_response,"value") y_surface.observe(surface_response,"value") z_surface.observe(surface_response,"value") size_drop.observe(size_response,"value") size_slider.observe(size_response, "value") slider1.observe(slider1_response, names="value") xaxis.observe(axis_response, names="value") yaxis.observe(axis_response, names="value") param_drop1.observe(param_update, names="value") scatterTab = widgets.VBox([container,g]) surfaceTab = widgets.VBox([container2,g2]) tab = widgets.Tab([scatterTab,surfaceTab]) tab.set_title(0,'Scatter') tab.set_title(1,'Surface') return tab
max=90.0, value=0.0, step=0.01, continuous_update=continuous_update, orientation='horizontal', description='Pipe Inclination [deg]', layout=layout) # Pipe Roughness k_s_button = widgets.FloatSlider(min=0.0, max=1e-3, value=1e-5, step=1e-6, continuous_update=continuous_update, description='Pipe Roughness [m]', readout_format='.2e', layout=layout) interface_button = widgets.Dropdown(options={ 'Smooth': 1, 'Wavy': 2 }, value=1, description='Interface:', layout=layout) plot_mesh_button = widgets.RadioButtons(options=['True', 'False'], value='False', description='Plot grid points:', disabled=False)
def seismic_refraction_app(): v1 = widgets.FloatSlider(description="v1", min=300, max=2000, step=1, continuous_update=False, value=500) v2 = widgets.FloatSlider(description="v2", min=300, max=5000, step=1, continuous_update=False, value=1000) v3 = widgets.FloatSlider(description="v3", min=300, max=5000, step=1, continuous_update=False, value=2000) z1 = widgets.FloatSlider(description="z1", min=5, max=50, step=1, continuous_update=False, value=10) z2 = widgets.FloatSlider(description="z2", min=5, max=50, step=1, continuous_update=False, value=20) x_loc = widgets.FloatSlider(description="offset", min=1, max=100, step=0.5, continuous_update=False, value=80) t_star = widgets.FloatSlider( description="time", min=0.001, max=0.25, step=0.001, continuous_update=False, value=0.1, orientation='vertical', readout_format='.3f', ) show = widgets.RadioButtons( description='plot', options=['direct', 'refraction1', 'refraction2', 'all'], value='all', disabled=False) out = widgets.interactive_output( interact_refraction, { 'v1': v1, 'v2': v2, 'v3': v3, 'z1': z1, 'z2': z2, 'x_loc': x_loc, 't_star': t_star, 'show': show }) left = widgets.VBox([t_star], layout=widgets.Layout(width='10%', height='400px', margin='300px 0px 0px 0px')) right = widgets.VBox([show, v1, v2, v3, z1, z2], layout=widgets.Layout(width='50%', height='400px', margin='20px 0px 0px 0px')) image = widgets.VBox([out, x_loc], layout=widgets.Layout(width='70%', height='600px', margin='0px 0px 0px 0px')) return widgets.HBox([left, image, right])
def interact_plot_model_two_monopole(self): component = widgets.RadioButtons( options=["Bt", "Bx", "By", "Bz", "Bg"], value="Bt", description="field", disabled=False, ) inclination = widgets.FloatSlider(description="I", continuous_update=False, min=-90, max=90, step=1, value=90) declination = widgets.FloatSlider(description="D", continuous_update=False, min=-180, max=180, step=1, value=0) length = widgets.FloatSlider( description="length", continuous_update=False, min=2, max=200, step=1, value=10, ) dx = widgets.FloatSlider( description="data spacing", continuous_update=False, min=0.1, max=15, step=0.1, value=0.1, ) moment = widgets.FloatText(description="M", value=30) depth_n = widgets.FloatSlider( description="depth$_{-Q}$", continuous_update=False, min=0, max=200, step=1, value=0, ) depth_p = widgets.FloatSlider( description="depth$_{+Q}$", continuous_update=False, min=0, max=200, step=1, value=1, ) profile = widgets.RadioButtons( options=["East", "North", "None"], value="East", description="profile", disabled=False, ) fixed_scale = widgets.Checkbox(value=False, description="fixed scale", disabled=False) show_halfwidth = widgets.Checkbox(value=False, description="half width", disabled=False) out = widgets.interactive_output( self.magnetic_two_monopole_applet, { "component": component, "inclination": inclination, "declination": declination, "length": length, "dx": dx, "moment": moment, "depth_n": depth_n, "depth_p": depth_p, "profile": profile, "fixed_scale": fixed_scale, "show_halfwidth": show_halfwidth, }, ) left = widgets.VBox( [component, profile], layout=Layout(width="20%", height="400px", margin="60px 0px 0px 0px"), ) right = widgets.VBox( [ inclination, declination, length, dx, moment, depth_n, depth_p, fixed_scale, show_halfwidth, ], layout=Layout(width="50%", height="400px", margin="20px 0px 0px 0px"), ) widgets.VBox([out], layout=Layout(width="70%", height="400px", margin="0px 0px 0px 0px")) return widgets.HBox([left, out, right])
def __init__( self, input_data: Units, trials: pynwb.epoch.TimeIntervals = None, unit_index=0, unit_controller=None, ntt=1000, ): self.units = input_data super().__init__() if trials is None: self.trials = self.get_trials() if self.trials is None: self.children = [widgets.HTML("No trials present")] return else: self.trials = trials if unit_controller is None: self.unit_ids = self.units.id.data[:] n_units = len(self.unit_ids) self.unit_controller = widgets.Dropdown( options=[(str(self.unit_ids[x]), x) for x in range(n_units)], value=unit_index, description="unit", layout=Layout(width="200px"), ) self.trial_event_controller = make_trial_event_controller( self.trials, layout=Layout(width="200px") ) self.start_ft = widgets.FloatText( -0.5, step=0.1, description="start (s)", layout=Layout(width="200px"), description_tooltip = 'Start time for calculation before or after (negative or positive) the reference point (aligned to)' ) self.end_ft = widgets.FloatText( 1.0, step=0.1, description="end (s)", layout=Layout(width="200px"), description_tooltip = 'End time for calculation before or after (negative or positive) the reference point (aligned to).' ) self.psth_type_radio = widgets.RadioButtons( options=["histogram", "gaussian"], layout=Layout(width="100px") ) self.bins_ft = widgets.IntText( 30, min=0, description="# bins", layout=Layout(width="150px") ) self.gaussian_sd_ft = widgets.FloatText( 0.05, min=0.001, description="sd (s)", layout=Layout(width="150px"), active=False, step=0.01, ) self.gas = self.make_group_and_sort(window=False, control_order=False) self.controls = dict( ntt=fixed(ntt), index=self.unit_controller, end=self.end_ft, start=self.start_ft, start_label=self.trial_event_controller, gas=self.gas, plot_type=self.psth_type_radio, sigma_in_secs=self.gaussian_sd_ft, nbins=self.bins_ft # progress_bar=fixed(progress_bar) ) out_fig = interactive_output(self.update, self.controls) self.children = [ widgets.HBox( [ widgets.VBox( [ self.gas, widgets.HBox( [ self.psth_type_radio, widgets.VBox([self.gaussian_sd_ft, self.bins_ft]), ] ), ] ), widgets.VBox( [ self.unit_controller, self.trial_event_controller, self.start_ft, self.end_ft, ] ), ] ), out_fig, ]
def how_to_combine(self): self.combine_method = widgets.RadioButtons(options=['add', 'mean'], value='add') display(self.combine_method)
max=2019, step=1, value=2003, description='Year '), month=widgets.IntSlider(min=1, max=12, step=1, value=2, description='Month '), days=widgets.IntSlider(min=0, max=10, step=1, value=0, description='Day '), gearbox=widgets.RadioButtons(value='manuell', options=list(df_auto.gearbox.unique()), description="Gear Type "), damage=widgets.RadioButtons(value='no', options=list( df_auto.notRepairedDamage.unique()), description="Repaired ")) df_auto.head() # Importing Necessary Libraries from sklearn.ensemble import RandomForestRegressor from sklearn.model_selection import train_test_split X = df_auto.drop(['price'], axis=1) y = df_auto.price