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')
