def improved_process(P, codes, channels): improved_codes = [] n = P.shape[1] // 3 for c in range(len(codes) // n): improved_codes.append( np.concatenate(([codes[n * c + k] for k in range(n)]))) # Encoding improved_encoder = Encoder(P) encodes = [improved_encoder.encode(code) for code in improved_codes] # Channeling outputs = [None] * len(channels) for c in range(len(channels)): outputs[c] = np.array( [channels[c].add_noise(code) for code in encodes]) # Decoding improved_decoder = Decoder(P, n + 1) for c in range(len(channels)): outputs[c] = np.array( [improved_decoder.decode(code) for code in outputs[c]]) return outputs
def evaluate(combination: tuple, keys: list, method: str, encoder: Encoder, y_true: np.array, y_pred: np.array, filenames: list) -> dict: """Compute the segments using the given parameters and then compute all the metrics using the sed_eval toolbox. Args: combination (tuple): keys (list): method (str): encoder (Encoder): y_true (np.array): y_pred (np.array): filenames (list): """ # Transform parameters from tuple to dictionary # If only one parameter --> transform into tuple before # if not isinstance(combination, list): # combination = [combination] combination = dict(zip(keys, combination)) # Compute segment and transform into a csv string segments = encoder.encode(y_pred, method=method, **combination) to_evaluate = encoder.parse(segments, filenames) # evaluate using sed_eval if encoder.method == "segment_based_metrics": return sb_evaluator(y_true, to_evaluate, time_resolution=encoder.time_resolution).results() else: return eb_evaluator( y_true, to_evaluate, t_collar=encoder.t_collar, percentage_of_length=encoder.percentage_of_length).results()
def encode(self, string): self.set_string(string) ### reciving the input stiring encoder = Encoder(self._string, self._probrangedict) ### creating an Encoder return encoder.encode( ) ### returning the binary Tagnumber generated by encoder given the stirng
str(size).encode()) # invio la dimensione del file if self.request.recv(1024).decode() == "OK": self.request.sendfile(fin) def finish(self): print("Invio completo") if __name__ == '__main__': encoder = Encoder() encoder.set_environment() base_path = encoder.base_path + "/compressione/" encoder.encode() print("Pronto per inviare ...") files = Queue() for _ in range(3): files.put(base_path + "/tmp" + str(_)) serv = TCPServer(('', 20000), ServerHandler) for n in range(2): t = Thread(target=serv.serve_forever) t.daemon = True t.start()
class NeuCube(): """ This class integrates all stages of the NeuCube model. """ def __init__(self, input_electrodes, number_of_training_samples, signal_duration, signal_timestep, simulation_timestep, subject): self.path = os.getcwd() self.input_electrodes = input_electrodes self.number_of_training_samples = number_of_training_samples self.encoder = Encoder(self.path, len(input_electrodes), number_of_training_samples, signal_duration, signal_timestep, subject) self.reservoir = NeuCubeReservoir(self.path, simulation_timestep) self.classifier = Classifier() def encode_eeg_input(self, encoding_method, save_data, plot_data, subject): #This method encodes the EEG data in the input_stage_1 folder using the defined encoding_method and saves / plots the data if needed. spike_trains = self.encoder.encode(encoding_method, subject) if save_data or plot_data: rec_sig = self.encoder.decode(encoding_method) error = self.encoder.calc_error() if save_data: self.encoder.save_output() self.encoder.save_rec_sig() if plot_data: self.encoder.plot_output(encoding_method) self.encoder.plot_rec_sig() return spike_trains def create_reservoir(self, new_reservoir, plot_stability, input_electrodes, inhibitory_split, connection_probability, small_world_conn_factor, max_syn_len, w_dist_ex_mean, w_dist_inh_mean, save_structure): if new_reservoir: self.reservoir.initialize_reservoir_structure( input_electrodes, inhibitory_split, connection_probability, small_world_conn_factor, max_syn_len, w_dist_ex_mean, w_dist_inh_mean, save_structure) if plot_stability: self.reservoir.reservoir_structure.calculate_stability( inhibitory_split, w_dist_ex_mean, w_dist_inh_mean) else: self.reservoir.load_reservoir_structure() def train_reservoir_STDP(self, use_STDP, encoding_method, simulation_time, number_of_neurons_per_core, number_of_training_samples, spike_train_data, tau_plus, tau_minus, A_plus, A_minus, w_min, w_max, save_training_result, plot_spikes, plot_voltage): if use_STDP: self.reservoir.train_network_STDP( encoding_method, simulation_time, number_of_neurons_per_core, number_of_training_samples, spike_train_data, tau_plus, tau_minus, A_plus, A_minus, w_min, w_max, save_training_result, plot_spikes, plot_voltage) def train_deSNN(self, load_spikes, save_reservoir_spikes, save_neurons, encoding_method, simulation_time, number_of_neurons_per_core, number_of_training_samples, spike_train_data, tau_plus, tau_minus, A_plus, A_minus, w_min, w_max, alpha, mod, drift_up, drift_down, number_of_classes, plot_spikes, plot_voltage): print('Training the deSNN network...') # Read target_class_labels: tar_class_labels = [] for item in csv.reader(open( os.path.join(self.path, 'input_stage_3', 'tar_class_labels.txt'), 'r'), delimiter=' '): tar_class_labels.append(item) if len(tar_class_labels) < number_of_training_samples: print('Error: Not enough class lables for number of samples!') else: tar_class_labels = tar_class_labels[0:number_of_training_samples] if load_spikes: #load spikes from storage for s in range(number_of_training_samples): sample_spikes = self.classifier.load_reservoir_spikes( os.path.join( self.path, 'input_stage_3', 'reservoir_spikes_sam_' + str(s + 1) + '.txt')) neuron = Output_Neuron( sample_spikes, len(self.reservoir.reservoir_structure.get_positions() ), alpha, mod, drift_up, drift_down, tar_class_labels[s]) if save_neurons: neuron.save_whole_neuron(self.path, s) self.classifier.add_neuron(neuron) else: #create spikes from reservoir STDP = False #enable/disable STDP during deSNN training reservoir_spikes = self.reservoir.train_network_deSNN( encoding_method, simulation_time, number_of_neurons_per_core, number_of_training_samples, spike_train_data, tau_plus, tau_minus, A_plus, A_minus, w_min, w_max, STDP, plot_spikes, plot_voltage, save_reservoir_spikes) for s in range(number_of_training_samples): sample_spikes = [] for spike in reservoir_spikes: if spike[1] >= s * 1.5 * simulation_time and spike[ 1] <= (s * 1.5 + 1) * simulation_time: sample_spikes.append(spike) neuron = Output_Neuron( sample_spikes, len(self.reservoir.reservoir_structure.get_positions() ), alpha, mod, drift_up, drift_down, tar_class_labels[s]) if save_neurons: neuron.save_whole_neuron(self.path, s) self.classifier.add_neuron(neuron) print('Added all samples/neurons to the deSNN classifier!') return self.classifier.separation( self.path, number_of_training_samples, number_of_classes, len(self.reservoir.reservoir_structure.get_positions())) def classify(self, subject, save_reservoir_spikes, first_test_sample_index, number_of_test_samples, encoding_method, simulation_time, number_of_neurons_per_core, number_of_training_samples, alpha, mod, drift_up, drift_down, feature, k_neighbors): # Classify test samples labels = [] for test_sample_index in range( first_test_sample_index, first_test_sample_index + number_of_test_samples): sample_EEG = self.encoder.load_sample(test_sample_index, subject) sample_SSA = self.encoder.encode_sample(sample_EEG, encoding_method) sample_reservoir_spikes = self.reservoir.filter_sample( encoding_method, test_sample_index, sample_SSA, simulation_time, number_of_neurons_per_core, save_reservoir_spikes) test_neuron = Output_Neuron( sample_reservoir_spikes, len(self.reservoir.reservoir_structure.get_positions()), alpha, mod, drift_up, drift_down) fitting_type = 'normal' #'normal' for fitting to all neurons, 'COM' for fitting to only center of mass vectors class_label = self.classifier.classify(test_neuron, feature, k_neighbors, fitting_type) labels.append(class_label[0]) print('Predicted labels for all samples: ' + str(labels)) # Calculate Accuracy tar_class_labels = [] for item in csv.reader(open( os.path.join(self.path, 'input_stage_3', 'tar_class_labels.txt'), 'r'), delimiter=' '): tar_class_labels.append(item[0]) count = 0 for i in range(number_of_test_samples): if labels[i] == tar_class_labels[number_of_training_samples + i]: count += 1 print('Real labels for all samples: ' + str(tar_class_labels[first_test_sample_index - 1:first_test_sample_index + number_of_test_samples - 1])) accuracy = count / float(number_of_test_samples) print('Accuracy: ' + str(accuracy)) return (accuracy)
def main(_): """ Run main function """ #___________________________________________Layer info_____________________________________________________ n = FLAGS.hidden_n Encoder_infos = { "outdim":[n,n,2*n,2*n,2*n,3*n,3*n, 3*n, 3*n],\ "kernel":[ \ [3, 3], \ [3, 3], \ [3, 3], \ [3, 3], \ [3, 3], \ [3, 3], \ [3, 3], \ [3, 3], \ [3, 3], \ ], \ "stride":[ \ [1, 1], \ [1, 1], \ [1, 1], \ [2, 2], \ [1, 1], \ [1, 1], \ [2, 2], \ [1, 1], \ [1, 1], \ ], \ } Decoder_infos = { "outdim":[n,n,n,n,n,n,3], \ "kernel":[ \ [3, 3], \ [3, 3], \ [3, 3], \ [3, 3], \ [3, 3], \ [3, 3], \ [3, 3], \ ], \ "stride":[ \ [1, 1], \ [1, 1], \ [1, 1], \ [1, 1], \ [1, 1], \ [1, 1], \ [1, 1], \ ], \ } Generator_infos = { "outdim":[n,n,n,n,n,n,3], \ "kernel":[ \ [3, 3], \ [3, 3], \ [3, 3], \ [3, 3], \ [3, 3], \ [3, 3], \ [3, 3], \ ], \ "stride":[ \ [1, 1], \ [1, 1], \ [1, 1], \ [1, 1], \ [1, 1], \ [1, 1], \ [1, 1], \ ], \ } """ Prepare Image Loader """ root = "./CelebA/images" batch_size = FLAGS.bn scale_size = [FLAGS.scale_h,FLAGS.scale_w] data_format = "NHWC" loader = Image_Loader(root, batch_size, scale_size, data_format, file_type="jpg") """ Make Saving Directories """ os.makedirs("./Check_Point", exist_ok=True) os.makedirs("./logs", exist_ok=True) # make logs directories to save summaries os.makedirs("./Real_Images", exist_ok=True) os.makedirs("./Generated_Images", exist_ok=True) os.makedirs("./Decoded_Generated_Images", exist_ok=True) #---------------------------------------------------------------------------------------------------- #____________________________________Model composition________________________________________ k = tf.Variable(0.0, name = "k_t", trainable = False, dtype = tf.float32) #init value of k_t = 0 batch = loader.queue # Get image batch tensor image = norm_img(batch) # Normalize Imgae z_G = generate_z() # Sample embedding vector batch from uniform distribution z_D = generate_z() # Sample embedding vector batch from uniform distribution E = Encoder("Encoder", Encoder_infos) D = Decoder("Decoder", Decoder_infos) G = Decoder("Generator", Generator_infos) #Generator generated_image = G.decode(z_G) generated_image_for_disc = G.decode(z_D, reuse = True) #Discriminator (Auto-Encoder) #image <--AutoEncoder--> reconstructed_image_real embedding_vector_real = E.encode(image) reconstructed_image_real = D.decode(embedding_vector_real) #generated_image_for_disc <--AutoEncoder--> reconstructed_image_fake embedding_vector_fake_for_disc = E.encode(generated_image_for_disc, reuse=True) reconstructed_image_fake_for_disc = D.decode(embedding_vector_fake_for_disc, reuse=True) #generated_image <--AutoEncoder--> reconstructed_image_fake embedding_vector_fake = E.encode(generated_image, reuse=True) reconstructed_image_fake = D.decode(embedding_vector_fake, reuse=True) #----------------------------------------------------------------------------------------------- #_________________________________Loss & Summary_______________________________________________ """ Define Loss """ real_image_loss = get_loss(image, reconstructed_image_real) generator_loss_for_disc = get_loss(generated_image_for_disc, reconstructed_image_fake_for_disc) discriminator_loss = real_image_loss - tf.multiply(k, generator_loss_for_disc) generator_loss = get_loss(generated_image, reconstructed_image_fake) global_measure = real_image_loss + tf.abs(tf.multiply(FLAGS.gamma,real_image_loss) - generator_loss) """ Summaries """ tf.summary.scalar('Real image loss', real_image_loss) tf.summary.scalar('Generator loss for discriminator', generator_loss_for_disc) tf.summary.scalar('Discriminator loss', discriminator_loss) tf.summary.scalar('Generator loss', generator_loss) tf.summary.scalar('Global_Measure', global_measure) tf.summary.scalar('k_t', k) merged_summary = tf.summary.merge_all() # merege summaries, no more summaries under this line #----------------------------------------------------------------------------------------------- #_____________________________________________Train_______________________________________________ discriminator_parameters = [] generator_parameters = [] for v in tf.trainable_variables(): if 'Encoder' in v.name: discriminator_parameters.append(v) print("Discriminator parameter : ", v.name) elif 'Decoder' in v.name: discriminator_parameters.append(v) print("Discriminator parameter : ", v.name) elif 'Generator' in v.name: generator_parameters.append(v) print("Generator parameter : ", v.name) else: print("None of Generator and Discriminator parameter : ", v.name) optimizer_D = tf.train.AdamOptimizer(FLAGS.lr,beta1=FLAGS.B1,beta2=FLAGS.B2).minimize(discriminator_loss,var_list=discriminator_parameters) optimizer_G = tf.train.AdamOptimizer(FLAGS.lr,beta1=FLAGS.B1,beta2=FLAGS.B2).minimize(generator_loss,var_list=generator_parameters) with tf.control_dependencies([optimizer_D, optimizer_G]): k_update = tf.assign(k, tf.clip_by_value(k + FLAGS.lamb * (FLAGS.gamma*real_image_loss - generator_loss), 0, 1)) #update k_t init = tf.global_variables_initializer() NUM_THREADS=2 config=tf.ConfigProto(inter_op_parallelism_threads=NUM_THREADS,\ intra_op_parallelism_threads=NUM_THREADS,\ allow_soft_placement=True,\ device_count = {'CPU': 1},\ ) # config.gpu_options.per_process_gpu_memory_fraction = FLAGS.gpu_portion with tf.Session(config=config) as sess: sess.run(init) # Initialize Variables coord = tf.train.Coordinator() # Set Coordinator to Manage Queue Runners threads = tf.train.start_queue_runners(sess, coord=coord) # Set Threads writer = tf.summary.FileWriter('./logs', sess.graph) # add the graph to the file './logs' #_______________________________Restore____________________________________ saver = tf.train.Saver(max_to_keep=1000) ckpt = tf.train.get_checkpoint_state(checkpoint_dir="./Check_Point") # try : # if ckpt and ckpt.model_checkpoint_path: # print("check point path : ", ckpt.model_checkpoint_path) # saver.restore(sess, ckpt.model_checkpoint_path) # print('Restored!') # except AttributeError: # print("No checkpoint") Real_Images = sess.run(denorm_img(image)) save_image(Real_Images, '{}.png'.format("./Real_Images/Real_Image")) #--------------------------------------------------------------------------- for t in range(FLAGS.iteration): # Mini-Batch Iteration Loop if coord.should_stop(): break _, _, l_D, l_G, l_Global, k_t = sess.run([\ optimizer_D,\ optimizer_G,\ discriminator_loss,\ generator_loss,\ global_measure,\ k_update,\ ]) print( " Step : {}".format(t), " Global measure of convergence : {}".format(l_Global), " Generator Loss : {}".format(l_G), " Discriminator Loss : {}".format(l_D), " k_{} : {}".format(t,k_t) ) #________________________________Save____________________________________ if t % 200 == 0: summary = sess.run(merged_summary) writer.add_summary(summary, t) Generated_Images, Decoded_Generated_Images = sess.run([denorm_img(generated_image), denorm_img(reconstructed_image_fake)]) save_image(Generated_Images, '{}/{}{}.png'.format("./Generated_Images", "Generated", t)) save_image(Decoded_Generated_Images, '{}/{}{}.png'.format("./Decoded_Generated_Images", "AutoEncoded", t)) print("-------------------Image saved-------------------") if t % 500 == 0: print("Save model {}th".format(t)) saver.save(sess, "./Check_Point/model.ckpt", global_step = t) #-------------------------------------------------------------------- writer.close() coord.request_stop() coord.join(threads)
decoder = Decoder(P, 3) else: encoder = EncoderHamming() decoder = DecoderHamming() channel = Channel(0.3) # Receiving code code = np.matrix([[int(x) for x in input()]]) # Printing code print("Code received: ") print(code) input() # Encoding channel print("Encoding: ") encoded = encoder.encode(code) print(encoded) input() # Passing through channel print("Passing through channel: ") through_channel = np.array(channel.add_noise(np.array(encoded)[0])) print(through_channel) input() # Decoding code print("Decoding: ") decoded = decoder.decode(through_channel) print(decoded)