Benchmarking

Author: melkebir

result/sims/machina/evaluate_mig_history.py

@@ -0,0 +1,103 @@
+#!/usr/bin/python
+import sys
+import re
+
+def get_mutations(edge_list, u):
+    # find parent
+    s = re.split("_|;|^", u)
+    mutations = set()
+    for i in s:
+        if i.isdigit():
+            mutations.add(int(i))
+    #print mutations
+
+    for edge in edge_list:
+        uu = edge[0]
+        vv = edge[1]
+        if vv == u:
+            return mutations | get_mutations(edge_list, uu)
+
+    return mutations
+
+def parse_clone_tree(filename_T, filename_l):
+    edges = []
+    with open(filename_T) as f:
+        for line in f:
+            s = line.rstrip("\n").split(" ")
+            edges += [(s[0], s[1])]
+
+    labeling = {}
+    with open(filename_l) as f:
+        for line in f:
+            s = line.rstrip("\n").split(" ")
+            labeling[s[0]] = s[1]
+
+    # find migration edges
+    migration_edges = []
+    for (u, v) in edges:
+        if labeling[u] != labeling[v]:
+            migration_edges += [(u,v)]
+
+    return edges, migration_edges
+
+def identify_seeding_clones(edge_list, migration_edge_list):
+    res = set()
+    for (u,v) in migration_edge_list:
+        muts_u = get_mutations(edge_list, u)
+        muts_v = get_mutations(edge_list, v)
+        res.add(frozenset(muts_u))
+
+    return res
+
+def parse_migration_graph(filename_G):
+    edges = []
+    with open(filename_G) as f:
+        for line in f:
+            s = line.rstrip("\n").split(" ")
+            edges += [(s[0], s[1])]
+
+    return edges
+
+def multi_graph_to_set(edge_list):
+    count = {}
+    res = set()
+    for edge in edge_list:
+        if edge not in count:
+            count[edge] = 1
+        else:
+            count[edge] += 1
+        res.add((edge[0], edge[1], count[edge]))
+    return res
+
+if __name__ == "__main__":
+    if len(sys.argv) != 7:
+        sys.stderr.write("Usage: %s <SIMULATED_CLONE_TREE> <SIMULATED_VERTEX_LABELING> <SIMULATED_MIGRATION_GRAPH>"
+                         " <INFERRED_CLONE_TREE> <INFERRED_VERTEX_LABELING> <INFERRED_MIGRATION_GRAPH>\n" % sys.argv[0])
+        sys.exit(1)
+
+    edges_simulated, mig_edges_simulated = parse_clone_tree(sys.argv[1], sys.argv[2])
+    seeding_clones_simulated = identify_seeding_clones(edges_simulated, mig_edges_simulated)
+
+    edges_inferred, mig_edges_inferred = parse_clone_tree(sys.argv[4], sys.argv[5])
+    seeding_clones_inferred = identify_seeding_clones(edges_inferred, mig_edges_inferred)
+
+    recall = float(len(seeding_clones_inferred & seeding_clones_simulated)) / float(len(seeding_clones_simulated))
+    precision = float(len(seeding_clones_inferred & seeding_clones_simulated)) / float(len(seeding_clones_inferred))
+    F = 2.0 / ((1.0 / recall) + (1.0 / precision))
+
+    edge_set_G_simulated = set(parse_migration_graph(sys.argv[3]))
+    edge_set_G_inferred = set(parse_migration_graph(sys.argv[6]))
+
+    edge_multiset_G_simulated = multi_graph_to_set(parse_migration_graph(sys.argv[3]))
+    edge_multiset_G_inferred = multi_graph_to_set(parse_migration_graph(sys.argv[6]))
+
+    recall_G = float(len(edge_set_G_inferred & edge_set_G_simulated)) / float(len(edge_set_G_simulated))
+    precision_G = float(len(edge_set_G_inferred & edge_set_G_simulated)) / float(len(edge_set_G_inferred))
+
+    recall_G2 = float(len(edge_multiset_G_inferred & edge_multiset_G_simulated)) / float(len(edge_multiset_G_simulated))
+    precision_G2 = float(len(edge_multiset_G_inferred & edge_multiset_G_simulated)) / float(len(edge_multiset_G_inferred))
+
+    F_G = 2.0 / ((1.0 / recall_G) + (1.0 / precision_G))
+    F_G2 = 2.0 / ((1.0 / recall_G2) + (1.0 / precision_G2))
+
+    print ",".join(map(str, [recall, precision, F, recall_G, precision_G, F_G, recall_G2, precision_G2, F_G2]))

result/sims/machina/extract_minimum.py

@@ -0,0 +1,26 @@
+#!/usr/bin/python
+import sys
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        sys.stderr.write("Usage: %s <MACHINA_PMH_CTI_RESULT>\n" % sys.argv[0])
+        sys.exit(1)
+
+    trees = set()
+    min_score = (100,100,100)
+    with open(sys.argv[1]) as f:
+        for line in f:
+            s = line.rstrip("\n").split("\t")
+            idx = int(s[0].rstrip("-"))
+            if s[2] != '-':
+                score = (int(s[2]), int(s[3]), int(s[4]))
+                pattern = s[1].lstrip("(").rstrip(")").split(", ")[-1]
+                if pattern != "R": continue
+                if score < min_score:
+                    min_score = score
+                    trees = set()
+                if score == min_score:
+                    trees.add((idx, pattern, s[5]))
+
+    for t in trees:
+        print ",".join(map(str, [t[0], t[1], t[2]] + list(min_score)))

result/sims/machina/process_pmh_cti.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+if [ ! $# -eq 3 ]
+then
+    echo "Usage: $0 <RESULT_DIR> <rf_executable> <m>" >&2
+    exit 1
+fi
+m=$3
+
+echo "pattern,seed,mut_tree,enforced,inferred,mu,gamma,sigma,method,RF,recallT,precisionT,FscoreT,recallG,precisionG,FscoreG,recallMultiG,precisionMultiG,FscoreMultiG"
+for f in $1/*.txt
+do
+    d=`basename $f .txt`
+    p=$(echo $d | sed -e s/_.*//g)
+    s=$(echo $d | sed -e s/.*_//g)
+    for t in `python extract_minimum.py $f`
+    do
+        pattern=$(echo $t | cut -d',' -f2)
+        idx=$(echo $t | cut -d',' -f1)
+	rf=$(echo -n $($2 ../../../data/sims/${m}/$p/T_seed$s.tree ../../../data/sims/$m/$p/T_seed$s.labeling $1/$d/${idx}-T-P-${pattern}.tree $1/$d/${idx}-T-P-${pattern}.labeling | tail -n 1 | cut -d' ' -f3))
+
+        if [ $p == "mS" ];
+        then
+            echo -n $p,
+        else
+            echo -n p$p,
+        fi
+
+        echo -n $s,$t,MACHINA,$rf,
+        python evaluate_mig_history.py ../../../data/sims/${m}/$p/T_seed${s}.tree ../../../data/sims/$m/$p/T_seed${s}.vertex.labeling ../../../data/sims/$m/$p/G_seed${s}.tree $1/${d}/${idx}-T-P-${pattern}.tree $1/${d}/${idx}-T-P-${pattern}.labeling $1/${d}/${idx}-G-P-${pattern}.tree
+       	#tail -n 1 ${p}_seed${s}.RF.txt | cut -d' ' -f3  >> results_m7.txt
+    done
+done
+