def __init__(self, tap, smoothed): if smoothed: self.speed_graph = SpeedGraph(['background', 'bar'], ['background', 'bar'], {(1, 0): 'bar:top'}) self.cagraph = urwid.BarGraph(['ca:background', 'ca:c', 'ca:a'], ['ca:background', 'ca:c', 'ca:a'], { (1, 0): 'ca:c:top', (2, 0): 'ca:a:top', }) else: self.speed_graph = SpeedGraph([('background', ' '), ('bar', ' ')], ['background', 'bar']) self.cagraph = urwid.BarGraph([ ('ca:background', ' '), ('ca:c', ' '), ('ca:a', ' '), ]) self.last_reading = urwid.Text("", align="right") scale = urwid.GraphVScale(graph_lines_captions(), graph_range()) footer = self.last_reading graph_cols = urwid.Columns([('fixed', 5, scale), self.speed_graph, ('fixed', 4, self.cagraph)], dividechars=1) self.top = urwid.Frame(graph_cols, footer=footer) self.spd = Speedometer(6) self.feed = tap.feed self.description = tap.description() super(GraphDisplay, self).__init__(self.top)
def update(loop, _): cur = conn.cursor() limit = loop.screen.get_cols_rows()[0] - 16 cur.execute( "SELECT value, measured_at FROM {} WHERE spot_tag = %(spot_tag)s ORDER BY measured_at DESC LIMIT %(lim)s" .format(args.sensor_type), { "lim": limit, "spot_tag": args.spot_tag }, ) data = list(cur.fetchall()) data.reverse() vals = [x[0] for x in data] vmin = floor(min(vals), 5) vmax = ceil(max(vals), 5) top = int((vmax - vmin) * 10) gdata = [[ int((x - vmin) * 10), ] for x in vals] graph.set_data(bardata=gdata, top=top) vscale = [[0, vmin], [top - 2, vmax]] cols.contents[0] = ( urwid.GraphVScale( [( 1 + interp(x, vscale[0][0], vscale[1][0], 5), "{:>4}".format(int(interp(x, vscale[0][1], vscale[1][1], 5))), ) for x in range(0, 6)], top, ), cols.options("given", 4), ) from_date.set_text(fmtdate(data[0][1])) mid_date.set_text(fmtdate((data[-1][1] - data[0][1]) / 2 + data[0][1])) to_date.set_text(fmtdate(data[-1][1])) def set_val(item, val): item.set_text(("vals", "{:.2f}".format(val))) set_val(cur_t, vals[-1]) set_val(min_t, min(vals)) set_val(avg_t, statistics.mean(vals)) set_val(max_t, max(vals)) loop.set_alarm_in(60, update)
def makeGraphArea(): nonlocal graph, graphVscale, graphColumns graph = urwid.BarGraph(attlist=['graph_bg', 'graph_bar']) graph.set_data([], top=1) labels = [[i, '{:.3f}'.format(i)] for i in numpy.arange(0.0, 1.0, 0.01)] graphVscale = urwid.AttrWrap(urwid.GraphVScale(labels=labels, top=1), 'graph_label') graphColumns = urwid.Columns([ (7, urwid.Padding(graphVscale, left=0, right=1)), graph, (7, urwid.Padding(graphVscale, left=1, right=0)) ]) graphFrame = makeMountedFrame(graphColumns, 'Rolling Loss') return graphFrame
def main_window(self): self.w_graph = self.bar_graph() self.w_scale = urwid.GraphVScale([(8.0, '8.0'), (4.0, '4.0')], 12.0) self.w_min = urwid.Text('0.0', align='left') self.w_qinfo = urwid.Text('zero=0, scale=2.0', align='center') self.w_max = urwid.Text('32.0', align='right') footer = urwid.Columns( [self.w_min, ('fixed', 108, self.w_qinfo), self.w_max]) pile0 = urwid.Pile([self.w_graph, ('pack', footer)]) pile1 = urwid.Pile([self.w_scale, ('pack', urwid.Text('chan[:]'))]) controls = self.graph_controls() cols = urwid.Columns([ ('fixed', 8, pile1), ('fixed', 128, pile0), controls, ], dividechars=1, focus_column=2) self.top = urwid.Frame(cols) return self.top
def test_graphvscale(self): self.wstest(urwid.GraphVScale([(0,"hello")], 1)) self.wstest(urwid.GraphVScale([(5,"hello")], 1))
def launchHypermaxUI(optimizer): screen = urwid.raw_display.Screen() palette = [ ('background', 'white', 'dark blue', 'standout'), ('body', 'dark gray', 'light gray', 'standout'), ('frame_header', 'white', 'dark gray', 'standout'), ('frame_shadow', 'black', 'black', 'standout'), ('frame_body', 'dark gray', 'light gray', 'standout'), ('tab_buttons', 'white', 'dark red', 'standout'), ('focus', 'black', 'light gray', 'underline'), ('reverse', 'light gray', 'black'), ('header', 'white', 'dark red', 'bold'), ('important', 'dark blue', 'light gray', ('standout', 'underline')), ('editfc', 'white', 'dark blue', 'bold'), ('editbx', 'light gray', 'dark blue'), ('editcp', 'black', 'light gray', 'standout'), ('bright', 'dark gray', 'light gray', ('bold', 'standout')), ('buttn', 'black', 'dark cyan'), ('buttnf', 'white', 'dark blue', 'bold'), ('graph_bg', 'black', 'light gray'), ('graph_bar', 'black', 'dark cyan', 'bold'), ('graph_label', 'dark cyan', 'light gray', 'bold'), ('table_row_body', 'dark gray', 'light gray', 'standout'), ('table_row_header', 'dark gray', 'light gray', 'underline'), ('table_row_footer', 'dark gray', 'light gray', 'standout'), ('table_row_body focused', 'light gray', 'dark gray', 'standout'), ('table_row_body column_focused', 'light gray', 'dark gray', 'standout'), ('table_row_body highlight', 'light gray', 'dark gray', 'standout'), ('table_row_body highlight focused', 'light gray', 'dark gray', 'standout'), ('table_row_body highlight column_focused', 'light gray', 'dark gray', 'standout'), ('table_row_header focused', 'light gray', 'dark gray', 'standout'), ('table_row_header column_focused', 'light gray', 'dark gray', 'standout'), ('table_row_header highlight', 'light gray', 'dark gray', 'standout'), ('table_row_header highlight focused', 'light gray', 'dark gray', 'standout'), ('table_row_header highlight column_focused', 'light gray', 'dark gray', 'standout'), ('table_row_footer focused', 'light gray', 'dark gray', 'standout'), ('table_row_footer column_focused', 'light gray', 'dark gray', 'standout'), ('table_row_footer highlight', 'light gray', 'dark gray', 'standout'), ('table_row_footer highlight focused', 'light gray', 'dark gray', 'standout'), ('table_row_footer highlight column_focused', 'light gray', 'dark gray', 'standout'), ] def onExitClicked(widget): raise urwid.ExitMainLoop() def viewHyperparameterCorrelations(): if optimizer.results: popupContainer.open_pop_up_with_widget( CorrelationGridPopup(optimizer), size=(('relative', 95), ('relative', 95))) else: popupContainer.open_pop_up_with_widget( MessagePopup('No results to compute correlation on yet.'), size=(('relative', 95), ('relative', 95))) def exportBestParameters(): if optimizer.best: popupContainer.open_pop_up_with_widget( ExportParametersPopup(optimizer)) else: popupContainer.open_pop_up_with_widget( MessagePopup('There is no best model to export yes.'), size=(('relative', 95), ('relative', 95))) popupContainer = None graph = None graphVscale = None graphColumns = None currentTrialsLeft = None currentTrialsMiddle = None currentTrialsRight = None currentBestLeft = None currentBestRight = None def makeMainMenu(): content = [ urwid.AttrWrap(urwid.Button( "Export Results to CSV", on_press=lambda button: popupContainer.open_pop_up_with_widget( ExportCSVPopup(optimizer))), 'body', focus_attr='focus'), urwid.AttrWrap(urwid.Button( 'View Hyperparameter Correlations', on_press=lambda button: viewHyperparameterCorrelations()), 'body', focus_attr='focus'), urwid.AttrWrap(urwid.Button( 'Export Best Hyperparameters to File', on_press=lambda button: exportBestParameters()), 'body', focus_attr='focus'), urwid.AttrWrap(urwid.Button('Exit', on_press=onExitClicked), 'body', focus_attr='focus') ] listbox = urwid.ListBox(urwid.SimpleFocusListWalker(content)) menu = makeMountedFrame(urwid.AttrWrap(listbox, 'body'), header='Hypermax v0.1') return menu def makeGraphArea(): nonlocal graph, graphVscale, graphColumns graph = urwid.BarGraph(attlist=['graph_bg', 'graph_bar']) graph.set_data([], top=1) labels = [[i, '{:.3f}'.format(i)] for i in numpy.arange(0.0, 1.0, 0.01)] graphVscale = urwid.AttrWrap(urwid.GraphVScale(labels=labels, top=1), 'graph_label') graphColumns = urwid.Columns([ (7, urwid.Padding(graphVscale, left=0, right=1)), graph, (7, urwid.Padding(graphVscale, left=1, right=0)) ]) graphFrame = makeMountedFrame(graphColumns, 'Rolling Loss') return graphFrame def makeCurrentTrialsArea(): nonlocal currentTrialsLeft, currentTrialsMiddle, currentTrialsRight currentTrialsLeft = urwid.AttrWrap(urwid.Text(markup=''), 'body') currentTrialsMiddle = urwid.AttrWrap(urwid.Text(markup=''), 'body') currentTrialsRight = urwid.AttrWrap(urwid.Text(markup=''), 'body') columns = urwid.Columns( [currentTrialsLeft, currentTrialsMiddle, currentTrialsRight]) return makeMountedFrame(urwid.Filler(columns), "Current Trials") currentOptimizationParamsLeft = None currentOptimizationParamsMiddle = None currentOptimizationParamsRight = None def makeOptimizationParametersArea(): nonlocal currentOptimizationParamsLeft, currentOptimizationParamsMiddle, currentOptimizationParamsRight currentOptimizationParamsLeft = urwid.AttrWrap(urwid.Text(markup=''), 'body') currentOptimizationParamsMiddle = urwid.AttrWrap( urwid.Text(markup=''), 'body') currentOptimizationParamsRight = urwid.AttrWrap( urwid.Text(markup=''), 'body') columns = urwid.Columns([ currentOptimizationParamsLeft, currentOptimizationParamsMiddle, currentOptimizationParamsRight ]) return makeMountedFrame(urwid.Filler(columns), "Optimization Parameters") optimizationDetailsLeft = None optimizationDetailsRight = None def makeOptimizationDetailsArea(): nonlocal optimizationDetailsLeft, optimizationDetailsRight optimizationDetailsLeft = urwid.AttrWrap(urwid.Text(markup=''), 'body') optimizationDetailsRight = urwid.AttrWrap(urwid.Text(markup=''), 'body') columns = urwid.Columns( [optimizationDetailsLeft, optimizationDetailsRight]) return makeMountedFrame(urwid.Filler(columns), "Optimization Details") def makeCurrentBestArea(): nonlocal currentBestLeft, currentBestRight currentBestLeft = urwid.Text(markup='') currentBestRight = urwid.Text(markup='') columns = urwid.Columns( [currentBestLeft, (1, urwid.Text(markup=' ')), currentBestRight]) return makeMountedFrame( urwid.AttrWrap(urwid.Filler(columns), 'frame_body'), "Current Best") # trialsList = urwid.SimpleFocusListWalker([]) trialsTable = None tableResultsSize = 0 def makeTrialsView(): nonlocal trialsTable # listbox = urwid.ListBox(trialsList) columns = [ # DataTableColumn("uniqueid", width=10, align="right", padding=1), DataTableColumn( "trial", label="Trial", width=6, align="right", attr="body", padding=0 # footer_fn=lambda column, values: sum(v for v in values if v is not None)), ), DataTableColumn( "loss", label="Loss", width=10, align="right", attr="body", padding=0, # footer_fn=lambda column, values: sum(v for v in values if v is not None)), ), DataTableColumn( "time", label="Time", width=6, align="right", attr="body", padding=0 # footer_fn=lambda column, values: sum(v for v in values if v is not None)), ), ] keys = Hyperparameter( optimizer.config.data['hyperparameters']).getFlatParameterNames() for key in sorted(keys): columns.append( DataTableColumn( key[5:], label=key[5:], width=len(key[5:]) + 2, align="right", attr="body", padding=0 # footer_fn=lambda column, values: sum(v for v in values if v is not None)), )) trialsTable = ScrollableDataTable( columns=columns, data=[{}], keepColumns=['trial', 'loss', 'time']) return makeMountedFrame(urwid.AttrWrap(trialsTable, 'body'), 'Trials') currentBestArea = makeCurrentBestArea() columns = urwid.Columns([makeMainMenu(), currentBestArea]) currentTrialsArea = makeCurrentTrialsArea() graphArea = makeGraphArea() trialsArea = makeTrialsView() optimizationParametersArea = makeOptimizationParametersArea() optimizationDetailsArea = makeOptimizationDetailsArea() bottomArea = None def showLossGraph(widget): bottomArea.contents[1] = (graphArea, (urwid.WEIGHT, 1)) def showCurrentTrials(widget): bottomArea.contents[1] = (currentTrialsArea, (urwid.WEIGHT, 1)) def showTrials(widget): bottomArea.contents[1] = (trialsArea, (urwid.WEIGHT, 1)) def showOptimizationParameters(widget): bottomArea.contents[1] = (optimizationParametersArea, (urwid.WEIGHT, 1)) def showOptimizationDetails(widget): bottomArea.contents[1] = (optimizationDetailsArea, (urwid.WEIGHT, 1)) bottomButtons = urwid.Columns([ urwid.Filler( urwid.Padding(urwid.AttrWrap( urwid.Button('Loss', on_press=showLossGraph), 'tab_buttons'), left=1, right=5)), urwid.Filler( urwid.Padding(urwid.AttrWrap( urwid.Button('Current Trials', on_press=showCurrentTrials), 'tab_buttons'), left=5, right=5)), urwid.Filler( urwid.Padding(urwid.AttrWrap( urwid.Button('ATPE Parameters', on_press=showOptimizationParameters), 'tab_buttons'), left=5, right=5)), urwid.Filler( urwid.Padding(urwid.AttrWrap( urwid.Button('ATPE Details', on_press=showOptimizationDetails), 'tab_buttons'), left=5, right=5)), urwid.Filler( urwid.Padding(urwid.AttrWrap( urwid.Button('Trials', on_press=showTrials), 'tab_buttons'), left=5, right=1)), ]) bottomArea = urwid.Pile([(2, bottomButtons), graphArea]) background = urwid.Frame( urwid.Pile([ urwid.AttrWrap(columns, 'background'), urwid.AttrWrap(bottomArea, 'background') ])) background = PopupContainer(background, optimizer) popupContainer = background def unhandled(key): if key == 'f8': raise urwid.ExitMainLoop() loop = urwid.MainLoop(background, palette, screen, pop_ups=True, unhandled_input=unhandled) def formatParamVal(value): if isinstance(value, float): return float('{:.4E}'.format(value)) else: return value def splitObjectIntoColumns(obj, num_columns): texts = [""] * num_columns if obj is None: return texts paramKeys = sorted(list(obj.keys())) cutoffs = [] for cutoff in range(num_columns + 1): cutoffs.append(int((len(paramKeys) + 1) * (cutoff) / 3)) for column in range(num_columns): columnKeys = paramKeys[cutoffs[column]:cutoffs[column + 1]] texts[column] += yaml.dump( {key: formatParamVal(obj[key]) for key in columnKeys}, default_flow_style=False) lines = max(*[text.count("\n") for text in texts]) for index in range(len(texts)): texts[index] += "\n" * (lines - texts[index].count("\n")) return tuple(texts) try: loop.start() while True: loop.draw_screen() loop.screen.set_input_timeouts(0.1) keys, raw = loop.screen.get_input(True) keys = loop.input_filter(keys, raw) if keys: loop.process_input(keys) currentTrialsLeftText = "" currentTrialsMiddleText = "" currentTrialsRightText = "" for trial in optimizer.currentTrials: trial = trial leftText, middleText, rightText = splitObjectIntoColumns( trial['params'], 3) runningTime = (datetime.datetime.now() - trial['start']).total_seconds() leftText = "Time: " + str( formatParamVal(runningTime)) + " seconds\n\n" + leftText middleText = "Trial: #" + str( trial['trial']) + " \n\n" + middleText rightText = "\n\n" + rightText currentTrialsLeftText += leftText currentTrialsMiddleText += middleText currentTrialsRightText += rightText currentTrialsLeft.set_text(currentTrialsLeftText) currentTrialsMiddle.set_text(currentTrialsMiddleText) currentTrialsRight.set_text(currentTrialsRightText) optimizationParamsLeftText, optimizationParamsMiddleText, optimizationParamsRightText = splitObjectIntoColumns( optimizer.lastATPEParameters, 3) currentOptimizationParamsLeft.set_text(optimizationParamsLeftText) currentOptimizationParamsMiddle.set_text( optimizationParamsMiddleText) currentOptimizationParamsRight.set_text( optimizationParamsRightText) optimizationDetailsLeftText, optimizationDetailsRightText = splitObjectIntoColumns( optimizer.atpeParamDetails, 2) optimizationDetailsLeft.set_text(optimizationDetailsLeftText) optimizationDetailsRight.set_text(optimizationDetailsRightText) if optimizer.best: paramKeys = [ key for key in optimizer.best.keys() if key not in optimizer.resultInformationKeys ] cutoff = int((len(paramKeys) + 1) / 2) leftParamKeys = paramKeys[:cutoff] rightParamKeys = paramKeys[cutoff:] bestLeftText = yaml.dump( { key: formatParamVal(optimizer.best[key]) for key in leftParamKeys }, default_flow_style=False) bestRightText = yaml.dump( { key: formatParamVal(optimizer.best[key]) for key in rightParamKeys }, default_flow_style=False) bestLeftText += "\n\nLoss: " + str(optimizer.bestLoss) bestRightText += "\n\nTime: " + str( optimizer.best['time']) + " (s)" bestLeftText += "\nTrials: " + str( optimizer.completed()) + "/" + str(optimizer.totalTrials) if optimizer.resultsAnalyzer.totalCharts > 0 and optimizer.resultsAnalyzer.completedCharts < optimizer.resultsAnalyzer.totalCharts: bestRightText += "\nCharts: " + str( optimizer.resultsAnalyzer.completedCharts) + "/" + str( optimizer.resultsAnalyzer.totalCharts) currentBestLeft.set_text(bestLeftText) currentBestRight.set_text(bestRightText) if len(optimizer.results) > 0: numResultsToAdd = max( 0, len(optimizer.results) - tableResultsSize) if numResultsToAdd > 0: resultsToAdd = optimizer.results[-numResultsToAdd:] newResults = [] for result in resultsToAdd: newResult = {} for key in result.keys(): if isinstance(result[key], float): if result[key] > 1e-3: newResult[key] = '{:.3F}'.format( result[key]) else: newResult[key] = '{:.3E}'.format( result[key]) else: newResult[key] = str(result[key]) newResults.append(newResult) trialsTable.append_rows(newResults) trialsTable.apply_filters() tableResultsSize += len(resultsToAdd) if len(optimizer.results) > 1: allResults = numpy.array([ result['loss'] for result in optimizer.results if isinstance(result['loss'], float) ]) windowSize = max(0, min(10, len(allResults) - 10)) allResults = [ numpy.median(allResults[max(0, index - windowSize):index + 1]) for index in range(0, len(allResults), 1) ] top = None bottom = None data = [] for result in allResults[-min(len(allResults), 50):]: data.append([result]) if top is None or result > top: top = result if bottom is None or result < bottom: bottom = result if top is None: top = 1 if bottom is None: bottom = 0 if '{:.3E}'.format(bottom) == '{:.3E}'.format(top): top = bottom + 1 graph_range = top - bottom graph.set_data([[d[0] - bottom] for d in data], graph_range) labels = [[i - bottom, '{:.3f}'.format(i)] for i in numpy.arange(bottom, top, graph_range / 100.0)] graphVscale = urwid.AttrWrap( urwid.GraphVScale(labels=labels, top=graph_range), 'graph_label') graphColumns.contents[0] = (urwid.Padding(graphVscale, left=0, right=1), (urwid.GIVEN, 7, False)) graphColumns.contents[2] = (urwid.Padding(graphVscale, left=1, right=0), (urwid.GIVEN, 7, False)) # if len(optimizer.results) > 0: # if optimizer.results[-1]['status'] != 'ok': # statusText += optimizer.results[-1]['log'] # status.set_text(statusText) except urwid.ExitMainLoop: pass finally: loop.stop()
parser = argparse.ArgumentParser(description="Plots value from database") parser.add_argument("sensor_type", type=str, help="Type of the sensor to be plotted") parser.add_argument("spot_tag", type=str, help="Spot at which the values were measured") args = parser.parse_args() graph = urwid.BarGraph( ["normal", ("bar", "\u2502"), "normal"], ["normal", "barline", "normal"], ) gscale = urwid.GraphVScale([], 0) type_t = urwid.Text(("vals", args.sensor_type), align="right") cur_t = urwid.Text("", align="right") min_t = urwid.Text("", align="right") avg_t = urwid.Text("", align="right") max_t = urwid.Text("", align="right") spot_t = urwid.Text(("vals", args.spot_tag), align="right") stats = urwid.ListBox([ urwid.Text("type"), type_t, urwid.Text("cur"), cur_t, urwid.Text("min"), min_t,