Merge pull request #42 from CSDLLab/3_6_draw_pic

HanZhaang · web-flow · commit 2c45a72ef8e9 · 2021-04-16T20:05:51.000+08:00
04_16
diff --git a/config/branch_metric.json b/config/branch_metric.json
@@ -1,7 +1,6 @@
 {
   "threshold_dis": 2,
   "threshold_mode": 1,
-  "metric_mode": 1,
   "true_positive_type": 3,
   "false_negative_type": 4,
   "false_positive_type": 5
diff --git a/config/fake_reconstruction_configs/branch_metric.json b/config/fake_reconstruction_configs/branch_metric.json
@@ -0,0 +1,4 @@
+{
+  "cfg1": [-5, 5, 100],
+  "cfg2": [-5, 5, 100]
+}
diff --git a/config/schemas/branch_metric_schema.json b/config/schemas/branch_metric_schema.json
@@ -4,15 +4,13 @@
   "required": [
       "threshold_dis",
       "threshold_mode",
-      "metric_mode",
       "true_positive_type",
       "false_negative_type",
       "false_positive_type"
   ],
   "properties": {
     "threshold_dis": {"type": "number", "exclusiveMinimum": 0},
     "threshold_mode": {"type": "number", "enum": [1, 2]},
-    "metric_mode": {"type": "number", "enum": [1, 2]},
     "true_positive_type": {"type": "integer", "exclusiveMinimum": 0},
     "false_negative_type": {"type": "integer", "exclusiveMinimum": 0},
     "false_positive_type": {"type": "integer", "exclusiveMinimum": 0}
diff --git a/pyneval/cli/pyneval.py b/pyneval/cli/pyneval.py
@@ -306,3 +306,4 @@ def run(DEBUG=True):
 
 # pyneval --gold .\\data\test_data\geo_metric_data\gold_34_23_10.swc --test .\data\test_data\geo_metric_data\test_34_23_10.swc --metric branch_metric
 
+# pyneval --gold .\\data\test_data\geo_metric_data\gold_34_23_10.swc --test .\data\test_data\geo_metric_data\test_34_23_10.swc --metric branch_metric
diff --git a/pyneval/metric/branch_leaf_metric.py b/pyneval/metric/branch_leaf_metric.py
@@ -66,7 +66,7 @@ def get_colored_tree(test_node_list, gold_node_list, switch, km, color):
 
 def score_point_distance(gold_tree: swc_node.SwcTree, test_tree: swc_node.SwcTree,
                          test_node_list: list, gold_node_list: list,
-                         threshold_dis: float, color: list, metric_mode: int):
+                         threshold_dis: float, color: list):
     """
     get minimum matching distance by running KM algorithm
     than calculte the return value according to matching result
@@ -78,9 +78,6 @@ def score_point_distance(gold_tree: swc_node.SwcTree, test_tree: swc_node.SwcTre
         threshold_dis: if the distance of two node are larger than this threshold,
                        they are considered unlimited far
         color(List): color id of tp, fn, fp nodes
-        metric_mode(1 or 2):
-            mode = 1: distance between nodes are calculated as euclidean distance
-            mode = 2: distance between nodes are calculated as distance on the gold tree
     Returns:
         gold_len(int): length of gold_node_list
         test_len(int): length of test_node_list
@@ -92,8 +89,8 @@ def score_point_distance(gold_tree: swc_node.SwcTree, test_tree: swc_node.SwcTre
         pt_cost: a composite value calculated by tp, fn, fp and threshold
         iso_node_num: number of nodes in test tree without parents or children
     """
-    test_gold_dict = point_match_utils.get_swc2swc_dicts(src_node_list=test_swc_tree.get_node_list(),
-                                                         tar_node_list=gold_swc_tree.get_node_list())
+    test_gold_dict = point_match_utils.get_swc2swc_dicts(src_node_list=test_tree.get_node_list(),
+                                                         tar_node_list=gold_tree.get_node_list())
     # disgraph is a 2D ndarray store the distance between nodes in gold and test
     # test_node_list contains only branch or leaf nodes
     dis_graph, switch, test_len, gold_len = km_utils.get_dis_graph(gold_tree=gold_tree,
@@ -102,7 +99,7 @@ def score_point_distance(gold_tree: swc_node.SwcTree, test_tree: swc_node.SwcTre
                                                                    gold_node_list=gold_node_list,
                                                                    test_gold_dict=test_gold_dict,
                                                                    threshold_dis=threshold_dis,
-                                                                   metric_mode=metric_mode)
+                                                                   metric_mode=1)
     # create a KM object and calculate the minimum match
     km = km_utils.KM(maxn=max(test_len, gold_len)+10, nx=test_len, ny=gold_len, G=dis_graph)
     km.solve()
@@ -150,7 +147,6 @@ def branch_leaf_metric(gold_swc_tree, test_swc_tree, config):
     """
     # read configs
     threshold_dis = config["threshold_dis"]
-    metric_mode = config["metric_mode"]
     threshold_mode = config["threshold_mode"]
 
     # in threshold mode 2, threshold is a multiple of the average length of edges
@@ -176,8 +172,7 @@ def branch_leaf_metric(gold_swc_tree, test_swc_tree, config):
                                                test_node_list=test_branch_swc_list,
                                                gold_node_list=gold_branch_swc_list,
                                                threshold_dis=threshold_dis,
-                                               color=color,
-                                               metric_mode=metric_mode)
+                                               color=color)
 
     branch_result = {
         "gold_len": branch_result_tuple[0],
@@ -199,8 +194,8 @@ def branch_leaf_metric(gold_swc_tree, test_swc_tree, config):
     gold_swc_tree = swc_node.SwcTree()
     test_swc_tree = swc_node.SwcTree()
 
-    test_swc_tree.load("../../data/test_data/topo_metric_data/gold_fake_data4.swc")
-    gold_swc_tree.load("../../data/test_data/topo_metric_data/test_fake_data4.swc")
+    gold_swc_tree.load("../../data/example_selected/a.swc")
+    test_swc_tree.load("../../output/random_data/move/a/010/move_03.swc")
 
     config = read_json.read_json("..\\..\\config\\branch_metric.json")
     config_schema = read_json.read_json("..\\..\\config\\schemas\\branch_metric_schema.json")
@@ -209,9 +204,6 @@ def branch_leaf_metric(gold_swc_tree, test_swc_tree, config):
     except Exception as e:
         raise Exception("[Error: ]Error in analyzing config json file")
 
-    config["metric_mode"] = 2
-    config["threshold_dis"] = 1
-    config["threshold_mode"] = 2
     branch_result = \
         branch_leaf_metric(test_swc_tree=test_swc_tree, gold_swc_tree=gold_swc_tree, config=config)
     print("---------------Result---------------")
diff --git a/pyneval/metric/length_metric.py b/pyneval/metric/length_metric.py
@@ -179,17 +179,16 @@ def geometry():
     goldTree = swc_node.SwcTree()
     testTree = swc_node.SwcTree()
     sys.setrecursionlimit(10000000)
-    goldTree.load("..\\..\\data\\test_data\\geo_metric_data\\gold_34_23_10.swc")
-    testTree.load("..\\..\\data\\test_data\\geo_metric_data\\test_34_23_10.swc")
+    testTree.load("E:\\00_project\\00_neural_reconstruction\\01_project\PyNeval\data\example_selected\\a.swc")
+    goldTree.load("E:\\00_project\\00_neural_reconstruction\\01_project\PyNeval\output\\random_data\move\\a\\020\move_00.swc")
 
     config = read_json.read_json("..\\..\\config\\length_metric.json")
     config_schema = read_json.read_json("..\\..\\config\\schemas\\length_metric_schema.json")
-
     try:
         jsonschema.validate(config, config_schema)
     except Exception as e:
         raise Exception("[Error: ]Error in analyzing config json file")
-    # config["detail_path"] = "..\\..\\output\\length_output\\length_metric_detail.swc"
+    config["detail_path"] = "..\\..\\output\\length_output\\length_metric_detail.swc"
     
     lm_res = length_metric(gold_swc_tree=goldTree,
                            test_swc_tree=testTree,
diff --git a/pyneval/metric/link_metric.py b/pyneval/metric/link_metric.py
@@ -93,7 +93,7 @@ def link_metric(gold_swc_tree, test_swc_tree, config):
     gold_swc_tree = SwcTree()
     test_swc_tree = SwcTree()
     test_swc_tree.load("..\\..\\data\\test_data\\topo_metric_data\\gold_fake_data4.swc")
-    gold_swc_tree.load("..\\..\\data\\test_data\\topo_metric_data\\test_fake_data4.swc")
+    gold_swc_tree.load("..\\..\\data\\test_data\\topo_metric_data\\gold_fake_data4.swc")
     config = read_json("..\\..\\config\\link_metric.json")
     config_schema = read_json("..\\..\\config\\schemas\\link_metric_schema.json")
 
diff --git a/pyneval/metric/ssd_metric.py b/pyneval/metric/ssd_metric.py
@@ -141,8 +141,8 @@ def ssd_metric(gold_swc_tree: swc_node.SwcTree, test_swc_tree: swc_node.SwcTree,
     gold_tree = swc_node.SwcTree()
 
     sys.setrecursionlimit(10000000)
-    gold_tree.load("..\\..\\data\\test_data\\geo_metric_data\\gold_34_23_10.swc")
-    test_tree.load("..\\..\\data\\test_data\\geo_metric_data\\test_34_23_10.swc")
+    gold_tree.load("E:\\00_project\\00_neural_reconstruction\\01_project\PyNeval\data\example_selected\\a.swc")
+    test_tree.load("E:\\00_project\\00_neural_reconstruction\\01_project\PyNeval\output\\random_data\move\\a\\020\move_00.swc")
 
     config = read_json.read_json("..\\..\\config\\ssd_metric.json")
     config_schema = read_json.read_json("..\\..\\config\\schemas\\ssd_metric_schema.json")
diff --git a/pyneval/metric/utils/km_utils.py b/pyneval/metric/utils/km_utils.py
@@ -26,7 +26,7 @@ def get_simple_lca_length(std_tree, test_gold_dict, node1, node2, switch):
 
     lca_id = std_tree.get_lca(tmp_node1.get_id(), tmp_node2.get_id())
     if lca_id == -1:
-        return DINF
+        return config_utils.DINF
     lca_node = std_id_node_dict[lca_id]
     return tmp_node1.root_length + tmp_node2.root_length - 2 * lca_node.root_length
 
diff --git a/pyneval/tools/optimize/fake_reconstruct.py b/pyneval/tools/optimize/fake_reconstruct.py
@@ -0,0 +1,36 @@
+demo_func = lambda x: x[0] ** 2 + (x[1] - 0.05) ** 2 + x[2] ** 2
+
+# %% Do SA
+from sko.SA import SA
+
+sa = SA(func=demo_func, x0=[1, 1, 0], T_max=1, T_min=1e-9, L=300, max_stay_counter=150)
+best_x, best_y = sa.run()
+print('best_x:', best_x, 'best_y', best_y)
+
+# %% Plot the result
+import matplotlib.pyplot as plt
+import pandas as pd
+
+plt.plot(pd.DataFrame(sa.best_y_history).cummin(axis=0))
+plt.show()
+
+# %%
+from sko.SA import SAFast
+
+sa_fast = SAFast(func=demo_func, x0=[1, 1, 1], T_max=1, T_min=1e-9, q=0.99, L=300, max_stay_counter=150)
+sa_fast.run()
+print('Fast Simulated Annealing: best_x is ', sa_fast.best_x, 'best_y is ', sa_fast.best_y)
+
+# %%
+from sko.SA import SABoltzmann
+
+sa_boltzmann = SABoltzmann(func=demo_func, x0=[1, 1, 1], T_max=1, T_min=1e-9, q=0.99, L=300, max_stay_counter=150)
+sa_boltzmann.run()
+print('Boltzmann Simulated Annealing: best_x is ', sa_boltzmann.best_x, 'best_y is ', sa_fast.best_y)
+
+# %%
+from sko.SA import SACauchy
+
+sa_cauchy = SACauchy(func=demo_func, x0=[1, 1, 1], T_max=1, T_min=1e-9, q=0.99, L=300, max_stay_counter=150)
+sa_cauchy.run()
+print('Cauchy Simulated Annealing: best_x is ', sa_cauchy.best_x, 'best_y is ', sa_cauchy.best_y)
diff --git a/pyneval/tools/optimize/optimize.py b/pyneval/tools/optimize/optimize.py
@@ -0,0 +1,126 @@
+from pyneval.io import read_json
+from pyneval.metric import ssd_metric
+from test.data_builder import dbuilder
+from pyneval.model import swc_node
+from scipy import stats as st
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import axes3d
+import numpy as np
+from sko.SA import SABoltzmann
+import pandas as pd
+
+g_score = -1
+g_gold_tree = None
+g_tar_tree = None
+g_rcn_method = None
+g_metric_method = None
+g_metric_configs = None
+
+
+def fake_gaussian(mean=[0.0, 0.0], cov=[[0.0, 1.0], [1.0, 0.0]], pos=(0,0)):
+    rv = st.multivariate_normal(mean=[1.5, -1], cov=[[0.5, 0],[0, 0.5]])
+    rv2 = st.multivariate_normal(mean=[-0.1, 0.5], cov=[[1, 0],[0, 1]])
+    x = np.empty(shape=(1, 1, 2))
+    x[0,0,0] = pos[0]
+    x[0,0,1] = pos[1]
+    return rv.pdf(x) + rv2.pdf(x)
+
+
+def fake_reconstruction(gold_tree,  rcn_config):
+    res_tree = dbuilder.swc_random_move(swc_tree=gold_tree,
+                                        move_percentage=rcn_config[0],
+                                        move_range=rcn_config[1])
+    return res_tree
+
+
+def metric(gold_tree, test_tree, method, configs):
+    return method(gold_tree, test_tree, configs)
+
+
+def naive_optimize(gold_tree, rcn_method, rcn_configs, current_config, metric_method, metric_configs):
+    """
+    A naive optimization, test every combination of test parameters
+    recursive parameter searching is used for traversing all the combinations.
+    """
+    clen = len(current_config)
+    if clen == len(rcn_configs):
+        # metric and get results
+        # res_tree = fake_reconstruction(gold_tree=gold_tree, method=rcn_method, rcn_config=current_config)
+        # main_score = metric(gold_tree=gold_tree, test_tree=res_tree, method=metric_method, configs=metric_configs)
+        main_score = fake_gaussian(mean=[0.5, -0.3], cov=[[1, 0],[0, 1]], pos=current_config)
+        global g_score
+        if main_score > g_score:
+            g_score = main_score
+            print("max_score = {}, current_score = {}, x = {}, y = {}".format(
+                g_score, main_score, current_config[0], current_config[1])
+            )
+        return None
+
+    for item in rcn_configs[clen]:
+        current_config.append(item)
+        naive_optimize(gold_tree=gold_tree,
+                       rcn_method=rcn_method,
+                       rcn_configs=rcn_configs,
+                       current_config=current_config,
+                       metric_method=metric_method,
+                       metric_configs=metric_configs)
+        current_config.pop()
+    return None
+
+
+def SA_optimize(configs):
+    global g_gold_tree
+    global g_metric_method
+    global g_metric_configs
+
+    res = fake_gaussian(pos=configs)
+    # print("res = {} x = {} y = {}".format(res, configs[0], configs[1]))
+    res_tree = fake_reconstruction(gold_tree=g_gold_tree, rcn_config=configs)
+    main_score = metric(gold_tree=g_tar_tree, test_tree=res_tree, method=g_metric_method, configs=g_metric_configs)
+    print("res = {} x = {} y = {}".format(main_score["recall"], configs[0], configs[1]))
+    return -main_score["recall"]
+
+
+def run_opt(rcn_method, metric_method):
+    global g_gold_tree
+    global g_tar_tree
+    global g_rcn_method
+    global g_metric_method
+    global g_metric_configs
+
+    g_gold_tree = swc_node.SwcTree()
+    g_tar_tree = swc_node.SwcTree()
+    g_gold_tree.load("..\\..\\..\\data\\example_selected\\c.swc")
+    g_tar_tree.load("..\\..\\..\\output\\random_data\move_r\c\\020\move_00.swc")
+    # rcn_configs = read_json.read_json("..\\..\\..\\config\\fake_reconstruction_configs\\branch_metric.json")
+    g_metric_configs = read_json.read_json("..\\..\\..\\config\\ssd_metric.json")
+    g_metric_method = ssd_metric.ssd_metric
+    # cfgs = []
+    # for cfg_name in rcn_configs:
+    #     cfg = rcn_configs[cfg_name]
+    #     cfgs.append(np.linspace(cfg[0], cfg[1], cfg[2]))
+    #
+    # naive_optimize(gold_tree=gold_tree,
+    #                rcn_method=rcn_method,
+    #                rcn_configs=cfgs,
+    #                current_config=[],
+    #                metric_method=metric_method,
+    #                metric_configs=metric_configs)
+    configs = [0, 0]
+    sa_boltzmann = SABoltzmann(func=SA_optimize,
+                               x0=configs, T_max=0.1, T_min=1e-6, q=0.96, L=30, max_stay_counter=150)
+    sa_boltzmann.run()
+    plt.plot(pd.DataFrame(sa_boltzmann.best_y_history).cummin(axis=0))
+    plt.xlabel("iterations")
+    plt.ylabel("score(opposite value)")
+    plt.show()
+
+
+if __name__ == "__main__":
+    # run_opt(fake_reconstruction, ssd_metric.ssd_metric)
+    # print(np.round(g_score, 4))
+    import os
+    cmd = "pyneval --gold ..\\..\\..\\data\\test_data\geo_metric_data\gold_34_23_10.swc --test ..\\..\\..\\data\\test_data\geo_metric_data\\test_34_23_10.swc --metric branch_metric"
+    # ans = os.system("chdir")
+    ans = os.system(cmd)
+    print(type(ans))
diff --git a/setup.py b/setup.py
@@ -17,8 +17,10 @@
                   ("config/schemas", glob.glob('config/schemas/*.json'))],
       install_requires=[
             'anytree>=2.7.2',
-            'numpy>=1.17.3',
-            'rtree>=0.8'
+            'kdtree>=0.16',
+            'numpy>=1.0',
+            'rtree>=0.8',
+            'jsonschema>=3.2.0'
       ],
       entry_points={
           'console_scripts': [
diff --git a/test/data_builder/dbuilder.py b/test/data_builder/dbuilder.py
@@ -49,7 +49,7 @@ def swc_random_delete(swc_tree, move_percentage=None, move_num=None):
 def swc_random_move(swc_tree, move_percentage=None, move_num=None, move_range=1.0, tendency=(1, 1, 1)):
     '''
     :param swc_tree: standard swc tree
-    :param percentage: percentage of nodes to move_5 (range:[0,1])
+    :param percentage: percentage of nodes to move (range:[0,1])
     :param range:stard range is the averange length of edge.
     :param tendency: a tuple to change the direction of the movement
     :return: modified swc tree(different object from the input one)
diff --git a/test/test_model/test_random.py b/test/test_model/test_random.py
diff --git a/test/test_model/visualize/linechart_visual.py b/test/test_model/visualize/linechart_visual.py

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"threshold_dis": 2,`
`3`	`3`	`"threshold_mode": 1,`
`4`		`- "metric_mode": 1,`
`5`	`4`	`"true_positive_type": 3,`
`6`	`5`	`"false_negative_type": 4,`
`7`	`6`	`"false_positive_type": 5`
-Original file line number
+Diff line change
@@ @@ -0,0 +1,4 @@ @@
 +{
 +  "cfg1": [-5, 5, 100],
 +  "cfg2": [-5, 5, 100]
 +}
Original file line number	Diff line number	Diff line change
`@@ -306,3 +306,4 @@ def run(DEBUG=True):`
`306`	`306`
`307`	`307`	`# pyneval --gold .\\data\test_data\geo_metric_data\gold_34_23_10.swc --test .\data\test_data\geo_metric_data\test_34_23_10.swc --metric branch_metric`
`308`	`308`
	`309`	`+# pyneval --gold .\\data\test_data\geo_metric_data\gold_34_23_10.swc --test .\data\test_data\geo_metric_data\test_34_23_10.swc --metric branch_metric`