def display_grabvars( self, grabbed_vals, grabbed_vars, step=1, ): try: names = [x.name for x in grabbed_vars] except Exception as e: names = [grabbed_vars] fig_index = 0 for i, v in enumerate(grabbed_vals): if type(v) == np.ndarray and len( v.shape) > 1: # If v is a matrix, use hinton plotting TFT.hinton_plot(v, fig=self.grabvar_figures[fig_index], title=names[i] + ' at step ' + str(step)) fig_index += 1 else: v = np.array([v]) if type(v) == np.ndarray and len( v.shape) > 1: # If v is a matrix, use hinton plotting TFT.hinton_plot(v, fig=self.grabvar_figures[fig_index], title=names[i] + ' at step ' + str(step)) fig_index += 1
def do_mapping(self, numCases=15, msg="Mapping"): names = [x.name for x in self.grabvars] self.reopen_current_session() tCases = self.case_manager.get_training_cases() cases = [] mapList = [] for i in range(0, numCases): print(i) cases.append(tCases[i]) inputs = [c[0] for c in cases] targets = [c[1] for c in cases] feeder = {self.input: inputs, self.target: targets} result = self.current_session.run([self.output, self.grabvars], feed_dict=feeder) for i, v in enumerate(result[1]): if type(v) == np.ndarray and len( v.shape) > 1: # If v is a matrix, use hinton plotting TFT.hinton_plot(v, fig=self.grabvar_figures[i], title=names[i]) else: print("\n\n") print(names[i]) print(v, end="\n\n") self.close_current_session(view=False)
def do_mapping(self, map_layers, number_of_cases, bestk): self.reopen_current_session() test_cases = self.caseman.get_training_cases() cases = test_cases[:number_of_cases] inputs = [c[0] for c in cases] targets = [c[1] for c in cases] feeder = {self.input: inputs, self.target: targets} grabvar_names = [grabvar for grabvar in self.grabvars] grabvar_layers = [] for layer in map_layers: for grabvar in grabvar_names: if ('-'+str(layer)+'-out') in str(grabvar.name): grabvar_layers.append(grabvar) for grabvar in grabvar_layers: features = [] for index, case in enumerate(cases): self.test_func = self.predictor if bestk is not None: self.test_func = self.gen_match_counter(self.predictor, [TFT.one_hot_to_int(list(v)) for v in targets], k=bestk) testres, grabvals, _ = self.run_one_step(self.test_func, grabvar, self.probes, session=self.current_session, feed_dict=feeder, show_interval=self.show_interval, step=self.global_training_step) features.append(grabvals[index]) TFT.hinton_plot(np.array(features), fig=PLT.figure(), title=grabvar.name + " Activation Levels") new_target = np.array(targets) TFT.hinton_plot(new_target, fig=PLT.figure(), title="Input Targets")
def display_grabvars(self, grabbed_vals, grabbed_vars, step=1): names = [x.name for x in grabbed_vars] msg = "Grabbed Variables at Step " + str(step) # print("\n" + msg, end="\n") for i, v in enumerate(grabbed_vals): if names: print(" " + names[i] + " = ", end="\n") if type(v) == np.ndarray and len( v.shape) > 1 and ('out' not in str( names[i])): # If v is a matrix, use hinton plotting TFT.hinton_plot(v, fig=PLT.figure(), title=names[i] + ' at step ' + str(step)) elif 'bias' in str(names[i]): fig = PLT.figure() v_list = v.tolist() v_length = len(v_list) x_axis = list(range(1, v_length + 1)) PLT.plot(x_axis, v_list, 'ro') for a, b in zip(x_axis, v_list): PLT.text(a, b, str(round(b, 6))) PLT.title("Bias at step: " + str(step) + " for layer " + names[i]) PLT.xlabel("Node") PLT.ylabel("Value") PLT.draw() PLT.pause(0.1) else: # print(v, end="\n\n") pass
def display_grabvars(self, grabbed_vals, grabbed_vars, step=1): if self.dendrogramLayers: grabbed_vars = grabbed_vars[:len(self.wantedMapGrabvars)] grabbed_vals = grabbed_vals[:len(self.wantedMapGrabvars)] names = [x.name for x in grabbed_vars] msg = "Grabbed Variables at Step " + str(step) print("\n" + msg, end="\n") fig_index = 0 for i, v in enumerate(grabbed_vals): if names: print(" " + names[i] + " = ", end="\n") if type(v) == np.ndarray and len( v.shape) > 1: # If v is a matrix, use hinton plotting if 'wgt' in names[i] and self.wgtMatrix: TFT.display_matrix(v, fig=self.grabvar_figures[fig_index], title=names[i] + ' at step ' + str(step)) else: TFT.hinton_plot(v, fig=self.grabvar_figures[fig_index], title=names[i] + ' at step ' + str(step)) fig_index += 1 else: print(v, end="\n\n")
def display_grabvars(self, grabbed_vals, grabbed_vars, step=1): names = [x.name for x in grabbed_vars] msg = "Grabbed Variables at Step " + str(step) #print("\n" + msg, end="\n") fig_index = 0 for i, v in enumerate(grabbed_vals): if names: print(" " + names[i] + " = ", end="\n") if type(v) == np.ndarray and len(v.shape) > 1: # If v is a matrix, use hinton plotting TFT.hinton_plot(v,fig=self.grabvar_figures[fig_index],title= names[i]+ ' at step '+ str(step)) fig_index += 1 else: print(v, end="\n\n")
def do_mapping(self, session=None, scatter=True, mbs=100, testset="mapping", mapbs=10, numeric=False): sess = session if session else self.current_session grabvars = [self.input, self.predictor] grabvars += self.mapvars randNum = random.randint(0, len(self.training_cases) - mapbs) cases = self.training_cases[randNum:randNum + mapbs] inputs = [c[0] for c in cases] targets = [c[1] for c in cases] predictions = [] feeder = {self.input: inputs, self.target: targets} _, grabvals, _ = self.run_one_step([self.predictor], grabvars, session=sess, feed_dict=feeder, show_interval=None) for val in grabvals[1]: predictions.append(val) fig_index = 0 names = [x.name for x in grabvars[2:-len(self.dendrogram_layers)]] for grabval in grabvals[2:-len(self.dendrogram_layers)]: if (type(grabval[0]) != np.ndarray): grabval = np.array([[c] for c in grabval]) if numeric: TFT.display_matrix(grabval, fig=self.mapvar_figures[fig_index], title=names[fig_index]) else: TFT.hinton_plot(grabval, fig=self.mapvar_figures[fig_index], title=names[fig_index]) fig_index += 1 input_strings = [TFT.bits_to_str(i) for i in inputs] target_strings = [TFT.bits_to_str(i) for i in targets] for dendro_vals in grabvals[-len(self.dendrogram_layers):]: TFT.dendrogram(dendro_vals, target_strings) a = input()
def displayGrabvars(self, grabbedVals, grabbedVars, step = 1): names = [x.name for x in grabbedVars]; msg = "Grabbed Variables at Step " + str(step) print("\n" + msg, end = "\n") figIndex = 0 for i, v in enumerate(grabbedVars): if names: print(" " + names[i] + " = ", end="\n"): tft.hinton_plot(v, fig = self.grabvarFigures[figIndex], title = names[i] + ' at step ' + str(step)) figIndex += 1 else: print(v, end="\n\n")
def run_mapping(self, case_generator = None, mapBatchSize = 0, mapLayers = [], mapDendrograms = []): self.mapBatchSize = mapBatchSize # Size of batch of cases used for a map test. 0 indicates no map test self.mapLayers = mapLayers # List of layers(their indices) to be visualized during a map test self.mapDendrograms = mapDendrograms # List of layers(their indices) whose activation patterns will be used to make dendrograms self.reopen_current_session() if self.mapBatchSize: # either a chosen set of cases or a random subset of the training cases: cases = case_generator() if case_generator else self.caseMan.get_mapping_cases(self.mapBatchSize) # Add the monitored variables self.add_mapvars() self.add_dendrogramvars() # Add all grabbed variables for weight in self.displayWeights: self.add_grabvar(weight, 'wgt') for bias in self.displayBiases: self.add_grabvar(bias, 'bias') # run map test mapvals, dendrovals, grabvals = self.do_mapping(session = self.current_session, cases = cases) # Plotting names = [x.name for x in self.mapVars] for i, v in enumerate(mapvals): if type(v) == np.ndarray and len(v.shape) > 1: # If v is a matrix, use hinton plotting TFT.hinton_plot(v, fig=None, title='Activation pattern of layer ' + names[i]) if len(self.mapDendrograms) > 0: names = [x.name for x in self.dendrogramVars] if TFT.is_bit_vector(cases[0][0]): labels = [TFT.bits_to_str(s[0]) for s in cases] else: labels = [TFT.one_hot_to_int(c[1]) for c in cases] for (i, v) in enumerate(dendrovals): TFT.dendrogram(v, labels, title = 'Dendrogram of ' + names[i]) if len(grabvals) > 0: self.display_grabvars(grabvals, self.grabVars, step = self.globalTrainingStep) # hold until a button is pressed while (not PLT.waitforbuttonpress()): pass PLT.close('all')
def display_mapvars(self, grabbed_vals, grabbed_vars, mode='h', cases=None): names = [x.name for x in grabbed_vars] fig_index = 0 for i, v in enumerate(grabbed_vals): if mode == 'h': # If v is a matrix TFT.hinton_plot(v, fig=self.mapLayer_grabvar_figures[fig_index], title=names[i]) fig_index += 1 elif mode == 'd': # If v is a matrix labels = [] for j in cases: labels.append(''.join(str(e) for e in j[0])) grabbed_vals = grabbed_vals[0].tolist() TFT.dendrogram(grabbed_vals, labels)
def do_mapping(self, sess, cases): #Separate the cases into inputs and targets inputs = [c[0] for c in cases] targets = [c[1] for c in cases] #Getting the value for the label tar = [] for t in targets: tar.append(list(t).index(1)) #Running the network without learning on the map batch feeder = {self.input: inputs, self.target: targets} testres, grabvals, _ = self.run_one_step(self.predictor, self.grabvars, self.probes, session=sess, feed_dict=feeder, show_interval=None) #Putting the names into an array for easier look up names = [x.name for x in self.grabvars] zips = zip(names, grabvals) #Variables to show which num = 0 num2 = 0 #Plotting the different plots for i in zips: if (i[0] in self.Hnames): TFT.hinton_plot(i[1], fig=PLT.figure(), title=i[0] + ' at step ' + str("Test")) if (i[0] in self.Dnames): TFT.dendrogram(i[1], tar, title="dendrogram" + str(i[0])) if (i[0] in self.wnames): fig_wgt = PLT.figure() TFT.display_matrix(i[1], fig=fig_wgt, title=(i[0])) num += 1 if (i[0] in self.bnames): fig_bias = PLT.figure() TFT.display_matrix(np.array([i[1]]), fig=fig_bias, title=(i[0])) num2 += 1
def display_grabvars(self, grabbed_vals, grabbed_vars, step=1): names = [x.name for x in grabbed_vars] msg = "Grabbed Variables at Step " + str(step) #print("\n" + msg, end="\n") fig_index = 0 for i, v in enumerate(grabbed_vals): if (i == 0): continue if type(v) == np.ndarray and len( v.shape) > 1: # If v is a matrix, use hinton plotting fig = self.grabvar_figures[fig_index] if fig == None: print('FIGURE IS NONE') TFT.hinton_plot(v, fig=fig, title=names[i]) fig_index += 1 elif len(v.shape) == 1: fig = self.grabvar_figures[fig_index] if (fig == None): print("FIGURE IS NONE") TFT.hinton_plot(np.array([v]), fig=fig, title=names[i]) fig_index += 1
def display_grabvars(self, grabbed_vals, grabbed_vars, step=1): names = [x.name for x in grabbed_vars] msg = "Grabbed Variables at Step " + str(step) print("\n" + msg, end="\n") fig_index = 0 for i, v in enumerate(grabbed_vals): if names: print(" " + names[i] + " = ", end="\n") if type(v) == np.ndarray and len( v.shape) > 1: # If v is a matrix, use hinton plotting TFT.hinton_plot(v, fig=self.grabvar_figures[fig_index], title=names[i] + ' at step ' + str(step)) #TFT.display_matrix(v,fig=self.grabvar_figures[fig_index],title= names[i]+ ' at step '+ str(step)) fig_index += 1 # Print graphical visialization of the bias vector in the module elif "bias" in names[i]: v = np.array([v]) print("Biases", v) #TFT.display_matrix(v, title=names[i] + ' at step ' + str(step)) TFT.hinton_plot(v, title="Biases: " + names[i]) fig_index += 1 else: print(v, end="\n\n")
output = module[1][1] weights = module[2] biases = module[3] module_vals.append([input, output, weights, biases]) all_module_vals.append(module_vals) #visualization of activation levels (output) for each case in each layer saved_m_index = 0 #mapping only level 1 places values on index 0 for module_index in map_layers: case_number = 0 for case in all_module_vals: output = case[saved_m_index][1] print("displaying mapping activation levels...") output = np.array([output]) TFT.hinton_plot(output, fig=PLT.figure(), title='Activation level module ' + str(module_index) + ': case: ' + str(case_number)) case_number += 1 saved_m_index += 1 #making dendrograms if len(map_dendrograms) > len(map_layers): raise ValueError( 'Custom error: Layers for dendrograms must be mapped via map_layers (len(map_dendrograms) > len(map_layers))' ) saved_m_index = 0 for module_index in map_dendrograms: all_inputs = [] all_outputs = [] for case in all_module_vals: all_inputs.append(case[saved_m_index][0])
def main(): parser = argument_parser.argument_parser() parser.parse() parser.organize() # (self, cases, vfrac, tfrac, casefrac, mapsep) caseman = gann_base.Caseman(parser.data_set_v, parser.vfrac_v, parser.tfrac_v, parser.casefrac_v, parser.mapbs_v) # (self, dims, cman, afunc, ofunc, cfunc, optimizer, lrate, wrange, vint, mbs, usevsi, showint=None): ann = gann_base.Gann(parser.dims_v, caseman, parser.afunc_v, parser.ofunc_v, parser.cfunc_v, parser.optimizer_v, parser.lrate_v, parser.wrange_v, parser.vint_v, parser.mbs_v, parser.usevsi_v, showint=parser.steps_v - 1) for layer in parser.dispw_v: ann.add_grabvar(layer, type='wgt') ann.gen_probe(layer, 'wgt', 'hist') for layer in parser.dispb_v: ann.add_grabvar(layer, type='bias') ann.gen_probe(layer, 'bias', 'hist') # run, then map ann.run(steps=parser.steps_v, sess=None, continued=False, bestk=parser.best1_v) ann.remove_grabvars() for layer in parser.maplayers_v: if layer == 0: ann.add_grabvar(layer, type='in', add_figure=False) else: ann.add_grabvar(layer - 1, type='out', add_figure=False) res, labs = ann.do_mapping() results = [] for i in range(len(res[0])): l = np.array([r[i] for r in res]) l = l.reshape(l.shape[0], l.shape[2]) TFT.hinton_plot(l, title="mapping test output of layer " + str(parser.maplayers_v[i])) results.append(l) for i, r in enumerate(results): # DENDOGRAM # if parser.maplayers_v[i] in parser.mapdend_v: if parser.best1_v: TFT.dendrogram(r, list(map(TFT.one_hot_to_int, labs)), title="Dendrogram " + str(parser.maplayers_v[i])) gann_base.PLT.show() TFT.fireup_tensorboard('probeview')