def get_all_data(prefix, domain):
data = None
for stage in range(constants.training_stages):
filename = constants.data_filename(prefix, stage)
if data is None:
data = np.load(filename)
else:
newdata = np.load(filename)
data = np.concatenate((data, newdata), axis=0)
return data
def remember(experiment, occlusion = None, bars_type = None, tolerance = 0):
""" Creates images from features.
Uses the decoder part of the neural networks to (re)create images from features.
Parameters
----------
experiment : TYPE
DESCRIPTION.
occlusion : TYPE, optional
DESCRIPTION. The default is None.
tolerance : TYPE, optional
DESCRIPTION. The default is 0.
Returns
-------
None.
"""
for i in range(constants.training_stages):
testing_data_filename = constants.data_name + constants.testing_suffix
testing_data_filename = constants.data_filename(testing_data_filename, i)
testing_features_filename = constants.features_name(experiment, occlusion, bars_type) + constants.testing_suffix
testing_features_filename = constants.data_filename(testing_features_filename, i)
testing_labels_filename = constants.labels_name + constants.testing_suffix
testing_labels_filename = constants.data_filename(testing_labels_filename, i)
memories_filename = constants.memories_name(experiment, occlusion, bars_type, tolerance)
memories_filename = constants.data_filename(memories_filename, i)
labels_filename = constants.labels_name + constants.memory_suffix
labels_filename = constants.data_filename(labels_filename, i)
model_filename = constants.model_filename(constants.model_name, i)
testing_data = np.load(testing_data_filename)
testing_features = np.load(testing_features_filename)
testing_labels = np.load(testing_labels_filename)
memories = np.load(memories_filename)
labels = np.load(labels_filename)
model = tf.keras.models.load_model(model_filename)
# Drop the classifier.
autoencoder = Model(model.input, model.output[1])
autoencoder.summary()
# Drop the encoder
input_mem = Input(shape=(constants.domain, ))
decoded = get_decoder(input_mem)
decoder = Model(inputs=input_mem, outputs=decoded)
decoder.summary()
for dlayer, alayer in zip(decoder.layers[1:], autoencoder.layers[11:]):
dlayer.set_weights(alayer.get_weights())
produced_images = decoder.predict(testing_features)
n = len(testing_labels)
Parallel(n_jobs=constants.n_jobs, verbose=5)( \
delayed(store_images)(original, produced, constants.testing_directory(experiment, occlusion, bars_type), i, j, label) \
for (j, original, produced, label) in \
zip(range(n), testing_data, produced_images, testing_labels))
total = len(memories)
steps = len(constants.memory_fills)
step_size = int(total/steps)
for j in range(steps):
print('Decoding memory size ' + str(j) + ' and stage ' + str(i))
start = j*step_size
end = start + step_size
mem_data = memories[start:end]
mem_labels = labels[start:end]
produced_images = decoder.predict(mem_data)
Parallel(n_jobs=constants.n_jobs, verbose=5)( \
delayed(store_memories)(label, produced, features, constants.memories_directory(experiment, occlusion, bars_type, tolerance), i, j) \
for (produced, features, label) in zip(produced_images, mem_data, mem_labels))
def obtain_features(model_prefix, features_prefix, labels_prefix, data_prefix,
training_percentage, am_filling_percentage, experiment,
occlusion = None, bars_type = None):
""" Generate features for images.
Uses the previously trained neural networks for generating the features corresponding
to the images. It may introduce occlusions.
"""
stages = constants.training_stages
(data, labels) = get_data(experiment, occlusion, bars_type)
total = len(data)
step = int(total/constants.training_stages)
training_size = int(total*training_percentage)
filling_size = int(total*am_filling_percentage)
testing_size = total - training_size - filling_size
histories = []
for n in range(stages):
i = int(n*step)
j = (i+training_size) % total
training_data = get_data_in_range(data, i, j)
training_labels = get_data_in_range(labels, i, j)
k = (j+filling_size) % total
filling_data = get_data_in_range(data, j, k)
filling_labels = get_data_in_range(labels, j, k)
l = (k+testing_size) % total
testing_data = get_data_in_range(data, k, l)
testing_labels = get_data_in_range(labels, k, l)
# Recreate the exact same model, including its weights and the optimizer
model = tf.keras.models.load_model(constants.model_filename(model_prefix, n))
# Drop the autoencoder and the last layers of the full connected neural network part.
classifier = Model(model.input, model.output[0])
no_hot = to_categorical(testing_labels)
classifier.compile(optimizer='adam', loss='categorical_crossentropy', metrics='accuracy')
history = classifier.evaluate(testing_data, no_hot, batch_size=batch_size, verbose=1, return_dict=True)
print(history)
histories.append(history)
model = Model(classifier.input, classifier.layers[-4].output)
model.summary()
training_features = model.predict(training_data)
if len(filling_data) > 0:
filling_features = model.predict(filling_data)
else:
r, c = training_features.shape
filling_features = np.zeros((0, c))
testing_features = model.predict(testing_data)
dict = {
constants.training_suffix: (training_data, training_features, training_labels),
constants.filling_suffix : (filling_data, filling_features, filling_labels),
constants.testing_suffix : (testing_data, testing_features, testing_labels)
}
for suffix in dict:
data_fn = constants.data_filename(data_prefix+suffix, n)
features_fn = constants.data_filename(features_prefix+suffix, n)
labels_fn = constants.data_filename(labels_prefix+suffix, n)
d, f, l = dict[suffix]
np.save(data_fn, d)
np.save(features_fn, f)
np.save(labels_fn, l)
return histories
def test_recalling(domain,
mem_size,
experiment,
occlusion=None,
bars_type=None,
tolerance=0):
n_memories = constants.n_labels
all_recalls = {}
all_entropies = {}
all_mprecision = {}
all_mrecall = {}
total_precisions = np.zeros(
(constants.training_stages, len(constants.memory_fills)))
total_recalls = np.zeros(
(constants.training_stages, len(constants.memory_fills)))
total_mismatches = np.zeros(
(constants.training_stages, len(constants.memory_fills)))
xlabels = constants.memory_fills
list_results = Parallel(n_jobs=constants.n_jobs, verbose=50)(
delayed(
test_recalling_fold)(n_memories, mem_size, domain, fold,
experiment, occlusion, bars_type, tolerance)
for fold in range(constants.training_stages))
for fold, stage_recalls, stage_entropies, stage_mprecision, stage_mrecall,\
total_precision, total_recall, mismatches in list_results:
all_recalls[fold] = stage_recalls
for msize in stage_entropies:
all_entropies[msize] = all_entropies[msize] + [stage_entropies[msize]] \
if msize in all_entropies.keys() else [stage_entropies[msize]]
all_mprecision[msize] = all_mprecision[msize] + [stage_mprecision[msize]] \
if msize in all_mprecision.keys() else [stage_mprecision[msize]]
all_mrecall[msize] = all_mrecall[msize] + [stage_mrecall[msize]] \
if msize in all_mrecall.keys() else [stage_mrecall[msize]]
total_precisions[fold] = total_precision
total_recalls[fold] = total_recall
total_mismatches[fold] = mismatches
for fold in all_recalls:
list_tups = all_recalls[fold]
tags = []
memories = []
for (idx, label, features) in list_tups:
tags.append((idx, label))
memories.append(np.array(features))
tags = np.array(tags)
memories = np.array(memories)
memories_filename = constants.memories_name(experiment, occlusion,
bars_type, tolerance)
memories_filename = constants.data_filename(memories_filename, fold)
np.save(memories_filename, memories)
tags_filename = constants.labels_name + constants.memory_suffix
tags_filename = constants.data_filename(tags_filename, fold)
np.save(tags_filename, tags)
main_avrge_entropies = get_means(all_entropies)
main_stdev_entropies = get_stdev(all_entropies)
main_avrge_mprecision = get_means(all_mprecision)
main_stdev_mprecision = get_stdev(all_mprecision)
main_avrge_mrecall = get_means(all_mrecall)
main_stdev_mrecall = get_stdev(all_mrecall)
np.savetxt(constants.csv_filename('main_average_precision', experiment,
occlusion, bars_type, tolerance),
main_avrge_mprecision,
delimiter=',')
np.savetxt(constants.csv_filename('main_average_recall', experiment,
occlusion, bars_type, tolerance),
main_avrge_mrecall,
delimiter=',')
np.savetxt(constants.csv_filename('main_average_entropy', experiment,
occlusion, bars_type, tolerance),
main_avrge_entropies,
delimiter=',')
np.savetxt(constants.csv_filename('main_stdev_precision', experiment,
occlusion, bars_type, tolerance),
main_stdev_mprecision,
delimiter=',')
np.savetxt(constants.csv_filename('main_stdev_recall', experiment,
occlusion, bars_type, tolerance),
main_stdev_mrecall,
delimiter=',')
np.savetxt(constants.csv_filename('main_stdev_entropy', experiment,
occlusion, bars_type, tolerance),
main_stdev_entropies,
delimiter=',')
np.savetxt(constants.csv_filename('main_total_recalls', experiment,
occlusion, bars_type, tolerance),
total_recalls,
delimiter=',')
np.savetxt(constants.csv_filename('main_total_mismatches', experiment,
occlusion, bars_type, tolerance),
total_mismatches,
delimiter=',')
plot_pre_graph(main_avrge_mprecision * 100,
main_avrge_mrecall * 100,
main_avrge_entropies,
main_stdev_mprecision * 100,
main_stdev_mrecall * 100,
main_stdev_entropies,
'recall-',
xlabels=xlabels,
xtitle=_('Percentage of memory corpus'),
action=experiment,
occlusion=occlusion,
bars_type=bars_type,
tolerance=tolerance)
plot_pre_graph(np.average(total_precisions, axis=0) * 100,
np.average(total_recalls, axis=0) * 100,
main_avrge_entropies,
np.std(total_precisions, axis=0) * 100,
np.std(total_recalls, axis=0) * 100,
main_stdev_entropies,
'total_recall-',
xlabels=xlabels,
xtitle=_('Percentage of memory corpus'),
action=experiment,
occlusion=occlusion,
bars_type=bars_type,
tolerance=tolerance)
print('Test completed')
def test_recalling_fold(n_memories,
mem_size,
domain,
fold,
experiment,
occlusion=None,
bars_type=None,
tolerance=0):
# Create the required associative memories.
ams = dict.fromkeys(range(n_memories))
for j in ams:
ams[j] = AssociativeMemory(domain, mem_size, tolerance)
suffix = constants.filling_suffix
filling_features_filename = constants.features_name() + suffix
filling_features_filename = constants.data_filename(
filling_features_filename, fold)
filling_labels_filename = constants.labels_name + suffix
filling_labels_filename = constants.data_filename(filling_labels_filename,
fold)
suffix = constants.testing_suffix
testing_features_filename = constants.features_name(
experiment, occlusion, bars_type) + suffix
testing_features_filename = constants.data_filename(
testing_features_filename, fold)
testing_labels_filename = constants.labels_name + suffix
testing_labels_filename = constants.data_filename(testing_labels_filename,
fold)
filling_features = np.load(filling_features_filename)
filling_labels = np.load(filling_labels_filename)
testing_features = np.load(testing_features_filename)
testing_labels = np.load(testing_labels_filename)
filling_max = filling_features.max()
testing_max = testing_features.max()
fillin_min = filling_features.min()
testing_min = testing_features.min()
maximum = filling_max if filling_max > testing_max else testing_max
minimum = fillin_min if fillin_min < testing_min else testing_min
total = len(filling_features)
percents = np.array(constants.memory_fills)
steps = np.round(total * percents / 100.0).astype(int)
stage_recalls = []
stage_entropies = {}
stage_mprecision = {}
stage_mrecall = {}
total_precisions = []
total_recalls = []
mismatches = []
i = 0
for j in range(len(steps)):
k = steps[j]
features = filling_features[i:k]
labels = filling_labels[i:k]
recalls, measures, entropies, total_precision, total_recall, mis_count = get_recalls(
ams, mem_size, domain, minimum, maximum, features, labels,
testing_features, testing_labels, fold)
# A list of tuples (position, label, features)
stage_recalls += recalls
# An array with entropies per memory
stage_entropies[j] = entropies
# An array with precision per memory
stage_mprecision[j] = measures[constants.precision_idx, :]
# An array with recall per memory
stage_mrecall[j] = measures[constants.recall_idx, :]
#
# Recalls and precisions per step
total_recalls.append(total_recall)
total_precisions.append(total_precision)
i = k
mismatches.append(mis_count)
return fold, stage_recalls, stage_entropies, stage_mprecision, \
stage_mrecall, np.array(total_precisions), np.array(
total_recalls), np.array(mismatches)
def test_memories(domain, experiment):
average_entropy = []
stdev_entropy = []
average_precision = []
stdev_precision = []
average_recall = []
stdev_recall = []
all_precision = []
all_recall = []
no_response = []
no_correct_response = []
no_correct_chosen = []
correct_chosen = []
total_responses = []
labels_x_memory = constants.labels_per_memory[experiment]
n_memories = int(constants.n_labels / labels_x_memory)
for i in range(constants.training_stages):
gc.collect()
suffix = constants.filling_suffix
training_features_filename = constants.features_name(
experiment) + suffix
training_features_filename = constants.data_filename(
training_features_filename, i)
training_labels_filename = constants.labels_name + suffix
training_labels_filename = constants.data_filename(
training_labels_filename, i)
suffix = constants.testing_suffix
testing_features_filename = constants.features_name(
experiment) + suffix
testing_features_filename = constants.data_filename(
testing_features_filename, i)
testing_labels_filename = constants.labels_name + suffix
testing_labels_filename = constants.data_filename(
testing_labels_filename, i)
training_features = np.load(training_features_filename)
training_labels = np.load(training_labels_filename)
testing_features = np.load(testing_features_filename)
testing_labels = np.load(testing_labels_filename)
measures_per_size = np.zeros(
(len(constants.memory_sizes), n_memories, constants.n_measures),
dtype=np.float64)
# An entropy value per memory size and memory.
entropies = np.zeros((len(constants.memory_sizes), n_memories),
dtype=np.float64)
behaviours = np.zeros(
(len(constants.memory_sizes), constants.n_behaviours))
print('Train the different co-domain memories -- NxM: ', experiment,
' run: ', i)
# Processes running in parallel.
list_measures_entropies = Parallel(
n_jobs=constants.n_jobs,
verbose=50)(delayed(get_ams_results)(
midx, msize, domain, labels_x_memory, training_features,
testing_features, training_labels, testing_labels)
for midx, msize in enumerate(constants.memory_sizes))
for j, measures, entropy, behaviour in list_measures_entropies:
measures_per_size[j, :, :] = measures.T
entropies[j, :] = entropy
behaviours[j, :] = behaviour
##########################################################################################
# Calculate precision and recall
precision = np.zeros((len(constants.memory_sizes), n_memories + 2),
dtype=np.float64)
recall = np.zeros((len(constants.memory_sizes), n_memories + 2),
dtype=np.float64)
for j, s in enumerate(constants.memory_sizes):
precision[j, 0:n_memories] = measures_per_size[
j, :, constants.precision_idx]
precision[j, constants.mean_idx(n_memories)] = measures_per_size[
j, :, constants.precision_idx].mean()
precision[j, constants.std_idx(n_memories)] = measures_per_size[
j, :, constants.precision_idx].std()
recall[j, 0:n_memories] = measures_per_size[j, :,
constants.recall_idx]
recall[j, constants.mean_idx(n_memories)] = measures_per_size[
j, :, constants.recall_idx].mean()
recall[j, constants.std_idx(n_memories)] = measures_per_size[
j, :, constants.recall_idx].std()
###################################################################3##
# Measures by memory size
# Average entropy among al digits.
average_entropy.append(entropies.mean(axis=1))
stdev_entropy.append(entropies.std(axis=1))
# Average precision as percentage
average_precision.append(
precision[:, constants.mean_idx(n_memories)] * 100)
stdev_precision.append(precision[:, constants.std_idx(n_memories)] *
100)
# Average recall as percentage
average_recall.append(recall[:, constants.mean_idx(n_memories)] * 100)
stdev_recall.append(recall[:, constants.std_idx(n_memories)] * 100)
all_precision.append(behaviours[:, constants.precision_idx] * 100)
all_recall.append(behaviours[:, constants.recall_idx] * 100)
no_response.append(behaviours[:, constants.no_response_idx])
no_correct_response.append(
behaviours[:, constants.no_correct_response_idx])
no_correct_chosen.append(behaviours[:,
constants.no_correct_chosen_idx])
correct_chosen.append(behaviours[:, constants.correct_response_idx])
total_responses.append(behaviours[:, constants.mean_responses_idx])
average_precision = np.array(average_precision)
stdev_precision = np.array(stdev_precision)
main_average_precision = []
main_stdev_precision = []
average_recall = np.array(average_recall)
stdev_recall = np.array(stdev_recall)
main_average_recall = []
main_stdev_recall = []
all_precision = np.array(all_precision)
main_all_average_precision = []
main_all_stdev_precision = []
all_recall = np.array(all_recall)
main_all_average_recall = []
main_all_stdev_recall = []
average_entropy = np.array(average_entropy)
stdev_entropy = np.array(stdev_entropy)
main_average_entropy = []
main_stdev_entropy = []
no_response = np.array(no_response)
no_correct_response = np.array(no_correct_response)
no_correct_chosen = np.array(no_correct_chosen)
correct_chosen = np.array(correct_chosen)
total_responses = np.array(total_responses)
main_no_response = []
main_no_correct_response = []
main_no_correct_chosen = []
main_correct_chosen = []
main_total_responses = []
main_total_responses_stdev = []
for i in range(len(constants.memory_sizes)):
main_average_precision.append(average_precision[:, i].mean())
main_average_recall.append(average_recall[:, i].mean())
main_average_entropy.append(average_entropy[:, i].mean())
main_stdev_precision.append(stdev_precision[:, i].mean())
main_stdev_recall.append(stdev_recall[:, i].mean())
main_stdev_entropy.append(stdev_entropy[:, i].mean())
main_all_average_precision.append(all_precision[:, i].mean())
main_all_stdev_precision.append(all_precision[:, i].std())
main_all_average_recall.append(all_recall[:, i].mean())
main_all_stdev_recall.append(all_recall[:, i].std())
main_no_response.append(no_response[:, i].mean())
main_no_correct_response.append(no_correct_response[:, i].mean())
main_no_correct_chosen.append(no_correct_chosen[:, i].mean())
main_correct_chosen.append(correct_chosen[:, i].mean())
main_total_responses.append(total_responses[:, i].mean())
main_total_responses_stdev.append(total_responses[:, i].std())
main_behaviours = [
main_no_response, main_no_correct_response, main_no_correct_chosen,
main_correct_chosen, main_total_responses
]
np.savetxt(constants.csv_filename(
'main_average_precision--{0}'.format(experiment)),
main_average_precision,
delimiter=',')
np.savetxt(constants.csv_filename(
'main_all_average_precision--{0}'.format(experiment)),
main_all_average_precision,
delimiter=',')
np.savetxt(constants.csv_filename(
'main_average_recall--{0}'.format(experiment)),
main_average_recall,
delimiter=',')
np.savetxt(constants.csv_filename(
'main_all_average_recall--{0}'.format(experiment)),
main_all_average_recall,
delimiter=',')
np.savetxt(constants.csv_filename(
'main_average_entropy--{0}'.format(experiment)),
main_average_entropy,
delimiter=',')
np.savetxt(constants.csv_filename(
'main_stdev_precision--{0}'.format(experiment)),
main_stdev_precision,
delimiter=',')
np.savetxt(constants.csv_filename(
'main_all_stdev_precision--{0}'.format(experiment)),
main_all_stdev_precision,
delimiter=',')
np.savetxt(constants.csv_filename(
'main_stdev_recall--{0}'.format(experiment)),
main_stdev_recall,
delimiter=',')
np.savetxt(constants.csv_filename(
'main_all_stdev_recall--{0}'.format(experiment)),
main_all_stdev_recall,
delimiter=',')
np.savetxt(constants.csv_filename(
'main_stdev_entropy--{0}'.format(experiment)),
main_stdev_entropy,
delimiter=',')
np.savetxt(constants.csv_filename(
'main_behaviours--{0}'.format(experiment)),
main_behaviours,
delimiter=',')
plot_pre_graph(main_average_precision,
main_average_recall,
main_average_entropy,
main_stdev_precision,
main_stdev_recall,
main_stdev_entropy,
action=experiment)
plot_pre_graph(main_all_average_precision,
main_all_average_recall,
main_average_entropy,
main_all_stdev_precision,
main_all_stdev_recall,
main_stdev_entropy,
'overall',
action=experiment)
plot_size_graph(main_total_responses,
main_total_responses_stdev,
action=experiment)
plot_behs_graph(main_no_response,
main_no_correct_response,
main_no_correct_chosen,
main_correct_chosen,
action=experiment)
print('Test complete')
def test_recalling(domain,
mem_size,
experiment,
occlusion=None,
bars_type=None,
tolerance=0):
n_memories = constants.n_labels
memory_fills = constants.memory_fills
training_stages = constants.training_stages
# All recalls, per memory fill and fold.
all_recalls = {}
# All entropies, precision, and recall, per fold, fill, and memory.
all_mfill_entropies = \
np.zeros((training_stages, len(memory_fills), n_memories))
all_mfill_precision = \
np.zeros((training_stages, len(memory_fills), n_memories))
all_mfill_recall = \
np.zeros((training_stages, len(memory_fills), n_memories))
# Store the matrix of stages x memory fills.
total_precisions = np.zeros((training_stages, len(memory_fills)))
total_recalls = np.zeros((training_stages, len(memory_fills)))
total_mismatches = np.zeros((training_stages, len(memory_fills)))
list_results = Parallel(n_jobs=constants.n_jobs, verbose=50)(
delayed(test_recalling_fold)(n_memories, mem_size, domain, fold, experiment, occlusion, bars_type, tolerance) \
for fold in range(constants.training_stages))
for fold, recalls, fill_mem_entropies, fill_mem_precision, fill_mem_recall,\
fold_precision, fold_recall, fold_mismatches in list_results:
all_recalls[fold] = recalls
total_precisions[fold] = fold_precision
total_recalls[fold] = fold_recall
total_mismatches[fold] = fold_mismatches
all_mfill_entropies[fold] = fill_mem_entropies
all_mfill_precision[fold] = fill_mem_precision
all_mfill_recall[fold] = fill_mem_recall
for fold in all_recalls:
list_tups = all_recalls[fold]
tags = []
memories = []
for (idx, label, features) in list_tups:
tags.append((idx, label))
memories.append(np.array(features))
tags = np.array(tags)
memories = np.array(memories)
memories_filename = constants.memories_name(experiment, occlusion,
bars_type, tolerance)
memories_filename = constants.data_filename(memories_filename, fold)
np.save(memories_filename, memories)
tags_filename = constants.labels_name + constants.memory_suffix
tags_filename = constants.data_filename(tags_filename, fold)
np.save(tags_filename, tags)
main_avrge_entropies = np.mean(all_mfill_entropies, axis=(0, 2))
main_stdev_entropies = np.std(all_mfill_entropies, axis=(0, 2))
main_avrge_mprecision = np.mean(all_mfill_precision, axis=(0, 2))
main_stdev_mprecision = np.std(all_mfill_precision, axis=(0, 2))
main_avrge_mrecall = np.mean(all_mfill_recall, axis=(0, 2))
main_stdev_mrecall = np.std(all_mfill_recall, axis=(0, 2))
np.savetxt(constants.csv_filename('main_average_precision',experiment, occlusion, bars_type, tolerance), \
main_avrge_mprecision, delimiter=',')
np.savetxt(constants.csv_filename('main_average_recall',experiment, occlusion, bars_type, tolerance), \
main_avrge_mrecall, delimiter=',')
np.savetxt(constants.csv_filename('main_average_entropy',experiment, occlusion, bars_type, tolerance), \
main_avrge_entropies, delimiter=',')
np.savetxt(constants.csv_filename('main_stdev_precision',experiment, occlusion, bars_type, tolerance), \
main_stdev_mprecision, delimiter=',')
np.savetxt(constants.csv_filename('main_stdev_recall',experiment, occlusion, bars_type, tolerance), \
main_stdev_mrecall, delimiter=',')
np.savetxt(constants.csv_filename('main_stdev_entropy',experiment, occlusion, bars_type, tolerance), \
main_stdev_entropies, delimiter=',')
np.savetxt(constants.csv_filename('main_total_recalls',experiment, occlusion, bars_type, tolerance), \
total_recalls, delimiter=',')
np.savetxt(constants.csv_filename('main_total_mismatches',experiment, occlusion, bars_type, tolerance), \
total_mismatches, delimiter=',')
plot_pre_graph(main_avrge_mprecision*100, main_avrge_mrecall*100, main_avrge_entropies,\
main_stdev_mprecision*100, main_stdev_mrecall*100, main_stdev_entropies, 'recall-', \
xlabels = constants.memory_fills, xtitle = _('Percentage of memory corpus'), action = experiment,
occlusion = occlusion, bars_type = bars_type, tolerance = tolerance)
plot_pre_graph(np.average(total_precisions, axis=0)*100, np.average(total_recalls, axis=0)*100, \
main_avrge_entropies, np.std(total_precisions, axis=0)*100, np.std(total_recalls, axis=0)*100, \
main_stdev_entropies, 'total_recall-', \
xlabels = constants.memory_fills, xtitle = _('Percentage of memory corpus'), action=experiment,
occlusion = occlusion, bars_type = bars_type, tolerance = tolerance)
print('Test completed')
def obtain_features(model_prefix,
features_prefix,
labels_prefix,
data_prefix,
training_percentage,
am_filling_percentage,
experiment,
occlusion=None,
bars_type=None):
""" Generate features for images.
Uses the previously trained neural networks for generating the features corresponding
to the images. It may introduce occlusions.
"""
(data, labels) = get_data(experiment, occlusion, bars_type)
total = len(data)
step = int(total / constants.training_stages)
# Amount of data used for training the networks
trdata = int(total * training_percentage)
# Amount of data used for testing memories
tedata = step
n = 0
histories = []
for i in range(0, total, step):
j = (i + tedata) % total
if j > i:
testing_data = data[i:j]
testing_labels = labels[i:j]
other_data = np.concatenate((data[0:i], data[j:total]), axis=0)
other_labels = np.concatenate((labels[0:i], labels[j:total]),
axis=0)
training_data = other_data[:trdata]
training_labels = other_labels[:trdata]
filling_data = other_data[trdata:]
filling_labels = other_labels[trdata:]
else:
testing_data = np.concatenate((data[0:j], data[i:total]), axis=0)
testing_labels = np.concatenate((labels[0:j], labels[i:total]),
axis=0)
training_data = data[j:j + trdata]
training_labels = labels[j:j + trdata]
filling_data = data[j + trdata:i]
filling_labels = labels[j + trdata:i]
# Recreate the exact same model, including its weights and the optimizer
model = tf.keras.models.load_model(
constants.model_filename(model_prefix, n))
# Drop the autoencoder and the last layers of the full connected neural network part.
classifier = Model(model.input, model.output[0])
no_hot = to_categorical(testing_labels)
classifier.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics='accuracy')
history = classifier.evaluate(testing_data,
no_hot,
batch_size=batch_size,
verbose=1,
return_dict=True)
print(history)
histories.append(history)
model = Model(classifier.input, classifier.layers[-4].output)
model.summary()
training_features = model.predict(training_data)
if len(filling_data) > 0:
filling_features = model.predict(filling_data)
else:
r, c = training_features.shape
filling_features = np.zeros((0, c))
testing_features = model.predict(testing_data)
dict = {
constants.training_suffix:
(training_data, training_features, training_labels),
constants.filling_suffix:
(filling_data, filling_features, filling_labels),
constants.testing_suffix:
(testing_data, testing_features, testing_labels)
}
for suffix in dict:
data_fn = constants.data_filename(data_prefix + suffix, n)
features_fn = constants.data_filename(features_prefix + suffix, n)
labels_fn = constants.data_filename(labels_prefix + suffix, n)
d, f, l = dict[suffix]
np.save(data_fn, d)
np.save(features_fn, f)
np.save(labels_fn, l)
n += 1
return histories
