Final experiments

Author: Neutrino42

.gitignore

@@ -1,10 +1,11 @@
-/out
+/out*
 /result
 /others
 __pycache__
 /.idea
 /evaluation_1
 /fig
+/env
 
 *.jar
 *.txt

analyse.ipynb

@@ -1,5 +1,6 @@
-JAR_VERSION="04ffa0"
-TAG="designed1_deviated_state"
+JAR_VERSION="ef8d28"
+TRACE_FILE="sample_designed2_12o-8c-1111.txt"
+TAG="designed2_unknown"
 IMAGE="nan42/eval"
 TRACE_VOL="trace"
 RESULT_VOL="result"

config.txt

@@ -16,7 +16,7 @@ function run() {
 
   echo ${compare_method}
 
-  for threshold in 5 10 15 20
+  for threshold in 20
   do
     for seed in 100
     do
@@ -26,7 +26,7 @@ function run() {
       --mount source=${result_vol},target=/experiments/runner/result \
       --mount source=${trace_vol},target=/experiments/simulator/trace/prediction \
       --name ${compare_method}_t${threshold}_s${seed} \
-      ${docker_image}:${tag} -t $threshold -s $seed -c $compare_method -w $compare_window &
+      ${docker_image}:${tag} -t $threshold -s $seed -c $compare_method -w $compare_window -u -q &
     done
   done
 }

run.sh

@@ -0,0 +1,26 @@
+from src.runner.Loader import TraceLoader
+from src.runner.Comparator import Comparator
+
+# load real trace
+path_real_trace = "/Users/Nann/workspace/icws2021/src/simulator/traces_real/sample_20o-10c-3333-999.txt"
+Loader = TraceLoader(trace_path=)
+# load
+
+comparator = Comparator(compare_method="utility", k=2)
+comparator.compare( , )
+
+# Analysis here
+plt.plot(np.array(time_list_archive), np.array(dists_list_archive))
+plt.title("position")
+plt.savefig(statistics_dir + "distance_plots{}_{}.pdf".format(seed, human_seed))
+plt.close("all")
+
+plt.plot(np.array(time_list_archive), np.array(dists_knowledge_list_archive))
+plt.title("global knowledge")
+plt.savefig(statistics_dir + "distance_knowledge_plots{}_{}.pdf".format(seed, human_seed))
+plt.close("all")
+
+plt.plot(np.array(time_list_archive), np.array(dists_interaction_list_archive))
+plt.title("interaction")
+plt.savefig(statistics_dir + "distance_interaction_plots{}_{}.pdf".format(seed, human_seed))
+plt.close("all")

src/analysis/Analyse.py

@@ -18,7 +18,7 @@ def __init__(self, rs_dir=None, port=None):
             self.__rs_dir = rs_dir
         else:
             self.__rs_dir = "/Users/Nann/eclipse-workspace/mobileCameras/mobileCameras.rs"
-        for i in range(5):
+        for i in range(10):
             try:
                 if self.__port is not None:
                     self.__gateway = JavaGateway(gateway_parameters=GatewayParameters(port=self.__port))
@@ -36,7 +36,7 @@ def __init__(self, rs_dir=None, port=None):
     def __load(self):
         try:
             self.__runner.load(self.__rs_dir)
-            print("loaded: " + self.__rs_dir)
+            # print("loaded: " + self.__rs_dir)
         except:
             print("ERROR: load config file failed, please check your file path")
             exit(-2)
@@ -53,6 +53,7 @@ def __load(self):
 
     def __run_init(self):
         self.__runner.runInitialize()
+        self.__runner.setOutputStream()
 
     def load_and_init(self):
         try:
@@ -84,6 +85,7 @@ def terminate(self):
         self.__runner.stop()
         self.__runner.cleanUpRun()
         self.__runner.cleanUpBatch()
+        self.__gateway.shutdown()
 
     def get_tick_count(self):
         return self.__gateway.jvm.repast.simphony.engine.environment.RunEnvironment \

src/runner/Analyser.py src/analysis/__init__.pysrc/runner/Analyser.py renamed to src/analysis/__init__.py

@@ -4,13 +4,16 @@
 
 
 class Comparator(object):
-    def __init__(self, compare_method="position"):
+    def __init__(self, compare_method="position", k=2):
         self.__method = compare_method
-        self.__k = 2
+        self.__k = k
 
     def set_compare_method(self, compare_method):
         self.__method = compare_method
 
+    def set_k(self, k):
+        self.__k = k
+
     def compare(self, traces_pre, traces_real):
         """
         Compare two input traces. A trace can be a list or a state.
@@ -34,8 +37,12 @@ def compare(self, traces_pre, traces_real):
             distances = self.__compare_action(traces_pre, traces_real)
         elif self.__method == "position":
             distances =  self.__compare_position(traces_pre, traces_real)
+        elif self.__method == "position_all":
+            distances = self.__compare_position(traces_pre, traces_real, compare_all=True)
         elif self.__method == "interaction":
             distances = self.__compare_interaction(traces_pre, traces_real)
+        elif self.__method == "utility":
+            distances = self.__compare_utility(traces_pre, traces_real)
         else:
             exit(-1)
 
@@ -51,14 +58,18 @@ def __compare_action(self, traces_1, traces_2):
             for ID in state_2["cameras"].keys():
                 action_r = state_2["cameras"][ID]["actions"]
                 action_p = state_1["cameras"][ID]["actions"]
-                d += self.__action_deviation(action_p, action_r)
+                d += self.__action_deviation_v2(action_p, action_r)
             distances.append(float(d)/len(state_2["cameras"]))
         return distances
 
-    def __compare_position(self, traces_pre, traces_real):
+    def __compare_position(self, traces_pre, traces_real, compare_all=False):
         distances = []
-        for state_pre, state_real in zip(traces_pre, traces_real):
-            distances.append(self.__position_deviation(state_pre, state_real))
+        if compare_all is False:
+            for state_pre, state_real in zip(traces_pre, traces_real):
+                distances.append(self.__position_deviation(state_pre, state_real))
+        else:
+            for state_pre, state_real in zip(traces_pre, traces_real):
+                distances.append(self.__position_deviation_all(state_pre, state_real))
         return distances
 
     def __compare_interaction(self, traces_1, traces_2):
@@ -67,6 +78,12 @@ def __compare_interaction(self, traces_1, traces_2):
             distances.append(self.__interaction_deviation(state_1["graph"], state_2["graph"]))
         return distances
 
+    def __compare_utility(self, traces_1, traces_2):
+        distances = []
+        for state_1, state_2 in zip(traces_1, traces_2):
+            distances.append(self.__utility_deviation(state_1, state_2))
+        return distances
+
     def __action_deviation(self, action_1, action_2):
         if action_1["random"] == 1 and action_2["random"] == 1:
             return 0
@@ -94,6 +111,51 @@ def __action_deviation(self, action_1, action_2):
         else:
             return 1
 
+
+    def __action_deviation_v2(self, action_1, action_2):
+        # both random movement
+        if action_1["random"] == 1 and action_2["random"] == 1:
+            return 0
+        # both responding to someone else (and follow)
+        elif action_1["respond"] != -1 and action_2["respond"] != -1:
+            return 0
+        # both notifying someone else
+        elif len(action_1["notify"]) != 0 and len(action_2["notify"]) != 0:
+            return 0
+        # both only following
+        elif action_1["respond"] == -1 and action_2["respond"] == -1 and \
+                len(action_1["notify"]) == 0 and len(action_2["notify"]) == 0:
+            return 0
+        # otherwise
+        else:
+            return 1
+
+    def __position_deviation_all(self, state_p, state_r):  # p for predicted and r for real
+        # store only the value [x,y] in the array, discarding id
+
+        # read all cameras
+        cams_r_array = []
+        cams_p_array = []
+        for cam_id, cam in state_r["cameras"].items():
+            cams_r_array.append([cam["x"], cam["y"]])
+            cam_p = state_p["cameras"].get(cam_id)
+            cams_p_array.append([cam_p["x"], cam_p["y"]])
+        cams_p_array = np.array(cams_p_array)
+        cams_r_array = np.array(cams_r_array)
+
+        # get all objects
+        objs_r = Loader.get_all_objects(state_r)
+        objs_p = Loader.get_all_objects(state_p)
+
+        sorted_objs_r = sorted(objs_r.items())
+        objs_r_array = np.array([item[1] for item in sorted_objs_r])
+        sorted_objs_p = sorted(objs_p.items())
+        objs_p_array = np.array([item[1] for item in sorted_objs_p])
+
+        p_array = np.concatenate([objs_p_array, cams_p_array])
+        r_array = np.concatenate([objs_r_array, cams_r_array])
+        return np.linalg.norm(p_array - r_array)
+
     def __position_deviation(self, state_p, state_r):  # p for predicted and r for real
         # store only the value [x,y] in the array, discarding id
 
@@ -141,6 +203,11 @@ def __interaction_deviation(self, graph_1: list, graph_2: list):
         strengths_2 = [edge['strength'] for edge in graph_2]
         return np.linalg.norm(np.array(strengths_1) - np.array(strengths_2))
 
+    def __utility_deviation(self, state_1, state_2):
+        util_1 = self.calc_k_coverage_value(self.__k, state_1)
+        util_2 = self.calc_k_coverage_value(self.__k, state_2)
+        return np.linalg.norm(np.array(util_1) - np.array(util_2))
+
     def calc_k_coverage_value(self, k, state):
         num_objs = Loader.get_num_objs(state)
         return len(self.filter_k_coverage(k, state)) / float(num_objs)
@@ -163,7 +230,3 @@ def calc_cov_for_objs(self, state):
             cov_objs += obj_list
         return dict(Counter(cov_objs))
 
-    def knowledge_distance(self, k, state_1, state_2):
-        knowledge_1 = self.calc_k_coverage_value(k, state_1)
-        knowledge_2 = self.calc_k_coverage_value(k, state_2)
-        return np.linalg.norm(np.array(knowledge_1) - np.array(knowledge_2))

src/runner/Client.py

@@ -6,11 +6,13 @@
 class Config(object):
     def __init__(self, path):
         self.data = {}
+        self.curr_time = ""
         with open(path, 'r') as f:
             self.data = yaml.safe_load(f)
             if self.data["version"] != "1.0":
                 self.data = {}
             else:
+                self.curr_time = datetime.now().strftime('%Y-%m-%d--%H-%M-%S-%f')[:-3]
                 self.__load()
 
     def __load(self):
@@ -28,6 +30,5 @@ def __parse(self, name):
         new_string = self.data[name]
         for ma in matches:
             if ma.strip() == "time":
-                curr_time = datetime.now().strftime('%Y-%m-%d--%H-%M-%S')
-                new_string = re.sub("\${{.*?}}", curr_time, self.data[name])
+                new_string = re.sub("\${{.*?}}", self.curr_time, self.data[name])
         return new_string

src/runner/Comparator.py

@@ -12,6 +12,14 @@ def get_all_covered_objects(state):
     return cov_objs
 
 
+def get_all_objects(state):
+    covered_objs = get_all_covered_objects(state)
+    uncovered_objs = {}
+    for obj_id, obj_content in state["objects"].items():
+        uncovered_objs[str(obj_id)] = [obj_content["x"], obj_content["y"]]
+    return covered_objs | uncovered_objs  # merge two dictionaries, python 3.9 only.
+
+
 def get_num_cams(state):
     return len(state["cameras"])
 
@@ -33,6 +41,20 @@ def __init__(self, trace_path):
     def set_trace_path(self, trace_path):
         self.__trace_path = trace_path
 
+    def read_trace(self, trace_raw=None):
+        """
+
+        :param trace_raw: raw trace as a string
+        :return:
+        """
+        if trace_raw is None:
+            with open(self.__trace_path, 'r') as f:
+                tmp_traces = self._preprocess_trace(f)
+                return [self._parse_state_for_each_timestep(_state) for _state in tmp_traces]
+        else:
+            tmp_traces = self._preprocess_trace(io.StringIO(trace_raw))
+            return [self._parse_state_for_each_timestep(_state) for _state in tmp_traces]
+
     def _parse_state_for_each_timestep(self, trace):
         """
         :param trace:
@@ -124,15 +146,6 @@ def _parse_state_for_each_timestep(self, trace):
                                             duration=int(uncovered_obj_xml[5]))
         return state
 
-    def read_trace(self, my_string=None):
-        if my_string is None:
-            with open(self.__trace_path, 'r') as f:
-                tmp_traces = self._preprocess_trace(f)
-                return [self._parse_state_for_each_timestep(_state) for _state in tmp_traces]
-        else:
-            tmp_traces = self._preprocess_trace(io.StringIO(my_string))
-            return [self._parse_state_for_each_timestep(_state) for _state in tmp_traces]
-
     def _preprocess_trace(self, f):
         lines = f.readlines()