Example #1
0
    def templateSyncEnsembleAllocation(self, stimulus, params, sim_steps,
                                       sim_time, expected_clusters):
        net = hhn_network(len(stimulus), stimulus, params)
        (t, x) = net.simulate(sim_steps, sim_time)

        ensembles = net.allocate_sync_ensembles(0.2)
        assert ensembles == expected_clusters
def template_dynamic_hhn(num_osc,
                         steps,
                         time,
                         stimulus=None,
                         params=None,
                         separate_representation=False):
    net = hhn_network(num_osc, stimulus, params)

    (t, dyn) = net.simulate(steps, time)

    draw_dynamics(t,
                  dyn,
                  x_title="Time",
                  y_title="V",
                  separate=separate_representation)
Example #3
0
def template_dynamic_hhn(num_osc, steps, time, stimulus = None, params = None, separate = False, ccore_flag = False):
    net = hhn_network(num_osc, stimulus, params, ccore = ccore_flag);

    (t, dyn_peripheral, dyn_central) = net.simulate(steps, time);

    amount_canvases = 1;
    if (isinstance(separate, list)):
        amount_canvases = len(separate) + 2;
    elif (separate is True):
        amount_canvases = len(dyn_peripheral[0]) + 2;
    
    visualizer = dynamic_visualizer(amount_canvases, x_title = "Time", y_title = "V", y_labels = False);
    visualizer.append_dynamics(t, dyn_peripheral, 0, separate);
    visualizer.append_dynamics(t, dyn_central, amount_canvases - 2, True);
    visualizer.show();
Example #4
0
 def templateSyncEnsembleAllocation(self, stimulus, params, sim_steps, sim_time, expected_clusters):
     result_testing = False;
     
     for attempt in range(0, 2, 1):
         net = hhn_network(len(stimulus), stimulus, params);
         (t, x) = net.simulate(sim_steps, sim_time);
         
         ensembles = net.allocate_sync_ensembles(1.0);
         if (ensembles != expected_clusters):
             continue;
         
         result_testing = True;
         break;
     
     assert result_testing;
Example #5
0
 def templateSyncEnsembleAllocation(self, stimulus, params, sim_steps, sim_time, expected_clusters):
     result_testing = False;
     
     for _ in range(0, 2, 1):
         net = hhn_network(len(stimulus), stimulus, params);
         (t, x) = net.simulate(sim_steps, sim_time);
         
         ensembles = net.allocate_sync_ensembles(1.0);
         if (ensembles != expected_clusters):
             continue;
         
         result_testing = True;
         break;
     
     assert result_testing;
Example #6
0
def template_dynamic_hhn(num_osc, steps, time, stimulus = None, params = None, separate = False, ccore_flag = False):
    net = hhn_network(num_osc, stimulus, params, ccore = ccore_flag);

    (t, dyn_peripheral, dyn_central) = net.simulate(steps, time);

    amount_canvases = 1;
    if (isinstance(separate, list)):
        amount_canvases = len(separate) + 2;
    elif (separate is True):
        amount_canvases = len(dyn_peripheral[0]) + 2;
    
    visualizer = dynamic_visualizer(amount_canvases, x_title = "Time", y_title = "V", y_labels = False);
    visualizer.append_dynamics(t, dyn_peripheral, 0, separate);
    visualizer.append_dynamics(t, dyn_central, amount_canvases - 2, True);
    visualizer.show();
Example #7
0
    def templateSyncEnsembleAllocation(stimulus, params, sim_steps, sim_time, expected_clusters, ccore):
        result_testing = False;

        for _ in range(0, 5, 1):
            net = hhn_network(len(stimulus), stimulus, params, ccore=ccore);
            (t, dyn_p, dyn_c) = net.simulate(sim_steps, sim_time);

            assert t is not None;
            assert dyn_p is not None;
            assert dyn_c is not None;

            assert len(t) == sim_steps + 1;
            assert len(dyn_p) == sim_steps + 1;
            assert len(dyn_c) == sim_steps + 1;

            ensembles = net.allocate_sync_ensembles(1.0);
            if (ensembles != expected_clusters):
                continue;

            result_testing = True;
            break;

        assert result_testing;
Example #8
0
    def templateSyncEnsembleAllocation(stimulus, params, sim_steps, sim_time, expected_clusters, ccore):
        result_testing = False;

        for _ in range(0, 5, 1):
            net = hhn_network(len(stimulus), stimulus, params, ccore=ccore);
            (t, dyn_p, dyn_c) = net.simulate(sim_steps, sim_time);

            assert t is not None;
            assert dyn_p is not None;
            assert dyn_c is not None;

            assert len(t) == sim_steps + 1;
            assert len(dyn_p) == sim_steps + 1;
            assert len(dyn_c) == sim_steps + 1;

            ensembles = net.allocate_sync_ensembles(1.0);
            if (ensembles != expected_clusters):
                continue;

            result_testing = True;
            break;

        assert result_testing;
Example #9
0
def template_image_segmentation(image_file, steps, time, dynamic_file_prefix):
    image = read_image(image_file)
    stimulus = rgb2gray(image)

    params = hhn_parameters()
    params.deltah = 650
    params.w1 = 0.1
    params.w2 = 9.0
    params.w3 = 5.0
    params.threshold = -10

    stimulus = [255.0 - pixel for pixel in stimulus]
    divider = max(stimulus) / 50.0
    stimulus = [int(pixel / divider) for pixel in stimulus]

    t, dyn_peripheral, dyn_central = None, None, None

    if (not os.path.exists(dynamic_file_prefix + 'dynamic_time.txt') or
            not os.path.exists(dynamic_file_prefix + 'dynamic_peripheral.txt')
            or not os.path.exists(dynamic_file_prefix +
                                  'dynamic_dyn_central.txt')):

        print(
            "File with output dynamic is not found - simulation will be performed - it may take some time, be patient."
        )

        net = hhn_network(len(stimulus), stimulus, params, ccore=True)

        (t, dyn_peripheral, dyn_central) = net.simulate(steps, time)

        print("Store dynamic to save time for simulation next time.")

        with open(dynamic_file_prefix + 'dynamic_time.txt',
                  'wb') as file_descriptor:
            pickle.dump(t, file_descriptor)

        with open(dynamic_file_prefix + 'dynamic_peripheral.txt',
                  'wb') as file_descriptor:
            pickle.dump(dyn_peripheral, file_descriptor)

        with open(dynamic_file_prefix + 'dynamic_dyn_central.txt',
                  'wb') as file_descriptor:
            pickle.dump(dyn_central, file_descriptor)
    else:
        print("Load output dynamic from file.")

        with open(dynamic_file_prefix + 'dynamic_time.txt',
                  'rb') as file_descriptor:
            t = pickle.load(file_descriptor)

        with open(dynamic_file_prefix + 'dynamic_peripheral.txt',
                  'rb') as file_descriptor:
            dyn_peripheral = pickle.load(file_descriptor)

        with open(dynamic_file_prefix + 'dynamic_dyn_central.txt',
                  'rb') as file_descriptor:
            dyn_central = pickle.load(file_descriptor)

    animate_segmentation(t, dyn_peripheral, image_file, 200)

    # just for checking correctness of results - let's use classical algorithm
    if (False):
        dbscan_instance = dbscan(image, 3, 4, True)
        dbscan_instance.process()
        trustable_clusters = dbscan_instance.get_clusters()

        amount_canvases = len(trustable_clusters) + 2
        visualizer = dynamic_visualizer(amount_canvases,
                                        x_title="Time",
                                        y_title="V",
                                        y_labels=False)
        visualizer.append_dynamics(t, dyn_peripheral, 0, trustable_clusters)
        visualizer.append_dynamics(t, dyn_central, amount_canvases - 2, True)
        visualizer.show()
Example #10
0
def template_dynamic_hhn(num_osc, steps, time, stimulus=None, params=None, separate_representation=False):
    net = hhn_network(num_osc, stimulus, params)

    (t, dyn) = net.simulate(steps, time)

    draw_dynamics(t, dyn, x_title="Time", y_title="V", separate=separate_representation)
Example #11
0
 def templateSyncEnsembleAllocation(self, stimulus, params, sim_steps, sim_time, expected_clusters):
     net = hhn_network(len(stimulus), stimulus, params);
     (t, x) = net.simulate(sim_steps, sim_time);
     
     ensembles = net.allocate_sync_ensembles(0.2);
     assert ensembles == expected_clusters;
Example #12
0
def template_image_segmentation(image_file, steps, time, dynamic_file_prefix):
    image = read_image(image_file);
    stimulus = rgb2gray(image);

    params = hhn_parameters();
    params.deltah = 650;
    params.w1 = 0.1;
    params.w2 = 9.0;
    params.w3 = 5.0;
    params.threshold = -10;

    stimulus = [255.0 - pixel for pixel in stimulus];
    divider = max(stimulus) / 50.0;
    stimulus = [int(pixel / divider) for pixel in stimulus];

    t, dyn_peripheral, dyn_central = None, None, None;

    if ( not os.path.exists(dynamic_file_prefix + 'dynamic_time.txt') or
         not os.path.exists(dynamic_file_prefix + 'dynamic_peripheral.txt') or
         not os.path.exists(dynamic_file_prefix + 'dynamic_dyn_central.txt') ):
        
        print("File with output dynamic is not found - simulation will be performed - it may take some time, be patient.");

        net = hhn_network(len(stimulus), stimulus, params, ccore=True);

        (t, dyn_peripheral, dyn_central) = net.simulate(steps, time);

        print("Store dynamic to save time for simulation next time.");

        with open(dynamic_file_prefix + 'dynamic_time.txt', 'wb') as file_descriptor:
            pickle.dump(t, file_descriptor);

        with open(dynamic_file_prefix + 'dynamic_peripheral.txt', 'wb') as file_descriptor:
            pickle.dump(dyn_peripheral, file_descriptor);

        with open(dynamic_file_prefix + 'dynamic_dyn_central.txt', 'wb') as file_descriptor:
            pickle.dump(dyn_central, file_descriptor);
    else:
        print("Load output dynamic from file.");
        
        with open (dynamic_file_prefix + 'dynamic_time.txt', 'rb') as file_descriptor:
            t = pickle.load(file_descriptor);

        with open (dynamic_file_prefix + 'dynamic_peripheral.txt', 'rb') as file_descriptor:
            dyn_peripheral = pickle.load(file_descriptor);

        with open (dynamic_file_prefix + 'dynamic_dyn_central.txt', 'rb') as file_descriptor:
            dyn_central = pickle.load(file_descriptor);

    animate_segmentation(t, dyn_peripheral, image_file, 200);

    # just for checking correctness of results - let's use classical algorithm
    if (False):
        dbscan_instance = dbscan(image, 3, 4, True);
        dbscan_instance.process();
        trustable_clusters = dbscan_instance.get_clusters();
    
        amount_canvases = len(trustable_clusters) + 2;
        visualizer = dynamic_visualizer(amount_canvases, x_title = "Time", y_title = "V", y_labels = False);
        visualizer.append_dynamics(t, dyn_peripheral, 0, trustable_clusters);
        visualizer.append_dynamics(t, dyn_central, amount_canvases - 2, True);
        visualizer.show();