def load_dataset(self):
if self.dataset["type"] == "image":
path = os.path.join("Data", "images", self.dataset["file"])
img = Image.open(path)
parameters = Parameters({
"pictures_dim":
[self.dataset["width"], self.dataset["height"]]
})
self.data = MosaicImage(img, parameters)
elif self.dataset["type"] == "random_image":
path = os.path.join("Data", "images", self.dataset["file"])
img = Image.open(path)
parameters = Parameters({
"pictures_dim":
[self.dataset["width"], self.dataset["height"]]
})
self.data = MosaicImage(img, parameters)
self.training_data = RandomImage(img, parameters)
elif self.dataset["type"] == "tracking":
path = os.path.join("Data", "tracking", "dataset",
self.dataset["file"], "back.jpg")
#if self.metadata["seed"] % 2 == 1:
# path = os.path.join("Data", "tracking", "dataset", self.dataset["file"], "input", "bkg.jpg")
#else:
# path = os.path.join("Data", "tracking", "dataset", self.dataset["file"], "input", "bkg2.jpg")
img = Image.open(path)
parameters = Parameters({
"pictures_dim":
[self.dataset["width"], self.dataset["height"]]
})
self.data = MosaicImage(img, parameters)
else:
print("Error : No dataset type specified !")
def learning(self, bkg_image):
# PARAMETERS
self.image_parameters = Parameters({"pictures_dim": self.pictures_dim})
data = MosaicImage(bkg_image, self.image_parameters)
inputs_SOM = Parameters({"alpha": Variable(start=self.alpha_start, end=self.alpha_end, nb_steps=self.nb_epochs),
"sigma": Variable(start=self.sigma_start, end=self.sigma_end, nb_steps=self.nb_epochs),
"data": data.get_data(),
"neurons_nbr": self.neurons_nb,
"epochs_nbr": self.nb_epochs})
self.som = SOM(inputs_SOM)
# RUN
for i in range(self.nb_epochs):
# print('Epoch', i)
self.som.run_epoch()
self.initial_map = self.som.get_all_winners()
def __init__(self,
input_path,
output_path,
supplements_path,
parameters=None):
self.input_path = input_path
self.output_path = output_path
self.supplements_path = supplements_path
if parameters is None:
parameters = Parameters()
self.tau_dt = parameters["tau_dt"] if parameters[
"tau_dt"] is not None else 0.8
self.h = parameters["h"] if parameters["h"] is not None else -0.2
self.gi = parameters["gi"] if parameters["gi"] is not None else 1
self.excitation_amplitude = parameters[
"excitation_amplitude"] if parameters[
"excitation_amplitude"] is not None else 1
self.excitation_sigma = parameters["excitation_sigma"] if parameters[
"excitation_sigma"] is not None else 0.05
self.inhibition_amplitude = parameters[
"inhibition_amplitude"] if parameters[
"inhibition_amplitude"] is not None else 0
self.inhibition_sigma = parameters["inhibition_sigma"] if parameters[
"inhibition_sigma"] is not None else 0.5
self.threshold = parameters["threshold"] if parameters[
"threshold"] is not None else 10
self.step = parameters["step"] if parameters["step"] is not None else 1
def regenerate_database():
global data_types
data_types = {
"spokenDigits":
SpokenDigitsDataset(
"/users/yabernar/workspace/watSOM/Data/FSDD/recordings",
1000).get_data(),
"images":
MosaicImage(
Image.open(
"/users/yabernar/workspace/watSOM/Code/fast_som/Elijah.png"),
Parameters({"pictures_dim": [10, 10]})).get_data(),
"uniform3D":
uniform(1000, 3),
"pixel_colors":
PixelsFromImage(
Image.open(
"/users/yabernar/workspace/watSOM/Code/fast_som/Elijah.png"),
1000).get_data(),
"catShape":
GenerateFromShape(
Image.open(
"/users/yabernar/workspace/watSOM/Code/fast_som/cat-silhouette.png"
), 1000).get_data(),
"uniform2D":
uniform(1000, 2)
}
def evaluate_learning(SOM, data_type, neurons_nbr):
inputs = Parameters({"alpha": Variable(start=0.6, end=0.05, nb_steps=nb_epochs),
"sigma": Variable(start=0.5, end=0.001, nb_steps=nb_epochs),
"data": data_type,
"neurons_nbr": (neurons_nbr, neurons_nbr),
"epochs_nbr": nb_epochs})
som = SOM(inputs)
som.run()
nb_comp = np.mean(som.nbr_quad_dist)
return {"nbr_comparisons": nb_comp, "percentage_calculated": nb_comp/(neurons_nbr**2)*100}
def evaluate_reconstruction(SOM, data_type):
inputs = Parameters({"alpha": Variable(start=0.6, end=0.05, nb_steps=nb_epochs),
"sigma": Variable(start=0.5, end=0.001, nb_steps=nb_epochs),
"data": data_type,
"neurons_nbr": n_nbr,
"epochs_nbr": nb_epochs})
st_som = StandardSOM(inputs)
st_som.run()
som = SOM(inputs)
som.neurons = st_som.neurons
return {"MSQE_R": som.mean_square_quantization_error()}
def runSOM(self):
if self.data is None:
self.load_dataset()
nb_epochs = self.model["nb_epochs"]
if "alpha_start" not in self.model: self.model["alpha_start"] = 0.2
if "alpha_end" not in self.model: self.model["alpha_end"] = 0.05
if "sigma_start" not in self.model: self.model["sigma_start"] = 0.7
if "sigma_end" not in self.model: self.model["sigma_end"] = 0.015
if "nb_images_evals" not in self.dataset:
self.dataset["nb_images_evals"] = 75
parameters = Parameters({
"alpha":
Variable(start=self.model["alpha_start"],
end=self.model["alpha_end"],
nb_steps=nb_epochs),
"sigma":
Variable(start=self.model["sigma_start"],
end=self.model["sigma_end"],
nb_steps=nb_epochs),
"data":
self.data.get_data(),
"neurons_nbr": (self.model["width"], self.model["height"]),
"epochs_nbr":
nb_epochs
})
if self.model["model"] == "standard":
self.map = SOM(parameters)
elif self.model["model"] == "fast":
self.map = FastSOM(parameters)
elif self.model["model"] == "recursive":
self.map = RecursiveSOM(parameters)
else:
print("Error : Unknown model !")
# if "initialisation" not in self.codebooks:
# self.codebooks["initialisation"] = self.som.neurons.tolist()
if "final" in self.codebooks:
self.map.neurons = np.asarray(self.codebooks["final"])
else:
self.map.run()
#for i in range(nb_epochs):
# self.map.run_epoch()
#self.codebooks["final"] = copy.deepcopy(self.map.neurons.tolist())
# for i in range(nb_epochs):
# print("Epoch "+str(i+1))
# if "Epoch "+str(i + 1) not in self.codebooks:
# if self.training_data is not None:
# self.som.data = self.training_data.get_data(self.som.data.shape[0])
# self.som.run_epoch()
# # self.codebooks["Epoch " + str(i + 1)] = copy.deepcopy(self.som.neurons.tolist())
# self.som.run_epoch()
self.map.data = self.data.get_data()
def __init__(self,
input_path,
output_path,
supplements_path,
temporal_ROI,
mask_ROI,
parameters=None):
self.mask = mask_ROI
self.input_path = input_path
self.output_path = output_path
self.supplements_path = supplements_path
self.temporal_ROI = temporal_ROI
if parameters is None:
parameters = Parameters()
self.pictures_dim = parameters["pictures_dim"] if parameters[
"pictures_dim"] is not None else [10, 10]
self.threshold = parameters["threshold"] if parameters[
"threshold"] is not None else 10
self.step = parameters["step"] if parameters[
"step"] is not None else 1 # IF CHANGED, NEED TO CHANGE COMPARATOR TOO
self.cut = parameters["cut"] if parameters["cut"] is not None else 0
self.image_parameters = Parameters({"pictures_dim": self.pictures_dim})
def evaluate(args):
# pic_dim, neuron_nbr, epochs = args
# params = Parameters({"pictures_dim": [int(pic_dim), int(pic_dim)], "neurons_nbr": (int(neuron_nbr), int(neuron_nbr)), "epochs_nbr": int(epochs)})
alpha_start, alpha_end, sigma_start, sigma_end = args
params = Parameters({
"alpha_start": alpha_start,
"alpha_end": alpha_end,
"sigma_start": sigma_start,
"sigma_end": sigma_end
})
print("Tested params : {}".format(params.data))
all_videos = []
categories_list = [1, 3]
categories = sorted([
d for d in os.listdir(cdnet_path)
if os.path.isdir(os.path.join(cdnet_path, d))
],
key=str.lower)
for cat in list(categories[i] for i in categories_list):
elements = sorted([
d for d in os.listdir(os.path.join(cdnet_path, cat))
if os.path.isdir(os.path.join(cdnet_path, cat, d))
],
key=str.lower)
for elem in elements:
all_videos.append(os.path.join(cat, elem))
# pool = mp.Pool(8)
# pool.starmap(process_video, zip(all_videos, itertools.repeat(params)))
# pool.close()
# pool.join()
#
# cmp = Comparator()
# fitness = cmp.evaluate_all(cdnet_path, output_path, categories_list)
pool = mp.Pool(8)
results = pool.starmap(process_bkg,
zip(all_videos, itertools.repeat(params)))
print(results)
pool.close()
pool.join()
fitness = np.mean(np.asarray(results))
print("Measured fitness : {}\n".format(fitness))
return fitness
def compute_metrics(self):
self.metrics["Square_error"] = self.map.square_error()
if self.model["model"] == "gng":
self.metrics["Neurons"] = len(self.map.network.nodes())
self.metrics["Connections"] = len(self.map.network.edges())
if self.dataset["type"] == "tracking":
current_path = os.path.join("Data", "tracking", "dataset",
self.dataset["file"])
input_path = os.path.join(current_path, "input")
roi_file = open(os.path.join(current_path, "temporalROI.txt"),
"r").readline().split()
temporal_roi = (int(roi_file[0]), int(roi_file[1]))
mask_roi = Image.open(os.path.join(current_path, "ROI.png"))
nb_img_gen = self.dataset["nb_images_evals"]
step = 1
if nb_img_gen > 0:
step = (temporal_roi[1] + 1 - temporal_roi[0]) // nb_img_gen
base = os.path.join("Results", "GNGopti", self.metadata["name"],
"results")
output_path = os.path.join(base, self.dataset["file"])
supplements_path = os.path.join(base, "supplements")
parameters = Parameters({
"pictures_dim":
[self.dataset["width"], self.dataset["height"]],
"step":
step
})
trackingMetric = TrackingMetrics(input_path,
output_path,
supplements_path,
temporal_roi,
mask_roi,
parameters=parameters)
trackingMetric.compute(self.map)
cmp = Comparator()
fmeasure, precision, recall = cmp.evaluate__folder_c(
current_path, output_path, step)
# print(fitness)
self.metrics["fmeasure"] = fmeasure
self.metrics["precision"] = precision
self.metrics["recall"] = recall
def compute_steps_metrics(self):
# self.metrics["Square_error"] = self.som.square_error()
# self.metrics["Neurons"] = len(self.som.network.nodes())
# self.metrics["Connections"] = len(self.som.network.edges())
if self.dataset["type"] == "tracking":
current_path = os.path.join("Data", "tracking", "dataset",
self.dataset["file"])
input_path = os.path.join(current_path, "input")
roi_file = open(os.path.join(current_path, "temporalROI.txt"),
"r").readline().split()
temporal_roi = (int(roi_file[0]), int(roi_file[1]))
mask_roi = Image.open(os.path.join(current_path, "ROI.png"))
base = os.path.join("Results", "GNGoptimisation",
self.metadata["name"], "results")
output_path = os.path.join(base, self.dataset["file"])
supplements_path = os.path.join(base, "supplements")
parameters = Parameters({
"pictures_dim":
[self.dataset["width"], self.dataset["height"]]
})
# ranges = list(range(1, 5)) + list(range(5, 101, 5))
#res = []
#ranges = range(1,201)
#for i in ranges:
# cmp = Comparator()
# fitness = cmp.evaluate__folder_c(current_path, output_path, i)
# res.append(fitness)
#self.metrics["fmeasure-steps"] = res
res = []
nb_image_ranges = range(5, 201)
for i in nb_image_ranges:
step = (temporal_roi[1] + 1 - temporal_roi[0]) // i
cmp = Comparator()
fitness = cmp.evaluate__folder_c(current_path, output_path,
step)
res.append(fitness)
self.metrics["fmeasure-nbimgs"] = res
def __init__(self, input_path, output_path, supplements_path, temporal_ROI, mask_ROI, parameters=None):
self.bkg = Image.open(os.path.join(input_path, "bkg.jpg"))
self.mask = mask_ROI
self.input_path = input_path
self.output_path = output_path
self.supplements_path = supplements_path
self.temporal_ROI = temporal_ROI
if parameters is None:
parameters = Parameters()
self.neurons_nb = parameters["neurons_nbr"] if parameters["neurons_nbr"] is not None else (10, 10)
self.pictures_dim = parameters["pictures_dim"] if parameters["pictures_dim"] is not None else [10, 10]
self.nb_epochs = parameters["nb_epochs"] if parameters["nb_epochs"] is not None else 50
self.alpha_start = parameters["alpha_start"] if parameters["alpha_start"] is not None else 0.09
self.alpha_end = parameters["alpha_end"] if parameters["alpha_end"] is not None else 0.22
self.sigma_start = parameters["sigma_start"] if parameters["sigma_start"] is not None else 0.94
self.sigma_end = parameters["sigma_end"] if parameters["sigma_end"] is not None else 0.56
self.threshold = parameters["threshold"] if parameters["threshold"] is not None else 10
self.step = parameters["step"] if parameters["step"] is not None else 30
def runGNG(self):
if self.data is None:
self.load_dataset()
inputs = Parameters({
"epsilon_winner":
self.model["epsilon_winner"], # 0.1,
"epsilon_neighbour":
self.model["epsilon_neighbour"], # 0.006,
"maximum_age":
self.model["maximum_age"], # 10,
"error_decrease_new_unit":
self.model["error_decrease_new_unit"], # 0.5,
"error_decrease_global":
self.model["error_decrease_global"], # 0.995,
"data":
self.data.get_data(),
"neurons_nbr":
self.model["nb_neurons"],
"epochs_nbr":
self.model["nb_epochs"]
})
self.map = GrowingNeuralGas(inputs)
self.map.run()
def evaluate_learning(SOM, data_type):
inputs = Parameters({
"alpha":
Variable(start=0.6, end=0.05, nb_steps=nb_epochs),
"sigma":
Variable(start=0.5, end=0.001, nb_steps=nb_epochs),
"data":
data_type,
"neurons_nbr":
n_nbr,
"epochs_nbr":
nb_epochs
})
som = SOM(inputs)
som.run()
msqe_r, nb_errors = som.mean_square_quantization_error_secondary()
return {
"MSQE_L": som.mean_square_quantization_error(),
"MSDtN": som.mean_square_distance_to_neighbour(),
"MSQE_R": msqe_r,
"Error Nbr": nb_errors,
"Error %:": nb_errors / data_type.shape[0] * 100
}
def evaluate(args):
tau_dt, h, gi, Ap, Sp = args
params = Parameters({
"tau_dt": tau_dt,
"h": h,
"gi": gi,
"excitation_amplitude": Ap,
"excitation_sigma": Sp
})
print("Tested params : {}".format(params.data))
all_videos = []
categories_list = [1]
categories = sorted([
d for d in os.listdir(input_path)
if os.path.isdir(os.path.join(input_path, d))
],
key=str.lower)
for cat in list(categories[i] for i in categories_list):
elements = sorted([
d for d in os.listdir(os.path.join(input_path, cat))
if os.path.isdir(os.path.join(input_path, cat, d))
],
key=str.lower)
for elem in elements:
all_videos.append(os.path.join(cat, elem))
pool = mp.Pool(8)
pool.starmap(process_video, zip(all_videos, itertools.repeat(params)))
pool.close()
pool.join()
cmp = Comparator()
fitness = 1 - cmp.evaluate_all(cdnet_path, output_path, categories_list)
print("Measured fitness : {}\n".format(fitness))
return fitness
def evaluate(args):
global run_nb
if run_nb > 0:
save_optimisation()
# pic_dim, neuron_nbr, epochs = args
# params = Parameters({"pictures_dim": [int(pic_dim), int(pic_dim)], "neurons_nbr": (int(neuron_nbr), int(neuron_nbr)), "epochs_nbr": int(epochs)})
#alpha_start, alpha_end = args
#sigma_start, sigma_end = (0.7, 0.015)
#params = Parameters({"alpha_start": alpha_start, "alpha_end": alpha_end, "sigma_start": sigma_start, "sigma_end": sigma_end})
epsilon_winner, epsilon_neighbour, maximum_age, error_decrease_new_unit, error_decrease_global, epochs_nbr = args
params = Parameters({
"epsilon_winner": epsilon_winner,
"epsilon_neighbour": epsilon_neighbour,
"maximum_age": maximum_age,
"error_decrease_new_unit": error_decrease_new_unit,
"error_decrease_global": error_decrease_global,
"epochs_nbr": epochs_nbr
})
print("Tested params : {}".format(params.data))
sr = SimulationRun()
sr.create(args)
sr.compute(8)
sr.all_runs = []
sr.open_folder(sr.current_path)
res = []
for i in sr.all_runs:
res.append(i.metrics["fmeasure"])
fitness = 1 - np.mean(np.asarray(res))
run_nb += 1
print("Measured fitness : {}".format([fitness, 1 - fitness]))
return fitness
for i in np.ndindex(winners.shape):
error[i] = np.mean((self.working_data[i] - self.network.nodes[winners[i]]['vector'])**2)
return np.mean(error)
def display(self):
reconstructed = self.img.reconstruct(self.get_reconstructed_data())
# som_image = mosaic.reconstruct(gng.get_neural_list(), size=som.neurons_nbr)
print("Error : ", self.square_error())
print("Neurons : ", len(self.network.nodes()))
print("Connections : ", len(self.network.edges()))
plt.imshow(reconstructed)
plt.show()
if __name__ == '__main__':
img = MosaicImage(Image.open(os.path.join("Data", "Tracking", "Dataset", "baseline", "highway", "bkg.jpg")), Parameters({"pictures_dim": [16, 16]}))
data = img.get_data()
gng = GrowingNeuralGas(data)
gng.img = img
gng.fit_network(e_b=0.1, e_n=0.006, a_max=10, l=200, a=0.5, d=0.995, passes=100, plot_evolution=False)
reconstructed = img.reconstruct(gng.get_reconstructed_data())
# som_image = mosaic.reconstruct(gng.get_neural_list(), size=som.neurons_nbr)
# print(gng.get_all_winners())
plt.imshow(reconstructed)
plt.show()
print(len(gng.network.nodes))
img2 = MosaicImage(Image.open(os.path.join("Data", "Tracking", "Dataset", "baseline", "highway", "input", "in001010.jpg")), Parameters({"pictures_dim": [16, 16]}))
data2 = img2.get_data()
old_winners = gng.get_all_winners()
gng.data = data2
from Code.fast_som.SwarmSOM import SwarmSOM
from Code.fast_som.GreedySOM import GreedySOM
from Code.fast_som.StandardSOM import StandardSOM
from Data.Generated_Data import sierpinski_carpet, uniform
from Data.Generated_from_shape import GenerateFromShape
from Data.Mosaic_Image import MosaicImage
# PARAMETERS
# som_algs = {"standard": StandardSOM, "greedy": GreedySOM, "swarm": SwarmSOM, "fourCorners": FourCornersSOM, "greedyToroidal": GreedyToroidalSOM}
from Data.Pixels_from_Image import PixelsFromImage
from Data.Spoken_digits_dataset import SpokenDigitsDataset
som_algs = {"Fast-SOM": FourCornersSOM, "Fast-Hex": FourCornersSOM_Hex}
data_types = {"spokenDigits": SpokenDigitsDataset("/users/yabernar/workspace/watSOM/Data/FSDD/recordings", 1000).get_data(),
"images": MosaicImage(Image.open("/users/yabernar/workspace/watSOM/Code/fast_som/Elijah.png"), Parameters({"pictures_dim": [10, 10]})).get_data(),
"uniform3D": uniform(1000, 3),
"pixel_colors": PixelsFromImage(Image.open("/users/yabernar/workspace/watSOM/Code/fast_som/Elijah.png"), 1000).get_data(),
"catShape": GenerateFromShape(Image.open("/users/yabernar/workspace/watSOM/Code/fast_som/cat-silhouette.png"), 1000).get_data(),
"uniform2D": uniform(1000, 2)}
neuron_numbers = {"12": (12, 12), "medium": (32, 32), "rectangular": (48, 24)}
n_nbr = (12, 12)
nb_epochs = 10
def regenerate_database():
global data_types
data_types = {"spokenDigits": SpokenDigitsDataset("/users/yabernar/workspace/watSOM/Data/FSDD/recordings", 1000).get_data(),
"images": MosaicImage(Image.open("/users/yabernar/workspace/watSOM/Code/fast_som/Elijah.png"),
Parameters({"pictures_dim": [10, 10]})).get_data(),
"uniform3D": uniform(1000, 3),
error.append(np.mean(np.abs(i)))
return np.mean(error)
def square_error(self):
rec = self.get_reconstructed_data()
diff = rec - self.data
error = []
for i in diff:
error.append(np.mean(i**2))
return np.mean(error)
if __name__ == '__main__':
start = time.time()
img = MosaicImage(Image.open("Data/images/Elijah.png"),
Parameters({"pictures_dim": [10, 10]}))
nb_epochs = 100
inputs = Parameters({
"alpha":
Variable(start=0.6, end=0.05, nb_steps=nb_epochs),
"sigma":
Variable(start=0.5, end=0.001, nb_steps=nb_epochs),
"data":
img.get_data(),
"neurons_nbr": (8, 8),
"epochs_nbr":
nb_epochs
})
som = RecursiveSOM(inputs)
som.run()
error[i] += np.mean((self.neurons[i] - self.neurons[j])**2)
nb_neighbours += 1
error[i] /= nb_neighbours
return np.mean(error)
if __name__ == '__main__':
start = time.time()
nb_epochs = 50
inputs = Parameters({
"alpha":
Variable(start=0.6, end=0.05, nb_steps=nb_epochs),
"sigma":
Variable(start=0.5, end=0.2, nb_steps=nb_epochs),
"data":
uniform(200, 3),
"neurons_nbr": (10, 10),
"epochs_nbr":
nb_epochs
})
som = GreedySOM(inputs)
som.run()
end = time.time()
print("Executed in " + str(end - start) + " seconds.")
print(som.mean_square_quantization_error())
print(som.mean_square_distance_to_neighbour())
# 2 0.000128 0.000151 0.000141 greedy uniform2D
# 3 0.000735 0.019616 0.032234 greedy uniform3D
key=str.lower)
print(categories)
print(elements)
chosen_path = path + "/dataset/" + categories[11] + "/" + elements[0]
temporal_ROI = (1, 200)
plot = None
bkg = Image.open(chosen_path + "/input/" + 'bkg.jpg')
# bkg = Image.open(path2 + video + '{0:05d}.png'.format(1))
# bkg = Image.open(path3 + "example_base.png")
############
# LEARNING #
############
pictures_dim = [10, 10]
parameters = Parameters({"pictures_dim": pictures_dim})
data = MosaicImage(bkg, parameters)
nb_epochs = 50
inputs_SOM = Parameters({
"alpha":
Variable(start=0.5, end=0.25, nb_steps=nb_epochs),
"sigma":
Variable(start=0.1, end=0.03, nb_steps=nb_epochs),
"data":
data.get_data(),
"neurons_nbr": (10, 10),
"epochs_nbr":
nb_epochs
})
som = SOM(inputs_SOM)
for i in range(nb_epochs):
som_algs = {
"standard": StandardSOM,
"fourCorners": FourCornersSOM,
"hexFourCorners": FourCornersSOM_Hex,
"hexSOM": HexSOM
}
data_types = {
"spokenDigits":
SpokenDigitsDataset(
"/users/yabernar/workspace/watSOM/Data/FSDD/recordings",
1000).get_data(),
"images":
MosaicImage(
Image.open(
"/users/yabernar/workspace/watSOM/Code/fast_som/Elijah.png"),
Parameters({"pictures_dim": [10, 10]})).get_data(),
"uniform3D":
uniform(1000, 3),
"pixel_colors":
PixelsFromImage(
Image.open(
"/users/yabernar/workspace/watSOM/Code/fast_som/Elijah.png"),
1000).get_data(),
"catShape":
GenerateFromShape(
Image.open(
"/users/yabernar/workspace/watSOM/Code/fast_som/cat-silhouette.png"
), 1000).get_data(),
"uniform2D":
uniform(1000, 2)
}
count = 0
for i in range(0, size[0] - dim[0], 5):
for j in range(0, size[1] - dim[1], 5):
# print(i,j)
current = data[count]
count += 1
# print(current)
current = current.reshape(dim)
# current = np.rot90(current, 2, (0, 1))
# current = np.flip(current, (0,1))
# print(pixels.shape)
# print(current.shape)
# print(self.pictures_dim)
# print(self.size)
pixels[i:i + dim[1], j:j + dim[1], :] += current
pixels *= (255 / 4)
pixels = np.array(pixels, 'uint8')
return pixels
def get_data(self):
return self.data
def display(self):
return plt.imshow(self.image)
if __name__ == '__main__':
bkg = Image.open("Data/color_test.png")
pictures_dim = [10, 10]
parameters = Parameters({"pictures_dim": pictures_dim})
data = SlidingWindow(bkg, parameters)
error[i] /= nb_neighbours
return np.mean(error)
if __name__ == '__main__':
for n in range(10, 61, 2):
start = time.time()
nb_epochs = 10
inputs = Parameters({
"alpha":
Variable(start=0.6, end=0.05, nb_steps=nb_epochs),
"sigma":
Variable(start=0.5, end=0.2, nb_steps=nb_epochs),
"data":
MosaicImage(
Image.open(
"/users/yabernar/workspace/watSOM/Code/fast_som/Elijah.png"
), Parameters({"pictures_dim": [10, 10]})).get_data(),
"neurons_nbr": (n, n),
"epochs_nbr":
nb_epochs
})
som = FastSOM(inputs)
som.run()
end = time.time()
print("Executed in " + str(end - start) + " seconds.", n, "neurons")
print("MSQE :", som.mean_square_quantization_error(), "MSDtN :",
som.mean_square_distance_to_neighbour())
error[i] = np.mean(np.abs(self.data[i] - self.neurons[winners[i]]))
return np.mean(error)
def square_error(self, winners=None):
if winners is None:
winners = self.get_all_winners()
error = np.zeros(winners.shape)
for i in np.ndindex(winners.shape):
error[i] = np.mean((self.data[i] - self.neurons[winners[i]])**2)
return np.mean(error)
if __name__ == '__main__':
start = time.time()
nb_epochs = 50
inputs = Parameters({"alpha": Variable(start=0.6, end=0.05, nb_steps=nb_epochs),
"sigma": Variable(start=0.5, end=0.001, nb_steps=nb_epochs),
"data": sierpinski_carpet(200),
"neurons_nbr": (10, 10),
"epochs_nbr": nb_epochs})
som = SOM(inputs)
som.run()
end = time.time()
print("Executed in " + str(end - start) + " seconds.")
print(som.mean_error(som.get_all_winners()))
print(som.square_error(som.get_all_winners()))
import os
import numpy as np
from PIL import Image, ImageOps, ImageChops
from Code.Parameters import Parameters, Variable
from Code.SOM import SOM
from Data.Mosaic_Image import MosaicImage
pictures_dim = [10, 10]
name = "office"
path = os.path.join("Data", "spikes", "office", "src")
bkg = Image.open(os.path.join(path, name + "0.png"))
img_parameters = Parameters({"pictures_dim": pictures_dim})
data = MosaicImage(bkg, img_parameters)
nb_epochs = 100
parameters = Parameters({
"alpha":
Variable(start=0.6, end=0.05, nb_steps=nb_epochs),
"sigma":
Variable(start=0.5, end=0.001, nb_steps=nb_epochs),
"data":
data.get_data(),
"neurons_nbr": (10, 10),
"epochs_nbr":
nb_epochs
})
map = SOM(parameters)
for i in range(nb_epochs):
print("Epoch " + str(i + 1))
map.run_epoch()
map.data = data.get_data()
def square_error(self, winners=None):
if winners is None:
winners = self.get_all_winners()
error = np.zeros(winners.shape)
for i in np.ndindex(winners.shape):
error[i] = np.mean(
(self.data[i] - self.network.nodes[winners[i]]['vector'])**2)
return np.mean(error)
if __name__ == '__main__':
bkg = MosaicImage(
Image.open(
os.path.join("Data", "tracking", "dataset", "baseline", "office",
"bkg.jpg")), Parameters({"pictures_dim": [16, 16]}))
image = MosaicImage(
Image.open(
os.path.join("Data", "tracking", "dataset", "baseline", "office",
"input", "in001010.jpg")),
Parameters({"pictures_dim": [16, 16]}))
nb_epochs = 100
inputs = Parameters({
"epsilon_winner": 0.1,
"epsilon_neighbour": 0.006,
"maximum_age": 10,
"error_decrease_new_unit": 0.5,
"error_decrease_global": 0.995,
"data": bkg.get_data(),
"neurons_nbr": 200,
def get_neural_distances(self, old_winners):
if self.winners is None:
self.get_all_winners()
distances = np.zeros(self.winners.shape)
for n in self.winners:
distances = nx.shortest_path_length(self.network, self.network.nodes[n], self.network.nodes[old_winners[n]])
print(distances)
def square_error(self):
if self.winners is None:
self.get_all_winners()
error = np.zeros(self.winners.shape)
for i in np.ndindex(self.winners.shape):
error[i] = np.mean((self.data[i] - self.network.nodes[self.winners[i]]['vector'])**2)
return np.mean(error)
if __name__ == '__main__':
img = MosaicImage(Image.open(os.path.join("Data", "Images", "Lenna.png")), Parameters({"pictures_dim": [10, 10]}))
data = img.get_data()
gng = NeuralTopology(data)
gng.img = img
gng.fit_network(e_b=0.1, e_n=0.006, a_max=10, l=200, a=0.5, d=0.995, passes=500, plot_evolution=False)
reconstructed = img.reconstruct(gng.get_reconstructed_data())
# som_image = mosaic.reconstruct(gng.get_neural_list(), size=som.neurons_nbr)
print(gng.get_all_winners())
plt.imshow(reconstructed)
plt.show()
# plt.imshow(som_image, cmap='gray')