def testAverageNeighborFourDistanceNegativeValues(self): points = [[0.0, 0.0], [0.0, -1.0], [-1.0, -1.0], [-1.0, 0.0]] assert average_neighbor_distance(points, 1) == 1.0 assert average_neighbor_distance(points, 2) == 1.0 assert self.float_comparasion(average_neighbor_distance(points, 3), 1.1381)
def process(self, order = 0.998, solution = solve_type.FAST, collect_dynamic = False): """! @brief Performs clustering of input data set in line with input parameters. @param[in] order (double): Level of local synchronization between oscillator that defines end of synchronization process, range [0..1]. @param[in] solution (solve_type) Type of solving differential equation. @param[in] collect_dynamic (bool): If True - returns whole history of process synchronization otherwise - only final state (when process of clustering is over). @return (tuple) Returns dynamic of the network as tuple of lists on each iteration (time, oscillator_phases) that depends on collect_dynamic parameter. @see get_clusters() """ if (self.__ccore_network_pointer is not None): analyser = wrapper.hsyncnet_process(self.__ccore_network_pointer, order, solution, collect_dynamic); return syncnet_analyser(None, None, analyser); number_neighbors = self.__initial_neighbors; current_number_clusters = float('inf'); dyn_phase = []; dyn_time = []; radius = average_neighbor_distance(self._osc_loc, number_neighbors); increase_step = int(len(self._osc_loc) * self.__increase_persent); if (increase_step < 1): increase_step = 1; analyser = None; while(current_number_clusters > self._number_clusters): self._create_connections(radius); analyser = self.simulate_dynamic(order, solution, collect_dynamic); if (collect_dynamic == True): if (len(dyn_phase) == 0): self.__store_dynamic(dyn_phase, dyn_time, analyser, True); self.__store_dynamic(dyn_phase, dyn_time, analyser, False); clusters = analyser.allocate_sync_ensembles(0.05); # Get current number of allocated clusters current_number_clusters = len(clusters); # Increase number of neighbors that should be used number_neighbors += increase_step; # Update connectivity radius and check if average function can be used anymore radius = self.__calculate_radius(number_neighbors, radius); if (collect_dynamic != True): self.__store_dynamic(dyn_phase, dyn_time, analyser, False); return syncnet_analyser(dyn_phase, dyn_time, None);
def process(self, order = 0.998, solution = solve_type.FAST, collect_dynamic = False): """! @brief Performs clustering of input data set in line with input parameters. @param[in] order (double): Level of local synchronization between oscillator that defines end of synchronization process, range [0..1]. @param[in] solution (solve_type) Type of solving differential equation. @param[in] collect_dynamic (bool): If True - returns whole history of process synchronization otherwise - only final state (when process of clustering is over). @return (tuple) Returns dynamic of the network as tuple of lists on each iteration (time, oscillator_phases) that depends on collect_dynamic parameter. @see get_clusters() """ if (self.__ccore_network_pointer is not None): analyser = wrapper.hsyncnet_process(self.__ccore_network_pointer, order, solution, collect_dynamic); return syncnet_analyser(None, None, analyser); number_neighbors = 0; current_number_clusters = float('inf'); dyn_phase = []; dyn_time = []; radius = 0.0; while(current_number_clusters > self._number_clusters): self._create_connections(radius); analyser = self.simulate_dynamic(order, solution, collect_dynamic); if (collect_dynamic == True): dyn_phase += analyser.output; if (len(dyn_time) > 0): point_time_last = dyn_time[len(dyn_time) - 1]; dyn_time += [time_point + point_time_last for time_point in analyser.time]; else: dyn_time += analyser.time; clusters = analyser.allocate_sync_ensembles(0.05); # Get current number of allocated clusters current_number_clusters = len(clusters); # Increase number of neighbors that should be used number_neighbors += 1; # Update connectivity radius and check if average function can be used anymore if (number_neighbors >= len(self._osc_loc)): radius = radius * 0.1 + radius; else: radius = average_neighbor_distance(self._osc_loc, number_neighbors); return syncnet_analyser(dyn_phase, dyn_time, None);
def __calculate_radius(self, number_neighbors, radius): """! @brief Calculate new connectivity radius. @param[in] number_neighbors (uint): Average amount of neighbors that should be connected by new radius. @param[in] radius (double): Current connectivity radius. @return New connectivity radius. """ if (number_neighbors >= len(self._osc_loc)): return radius * self.__increase_persent + radius return average_neighbor_distance(self._osc_loc, number_neighbors)
def __calculate_radius(self, number_neighbors, radius): """! @brief Calculate new connectivity radius. @param[in] number_neighbors (uint): Average amount of neighbors that should be connected by new radius. @param[in] radius (double): Current connectivity radius. @return New connectivity radius. """ if (number_neighbors >= len(self._osc_loc)): return radius * self.__increase_persent + radius; return average_neighbor_distance(self._osc_loc, number_neighbors);
def process(self, number_neighbours, collect_dynamic=False, order=0.999): """! @brief Performs simulation of the oscillatory network. @param[in] number_neighbours (uint): Number of neighbours that should be used for calculation average distance and creation connections between oscillators. @param[in] collect_dynamic (bool): If True - returns whole dynamic of oscillatory network, otherwise returns only last values of dynamics. @param[in] order (double): Order of process synchronization that should be considered as end of clustering, destributed 0..1. @return (tuple) Dynamic of oscillatory network. If argument 'collect_dynamic' = True, than return dynamic for the whole simulation time, otherwise returns only last values (last step of simulation) of dynamic. @see get_som_clusters() @see get_clusters() """ # train self-organization map. self._som.train(self._data, 100) # prepare to build list. weights = list() self._som_osc_table.clear() # must be cleared, if it's used before. for i in range(self._som.size): if self._som.awards[i] > 0: weights.append(self._som.weights[i]) self._som_osc_table.append(i) # calculate trusted distance between objects. radius = 0 if len(weights) >= number_neighbours: radius = average_neighbor_distance(weights, number_neighbours) else: radius = 0 # create oscillatory neural network. self._sync = syncnet(weights, radius, initial_phases=initial_type.EQUIPARTITION) self._analyser = self._sync.process(order, collect_dynamic=collect_dynamic) # Draw SOM clusters. # clusters = self._sync.get_clusters(); # draw_clusters(weights, clusters); # self._som.show_network(awards = False, belongs = True); # return dynamic if it was requested. return (self._analyser.time, self._analyser.output)
def __create_weights(self, stimulus): """! @brief Create weights between neurons in line with stimulus. @param[in] stimulus (list): External stimulus for the chaotic neural network. """ self.__average_distance = average_neighbor_distance(stimulus, self.__amount_neighbors) self.__weights = [ [ 0.0 for _ in range(len(stimulus)) ] for _ in range(len(stimulus)) ] self.__weights_summary = [ 0.0 for _ in range(self.__num_osc) ] if self.__conn_type == type_conn.ALL_TO_ALL: self.__create_weights_all_to_all(stimulus) elif self.__conn_type == type_conn.TRIANGULATION_DELAUNAY: self.__create_weights_delaunay_triangulation(stimulus)
def process(self, number_neighbours, collect_dynamic = False, order = 0.999): """! @brief Performs simulation of the oscillatory network. @param[in] number_neighbours (uint): Number of neighbours that should be used for calculation average distance and creation connections between oscillators. @param[in] collect_dynamic (bool): If True - returns whole dynamic of oscillatory network, otherwise returns only last values of dynamics. @param[in] order (double): Order of process synchronization that should be considered as end of clustering, destributed 0..1. @return (tuple) Dynamic of oscillatory network. If argument 'collect_dynamic' = True, than return dynamic for the whole simulation time, otherwise returns only last values (last step of simulation) of dynamic. @see get_som_clusters() @see get_clusters() """ # train self-organization map. self._som.train(self._data, 100); # prepare to build list. weights = list(); self._som_osc_table.clear(); # must be cleared, if it's used before. for i in range(self._som.size): if (self._som.awards[i] > 0): weights.append(self._som.weights[i]); self._som_osc_table.append(i); # calculate trusted distance between objects. radius = 0; if (len(weights) >= number_neighbours): radius = average_neighbor_distance(weights, number_neighbours); else: radius = 0; # create oscillatory neural network. self._sync = syncnet(weights, radius, initial_phases = initial_type.EQUIPARTITION); self._analyser = self._sync.process(order, collect_dynamic = collect_dynamic); # Draw SOM clusters. #clusters = self._sync.get_clusters(); #draw_clusters(weights, clusters); #self._som.show_network(awards = False, belongs = True); # return dynamic if it was requested. return (self._analyser.time, self._analyser.output);
def process(self, order=0.998, solution=solve_type.FAST, collect_dynamic=False): """! @brief Performs clustering of input data set in line with input parameters. @param[in] order (double): Level of local synchronization between oscillator that defines end of synchronization process, range [0..1]. @param[in] solution (solve_type) Type of solving differential equation. @param[in] collect_dynamic (bool): If True - returns whole history of process synchronization otherwise - only final state (when process of clustering is over). @return (tuple) Returns dynamic of the network as tuple of lists on each iteration (time, oscillator_phases) that depends on collect_dynamic parameter. @see get_clusters() """ if (self.__ccore_network_pointer is not None): analyser = wrapper.hsyncnet_process(self.__ccore_network_pointer, order, solution, collect_dynamic) return syncnet_analyser(None, None, analyser) number_neighbors = self.__initial_neighbors current_number_clusters = float('inf') dyn_phase = [] dyn_time = [] radius = average_neighbor_distance(self._osc_loc, number_neighbors) increase_step = int(len(self._osc_loc) * self.__increase_persent) if (increase_step < 1): increase_step = 1 analyser = None while (current_number_clusters > self._number_clusters): self._create_connections(radius) analyser = self.simulate_dynamic(order, solution, collect_dynamic) if (collect_dynamic == True): if (len(dyn_phase) == 0): self.__store_dynamic(dyn_phase, dyn_time, analyser, True) self.__store_dynamic(dyn_phase, dyn_time, analyser, False) clusters = analyser.allocate_sync_ensembles(0.05) # Get current number of allocated clusters current_number_clusters = len(clusters) # Increase number of neighbors that should be used number_neighbors += increase_step # Update connectivity radius and check if average function can be used anymore radius = self.__calculate_radius(number_neighbors, radius) if (collect_dynamic != True): self.__store_dynamic(dyn_phase, dyn_time, analyser, False) return syncnet_analyser(dyn_phase, dyn_time, None)
def testAverageNeighborFourDistance(self): points = [[0.0, 0.0], [0.0, 1.0], [1.0, 1.0], [1.0, 0.0]]; assert average_neighbor_distance(points, 1) == 1.0; assert average_neighbor_distance(points, 2) == 1.0; assert self.float_comparasion(average_neighbor_distance(points, 3), 1.1381);
def testAverageNeighborFourDistanceNegativeValues(self): points = [[0.0, 0.0], [0.0, -1.0], [-1.0, -1.0], [-1.0, 0.0]]; assert average_neighbor_distance(points, 1) == 1.0; assert average_neighbor_distance(points, 2) == 1.0; assert self.float_comparasion(average_neighbor_distance(points, 3), 1.1381);
def testAverageNeighborDistance(self): points = [[0, 0], [0, 1], [1, 1], [1, 0]]; assert average_neighbor_distance(points, 1) == 1.0; assert average_neighbor_distance(points, 2) == 1.0; assert self.float_comparasion(average_neighbor_distance(points, 3), 1.1381);