def fillAspect(aspectj_setup_dir, monitor_setup_dir, gen_monitor_setup_dir):
"""
Fills the user-defined parts of a generated .aj file.
The file should be called unittestMonitorAspect.aj file.
Args:
aspectj_setup_dir (str): The destination directory for the
filled .aj file.
monitor_setup_dir (str): Input directory that contains two files:
* import.txt: should contain the code that replaces the
"// add your own imports." comment in the .aj file.
* ajcode.txt: should contain the code that replaces the
"// Implement your code here." comment in the .aj file.
gen_monitor_dir (str): The input directory, which must a
a single unittestMonitorAspect.aj file.
"""
tools.progress("Fill in AspectJ template")
aspect_file_name = "unittestMonitorAspect.aj"
aspect_file_path = os.path.join(gen_monitor_setup_dir, aspect_file_name)
aspectContent = tools.readFile(aspect_file_path)
aspectContent = aspectContent.replace(
"// add your own imports.",
tools.readFile(os.path.join(monitor_setup_dir, "import.txt")))
aspectContent = aspectContent.replace(
"// Implement your code here.",
tools.readFile(os.path.join(monitor_setup_dir, "ajcode.txt")))
tools.writeFile(os.path.join(aspectj_setup_dir, aspect_file_name),
aspectContent)
def translate(pcompiler_dir, p_spec_dir, gen_monitor_dir, aspectj_dir):
"""
Translates a P spec to RVM code.
Args:
pcompiler_dir (str): The root directory for the P compiler
repository.
p_spec_dir (str): The directory containing the P spec.
It should contain exactly one .p file.
gen_monitor_dir (str): The directory in which to place
the Rvm files.
Raises:
SubprocessError if the P compiler returned an error code.
Exception if the p_spec_dir contained no .p file or more
than one .p file
"""
tools.progress("Run the PCompiler...")
p_spec_paths = glob.glob(os.path.join(p_spec_dir, "*.p"))
if len(p_spec_paths) != 1:
raise Exception("Expected a single p spec")
p_spec_path = p_spec_paths[0]
runPc(pcompiler_dir, [
p_spec_path, "-g:RVM",
"-o:%s" % gen_monitor_dir,
"-a:%s" % aspectj_dir
])
for f in glob.glob(os.path.join(p_spec_dir, "*.aj")):
shutil.copy(f, aspectj_dir)
def runMonitor(rvmonitor_bin, gen_monitor_dir, java_dir):
"""
Translates a .rvm file to Java.
Args:
rvmonitor_bin (str): The directory containing the rv-monitor tool.
gen_monitor_dir (str): The directory containing the .rvm file.
It must contain exactly one .rvm file and it must contain
an .aj file associated with it.
This directory is treated as a temporary directory (i.e. the
Java files are generated here before being copied to the
java_dir).
java_dir (str): The directory in which to place the generated
Java files.
Raises:
SubprocessError if the rv-monitor tool returned an error.
Exception if the input directory contains no rvm file or more
than one.
"""
tools.progress("Run RVMonitor")
monitor_binary = os.path.join(rvmonitor_bin, "rv-monitor")
rvm_file_paths = glob.glob(os.path.join(gen_monitor_dir, "*.rvm"))
if len(rvm_file_paths) != 1:
raise Exception("Expected a single rvm spec")
rvm_file_path = rvm_file_paths[0]
tools.runNoError([monitor_binary, "--controlAPI", "-merge", rvm_file_path])
for f in glob.glob(os.path.join(gen_monitor_dir, "*.java")):
shutil.copy(f, java_dir)
def translate(pcompiler_dir, p_spec_dir, gen_monitor_dir):
tools.progress("Run the PCompiler...")
p_spec_paths = glob.glob(os.path.join(p_spec_dir, "*.p"))
if len(p_spec_paths) != 1:
raise Exception("Expected a single p spec")
p_spec_path = p_spec_paths[0]
runPc(pcompiler_dir, [p_spec_path, "-g:RVM", "-o:%s" % gen_monitor_dir])
def runGetConsistency():
tools.progress("Running the getconsistency tests...")
tools.runNoError(["mvn", "clean", "test", "-Dtest=db.GetConsistentTest"])
tools.runNoError(
["mvn", "clean", "test", "-Dtest=db.GetInconsistent1Test"])
tools.runNoError(
["mvn", "clean", "test", "-Dtest=db.GetInconsistent2Test"])
tools.runNoError(["mvn", "clean"])
def initGitModules():
"""
Runs "git submodule update --init --recursive".
Raises:
SubprocessError if the git command returns an error code.
"""
tools.progress("Updating the RV-Monitor submodules...")
tools.runNoError(["git", "submodule", "update", "--init", "--recursive"])
def buildRvMonitor():
"""
Builds and installs the RV-Monitor tool in the local Maven repository.
Raises:
SubprocessError if the mvn command returns an error code.
"""
tools.progress("Building RV-Monitor...")
tools.runNoError(["mvn", "-B", "clean", "install", "-DskipTests"])
def runMonitor(rvmonitor_bin, gen_monitor_dir, java_dir):
tools.progress("Run RVMonitor")
monitor_binary = os.path.join(rvmonitor_bin, "rv-monitor")
rvm_file_paths = glob.glob(os.path.join(gen_monitor_dir, "*.rvm"))
if len(rvm_file_paths) != 1:
raise Exception("Expected a single rvm spec")
rvm_file_path = rvm_file_paths[0]
tools.runNoError([monitor_binary, "-merge", rvm_file_path])
for f in glob.glob(os.path.join(gen_monitor_dir, "*.java")):
shutil.copy(f, java_dir)
def runTwoPhaseCommit():
tools.progress("Running the twophasecommit tests...")
tools.runNoError(
["mvn", "clean", "test", "-Dtest=twophasecommit.PrepareSuccessTest"])
tools.runNoError(
["mvn", "clean", "test", "-Dtest=twophasecommit.PrepareFailureTest"])
tools.runNoError([
"mvn", "clean", "test", "-Dtest=twophasecommit.BuggyPrepareFailureTest"
])
tools.runNoError(["mvn", "clean"])
def fillAspect(aspectj_dir, gen_monitor_dir):
tools.progress("Fill in AspectJ template")
aspect_file_paths = glob.glob(os.path.join(gen_monitor_dir, "*.aj"))
if len(aspect_file_paths) != 1:
raise Exception("Expected a single aspectJ template")
aspect_file_path = aspect_file_paths[0]
aspectContent = readFile(aspect_file_path)
aspectContent = aspectContent.replace("// add your own imports.",
readFile("import.txt"))
aspectContent = aspectContent.replace("// Implement your code here.",
readFile("ajcode.txt"))
writeFile(aspect_file_path, aspectContent)
for f in glob.glob(os.path.join(gen_monitor_dir, "*.aj")):
shutil.copy(f, aspectj_dir)
def runTests(test_name):
"""
Uses Maven to run a Rvm unit-test.
Args:
test_name (str): The name of the test, used for user-friendly
messages.
Raises:
SubprocessError if mvn returns an error code.
"""
tools.progress("Running the %s test(s)..." % test_name)
tools.runNoError(["mvn", "-B", "clean", "test"])
tools.runNoError(["mvn", "-B", "clean"])
def initialize(self):
f = open(self.ret_file, 'r')
data_q = json.load(f)
abstracts_needed = set()
for i in range(len(data_q["questions"])):
abstracts_needed = abstracts_needed | set(data_q["questions"][i]["retrieved"])
f.close()
print "Collecting Abstracts.."
f = open(self.corpus_file, 'r')
corpus = ijson.items(f, 'articles.item')
for article in corpus:
pmid = article["pmid"]
if pmid in abstracts_needed:
self.corpus_index[pmid] = article["title"] + ' ' + article["abstractText"]
abstracts_needed.remove(pmid)
if not abstracts_needed:
break
f.close()
print len(self.corpus_index)
q_array_q = []
q_array_d = []
q_array_max = []
print "Reranking.."
n_questions = len(data_q["questions"])
for i in range(n_questions):
#print i
progress(i+1, n_questions, 'questions')
q_id = data_q["questions"][i]["id"]
q_body = data_q["questions"][i]["body"]
q_retrieved = data_q["questions"][i]["retrieved"]
retr_array_q, retr_array_d, retr_array_max = self.rerank(q_body, q_retrieved)
q_array_q.append(Question(q_body, q_id, [x[0] for x in retr_array_q], [x[1] for x in retr_array_q]))
q_array_d.append(Question(q_body, q_id, [x[0] for x in retr_array_d], [x[1] for x in retr_array_d]))
q_array_max.append(Question(q_body, q_id, [x[0] for x in retr_array_max], [x[1] for x in retr_array_max]))
with open('.'.join(self.ret_file.split('.')[:-1]) + '_RWMD_Q.json', 'w+') as outfile:
outfile.write(json.dumps({"questions":[ob.__dict__ for ob in q_array_q]}, indent=2))
with open('.'.join(self.ret_file.split('.')[:-1]) + '_RWMD_D.json', 'w+') as outfile:
outfile.write(json.dumps({"questions":[ob.__dict__ for ob in q_array_d]}, indent=2))
with open('.'.join(self.ret_file.split('.')[:-1]) + '_RWMD_MAX.json', 'w+') as outfile:
outfile.write(json.dumps({"questions":[ob.__dict__ for ob in q_array_max]}, indent=2))
def main(self):
chunks = split_list(range(len(self.idmap)), self.n_chunks)
q_centroids, question_details = self.load_questions_matrix()
q_arrays = []
c = 0 # Number of current chunk
for chunk in chunks:
start_row = chunk[0]
n_rows = len(chunk)
corpus_centroids = read_npy_chunk(centroids_file, start_row, n_rows)
q_arrays.append(self.get_chunk_nns(corpus_centroids, q_centroids, question_details, chunk))
c += 1
progress(c, len(chunks), 'chunks')
self.reorder(q_arrays)
return
def runTests(parallelism, test_names, temporary_directory, command_creator):
"""Runs a test suite.
Args:
parallelism (int): maximum number of tests to run in parallel.
test_names (list of string): the names of all tests in the suite.
temporary_directory (string): path of a directory for temporary files.
command_creator (func(string, string) : list of string): function that
receives a temporary directory and a test name and produces the
command which runs that test.
Returns:
0 for success, 1 for failure.
"""
running = []
failed = []
test_count = len(test_names)
while running or test_names:
time.sleep(0.1) # 0.1 sec
new_running = []
for test in running:
if test.isRunning():
new_running.append(test)
elif test.failed():
test.closeAndPrintFailure()
failed.append(test)
else:
print("%s finished" % test.name())
test.close()
running = new_running
while test_names and len(running) < parallelism:
print("Starting: %s" % test_names[0])
running.append(
Test(test_names[0], temporary_directory, command_creator))
test_names = test_names[1:]
if failed:
tools.progress("Finished running, %d out of %d tests failed." %
(len(failed), test_count))
return 1
else:
tools.progress("Finished running, all tests passed.")
return 0
def translate(script_dir, root_dir, gen_monitor_setup_dir):
"""
Translates a `spec.p` file to RVM code.
Args:
script_dir (str): Input directory containing the `spec.p` file.
root_dir (str): The root directory for the P compiler
repository.
gen_monitor_setup_dir (str): Output directory that will contain
the generated files.
Raises:
SubprocessError if the P compiler returned an error code.
"""
tools.progress("Run the PCompiler...")
runPc(root_dir, [os.path.join(script_dir, "spec.p"), "-g:RVM", "-o:%s" % gen_monitor_setup_dir])
def main(argv):
if len(argv) == 0:
parallelism = 3 * tools.findAvailableCpus() / 2
elif len(argv) == 1:
parallelism = int(argv[0])
else:
usageError()
temp_dir = tempfile.mkdtemp()
tools.progress("Temporary directory: %s" % temp_dir)
script_dir = os.path.dirname(os.path.abspath(__file__))
exit_code = paralleltests.runTests(
parallelism,
getTests(),
temp_dir,
lambda temp_dir, test_name: buildCommand(script_dir, temp_dir, test_name))
shutil.rmtree(temp_dir)
sys.exit(exit_code)
def main(self):
chunks = split_list(range(len(self.idmap)), self.n_chunks)
q_centroids, question_details = self.load_questions_matrix()
q_arrays = []
c = 0 # Number of current chunk
for chunk in chunks:
start_row = chunk[0]
n_rows = len(chunk)
corpus_centroids = read_npy_chunk(centroids_file, start_row,
n_rows)
q_arrays.append(
self.get_chunk_nns(corpus_centroids, q_centroids,
question_details, chunk))
c += 1
progress(c, len(chunks), 'chunks')
self.reorder(q_arrays)
return
def createRvm(rvmonitor_bin, gen_monitor_setup_dir, java_dir):
"""
Compiles a rvm file to java.
Args:
rvmonitor_bin (str): Directory containing the rv-monitor binary.
gen_monitor_setup_dir (str): Input directory containing a file
called "unittest.rvm". The file will be changed during the
call.
java_dir: Destination directory for the generated Java files
Raises:
SubprocessError if the rv-monitor tool returned an error code.
"""
tools.progress("Run RVMonitor")
monitor_binary = os.path.join(rvmonitor_bin, "rv-monitor")
rvm_file = os.path.join(gen_monitor_setup_dir, "unittest.rvm")
addRvmExceptions(rvm_file)
tools.runNoError([monitor_binary, "-merge", "-d", java_dir, rvm_file])
def fillAspect(aspectj_dir, gen_monitor_dir):
"""
Fills the user-defined parts of a generated .aj file.
The current directory should contain two files:
* import.txt: should contain the code that replaces the
"// add your own imports." comment in the .aj file.
* ajcode.txt: should contain the code that replaces the
"// Implement your code here." comment in the .aj file.
The fillAspect function replaces the comments mentioned above in
the .aj file, and copies the result to the destination directory.
Args:
aspectj_dir (str): The destination directory for the
filled .aj file.
gen_monitor_dir (str): The input directory, which must contain
a single .aj file
Raises:
Exception if the input directory does not contain exactly
one .aj file.
"""
tools.progress("Fill in AspectJ template")
aspect_file_paths = glob.glob(os.path.join(gen_monitor_dir, "*.aj"))
if len(aspect_file_paths) != 1:
raise Exception("Expected a single aspectJ template")
aspect_file_path = aspect_file_paths[0]
aspectContent = tools.readFile(aspect_file_path)
aspectContent = aspectContent.replace("// add your own imports.",
tools.readFile("import.txt"))
aspectContent = aspectContent.replace("// Implement your code here.",
tools.readFile("ajcode.txt"))
aspect_file_name = os.path.basename(aspect_file_path)
tools.writeFile(os.path.join(aspectj_dir, aspect_file_name), aspectContent)
def closeAndPrintFailure(self):
assert not self.isRunning()
self.close()
tools.progress("Test %s failed!" % self.__name)
print('')
tools.progress("Stdout:")
print(''.join(self.__stdout))
print('')
tools.progress("Stderr:")
print(''.join(self.__stderr))
print('')
print('')
def train_epoch(_epoch, dataloader, model, loss_function):
# switch to train mode -> enable regularization layers, such as Dropout
model.train()
running_loss = 0.0
for i_batch, sample_batched in enumerate(dataloader, 1):
# get the inputs (batch)
inputs, topics, labels, lengths, topic_lengths, weights, indices = sample_batched
# sort batch (for handling inputs of variable length)
lengths, (inputs, labels, topics) = sort_batch(lengths, (inputs, labels, topics))
# convert to CUDA Variables
if torch.cuda.is_available():
inputs = Variable(inputs.cuda())
topics = Variable(topics.cuda())
labels = Variable(labels.cuda())
lengths = Variable(lengths.cuda())
topic_lengths = Variable(topic_lengths.cuda())
else:
inputs = Variable(inputs)
topics = Variable(topics)
labels = Variable(labels)
topic_lengths = Variable(topic_lengths)
# 1 - zero the gradients
optimizer.zero_grad()
# 2 - forward pass: compute predicted y by passing x to the model
outputs = model(inputs, topics, lengths, topic_lengths)
# 3 - compute loss
loss = loss_function(outputs, labels)
# 4 - backward pass: compute gradient wrt model parameters
loss.backward()
# 5 - update weights
optimizer.step()
running_loss += loss.data[0]
# print statistics
progress(loss=loss.data[0],
epoch=_epoch,
batch=i_batch,
batch_size=BATCH_SIZE,
dataset_size=len(loader_train.sampler.indices))
# `clip_grad_norm` helps prevent the exploding gradient problem in RNNs / LSTMs.
torch.nn.utils.clip_grad_norm(model.parameters(), clip)
try:
for p in model.parameters():
if p.grad is not None:
p.data.add_(-lr, p.grad.data)
except ValueError:
print("'NoneType' object has no attribute 'data'")
return running_loss / i_batch
def runTwoPhaseCommit():
tools.progress("Running the twophasecommit tests...")
tools.runNoError(
["mvn", "clean", "test", "-Dtest=twophasecommit.TwoPhaseCommitTest"])
tools.runNoError(["mvn", "clean"])
def fit_network(self,
e_b,
e_n,
distance_toremove_edge,
l,
a,
d,
passes=1,
plot_evolution=False):
# logging variables
accumulated_local_error = []
global_error = []
network_order = []
network_size = []
total_units = []
self.units_created = 0
# 0. start with two units a and b at random position w_a and w_b
w_a = [np.random.uniform(-2, 2) for _ in range(np.shape(self.data)[1])]
w_b = [np.random.uniform(-2, 2) for _ in range(np.shape(self.data)[1])]
self.network = nx.Graph()
self.network.add_node(self.units_created, vector=w_a, error=0)
self.units_created += 1
self.network.add_node(self.units_created, vector=w_b, error=0)
self.units_created += 1
# 1. iterate through the data
sequence = 0
for p in range(passes):
tools.progress(p, passes)
np.random.shuffle(self.data)
steps = 0
for observation in self.data:
# 2. find the nearest unit s_1 and the second nearest unit s_2
nearest_units = self.find_nearest_units(observation)
s_1 = nearest_units[0]
s_2 = nearest_units[1]
# 3. increment the age of all edges emanating from s_1
for u, v in self.network.edges(nbunch=[s_1]):
attributes = self.network[u][v]
self.network.add_edge(u, v, age=attributes['age'] + 1)
# 4. add the squared distance between the observation and the nearest unit in input space
self.network.node[s_1]['error'] += spatial.distance.euclidean(
observation, self.network.node[s_1]['vector'])**2
# 5 .move s_1 and its direct topological neighbors towards the observation by the fractions
# e_b and e_n, respectively, of the total distance
update_w_s_1 = e_b * (np.subtract(
observation, self.network.node[s_1]['vector']))
self.network.node[s_1]['vector'] = np.add(
self.network.node[s_1]['vector'], update_w_s_1)
update_w_s_n = e_n * (np.subtract(
observation, self.network.node[s_1]['vector']))
for neighbor in self.network.neighbors(s_1):
self.network.node[neighbor]['vector'] = np.add(
self.network.node[neighbor]['vector'], update_w_s_n)
# 6. if s_1 and s_2 are connected by an edge, set the age of this edge to zero
# if such an edge doesn't exist, create it
self.network.add_edge(s_1, s_2, age=0)
# 7. remove edges with an age larger than a_max
# if this results in units having no emanating edges, remove them as well
self.prune_connections(distance_toremove_edge)
# 8. if the number of steps so far is an integer multiple of parameter l, insert a new unit
steps += 1
if steps % l == 0:
if plot_evolution and len(self.network.nodes) > 3:
self.plot_network2("pass" + str(sequence))
sequence += 1
# 8.a determine the unit q with the maximum accumulated error
q = 0
error_max = 0
for u in self.network.nodes():
if self.network.node[u]['error'] > error_max:
error_max = self.network.node[u]['error']
q = u
# 8.b insert a new unit r halfway between q and its neighbor f with the largest error variable
f = -1
largest_error = -1
for u in self.network.neighbors(q):
if self.network.node[u]['error'] > largest_error:
largest_error = self.network.node[u]['error']
f = u
w_r = 0.5 * (np.add(self.network.node[q]['vector'],
self.network.node[f]['vector']))
r = self.units_created
self.units_created += 1
# 8.c insert edges connecting the new unit r with q and f
# remove the original edge between q and f
self.network.add_node(r, vector=w_r, error=0)
self.network.add_edge(r, q, age=0)
self.network.add_edge(r, f, age=0)
self.network.remove_edge(q, f)
# 8.d decrease the error variables of q and f by multiplying them with a
# initialize the error variable of r with the new value of the error variable of q
self.network.node[q]['error'] *= a
self.network.node[f]['error'] *= a
self.network.node[r]['error'] = self.network.node[q][
'error']
# 9. decrease all error variables by multiplying them with a constant d
error = 0
for u in self.network.nodes:
error += self.network.node[u]['error']
accumulated_local_error.append(error)
network_order.append(self.network.order())
network_size.append(self.network.size())
total_units.append(self.units_created)
for u in self.network.nodes():
self.network.node[u]['error'] *= d
if self.network.degree(nbunch=[u]) == 0:
print(u)
global_error.append(self.compute_global_error())
plt.clf()
plt.title('Accumulated local error')
plt.xlabel('iterations')
plt.plot(range(len(accumulated_local_error)), accumulated_local_error)
plt.savefig('visualization/accumulated_local_error.png')
plt.clf()
plt.title('Global error')
plt.xlabel('passes')
plt.plot(range(len(global_error)), global_error)
plt.savefig('visualization/global_error.png')
plt.clf()
plt.title('Neural network properties')
plt.plot(range(len(network_order)),
network_order,
label='Network order')
plt.plot(range(len(network_size)), network_size, label='Network size')
plt.legend()
plt.savefig('visualization/network_properties.png')
def runGetConsistency():
tools.progress("Running the getconsistency tests...")
tools.runNoError(["mvn", "clean", "test", "-Dtest=TwoPCTest"])
tools.runNoError(["mvn", "clean", "test", "-Dtest=TwoPCPhase1FailureTest"])
tools.runNoError(["mvn", "clean"])
def main():
"""Main"""
print("============ Prep ===========")
print("Reading Directories")
a = pathlib.Path(set_a)
b = pathlib.Path(set_b)
i = pathlib.Path(images)
a_infos = list(a.glob(f"*.txt"))
b_infos = list(b.glob(f"*.txt"))
all_imgs = list(i.glob(f"*.png"))
print("Finding Intersection...")
a_stems = [path.stem for path in a_infos] if not ignore_visit else [
path.stem.split("_")[0] for path in a_infos
]
b_stems = [path.stem for path in b_infos] if not ignore_visit else [
path.stem.split("_")[0] for path in b_infos
]
im_stems = [path.stem for path in all_imgs] if not ignore_visit else [
path.stem.split("_")[0] for path in b_infos
]
if set_eq:
e = pathlib.Path(set_eq)
e_infos = list(e.glob(f"*.txt"))
e_stems = [path.stem for path in e_infos] if not ignore_visit else [
path.stem.split("_")[0] for path in e_infos
]
intersection = (((set(a_stems) & set(b_stems)) & set(im_stems))
& set(e_stems))
else:
intersection = (set(a_stems) & set(b_stems)) & set(im_stems)
a_infos = [
inf for inf in a_infos
if (inf.stem if not ignore_visit else inf.stem.split("_")[0]
) in intersection
]
b_infos = [
inf for inf in b_infos
if (inf.stem if not ignore_visit else inf.stem.split("_")[0]
) in intersection
]
all_imgs = [
im for im in all_imgs
if (im.stem if not ignore_visit else im.stem.split("_")[0]
) in intersection
]
print("Building Scan Objects...")
pairs = []
for a, b, im in zip(a_infos, b_infos, all_imgs):
a_scan = Scan.from_files(im, a)
b_scan = Scan.from_files(im, b)
pairs.append((a_scan, b_scan))
print(f"{len(pairs)} Scans will be considered.")
if euclidean:
print("====== Euclidean Distance ======")
print("Finding Distances Between Scans...")
e_dists = []
for idx, pair in enumerate(pairs):
progress(idx, len(pairs))
dist = pair[0].euclidean_distance(pair[1])
e_dists.append(dist)
print("Statistics...")
e_dists = np.array(list(zip(e_dists, pairs)), dtype=object)
srt = e_dists[e_dists[:, 0].argsort()]
print(f"Top {top} Farthest:")
for idx, p in enumerate(srt[-top:][::-1]):
dist = p[0]
a = p[1][0]
b = p[1][1]
print(
f"- {dist: 0.2f} : {a.patient} ({a.info_path} <> {b.info_path})"
)
print(f"Average: {np.average(srt[:, 0])}")
print(f"Min: {np.min(srt[:, 0])}")
print(f"Max: {np.max(srt[:, 0])}")
print(f"Median: {np.median(srt[:, 0])}")
if dice:
print("======== Sørensen–Dice =========")
print("Finding Distances Between Scans...")
if mp:
with Pool(cpu_count() - 1) as pool:
results = pool.starmap(_mp_work, pairs)
d_dists = [r[0] for r in results]
joint_threshold_count = [r[1] for r in results]
else:
d_dists = []
joint_threshold_count = []
for idx, pair in enumerate(pairs):
progress(idx, len(pairs))
dist, tpr_count = pair[0].dice_similarity(
pair[1], count_over=tpr_threshold)
d_dists.append(dist)
joint_threshold_count.append(tpr_count)
print("Statistics...")
d_dists = np.array(list(zip(d_dists, pairs)), dtype=object)
srt = d_dists[d_dists[:, 0].argsort()]
joint_threshold_sum = np.sum(np.array(joint_threshold_count))
joint_tpr = joint_threshold_sum / (len(pairs) * 12
) # 12 joints per hand
print(f"Joint TPR: {joint_tpr}")
hand_threshold_sum = np.count_nonzero(
np.array(joint_threshold_count) == 12) # All joints over threshold
hand_tpr = hand_threshold_sum / len(pairs)
print(f"Hand TPR: {hand_tpr}")
print()
print(f"Top {top} Dissimilar:")
for idx, p in enumerate(srt[:top]):
dist = p[0]
a = p[1][0]
b = p[1][1]
print(
f"- {dist: 0.2f} : {a.patient} ({a.info_path} <> {b.info_path})"
)
print(f"Top {top} Similar:")
for idx, p in enumerate(srt[-top:]):
dist = p[0]
a = p[1][0]
b = p[1][1]
print(
f"- {dist: 0.2f} : {a.patient} ({a.info_path} <> {b.info_path})"
)
print(f"Average: {np.average(srt[:, 0])}")
print(f"Min: {np.min(srt[:, 0])}")
print(f"Max: {np.max(srt[:, 0])}")
print(f"Median: {np.median(srt[:, 0])}")
if meta:
print("====== Meta Statistics =========")
e_list = list(e_dists[:, 0])
d_list = list(d_dists[:, 0])
print(
f"Coef. Corr. Dice & Euclidean: {np.corrcoef(e_list, d_list)[0][1]}"
)
if joint_stats:
print("====== Joint < TPR Threshold Statistics ======")
joint_pairs = []
for pair in pairs:
size = pair[0].image.size
for a, b in zip(pair[0].joints, pair[1].joints):
joint_pairs.append((a, b, size))
if mp:
with Pool(cpu_count() - 1) as pool:
results = pool.starmap(_joint_mp_work, joint_pairs)
d_j_dists = [r[0] for r in results]
d_j_labels = [r[1] for r in results]
else:
d_j_dists = []
d_j_labels = []
for idx, pair in enumerate(joint_pairs):
progress(idx, len(joint_pairs))
dist, name = pair[0].dice_similarity(pair[1],
pair[2],
return_name=True)
d_j_dists.append(dist)
d_j_labels.append(name)
miss_counts = {}
for dist, label in zip(d_j_dists, d_j_labels):
if dist < tpr_threshold:
if label not in miss_counts.keys():
miss_counts[label] = 1
else:
miss_counts[label] += 1
print("Miss Counts Below TPR Threshold: ")
print(str(miss_counts))
if save:
print("Saving arrays...")
with open('euclidean.npy', 'wb') as f:
np.save(f, e_dists)
with open('dice.npy', 'wb') as f:
np.save(f, d_dists)
def runBtm():
tools.progress("Running the btm tests...")
tools.runNoError(["mvn", "clean", "test", "-Dtest=TwoPCTest"])
tools.runNoError(["mvn", "clean", "test", "-Dtest=TwoPCPhase1FailureTest"])
tools.runNoError(["mvn", "clean"])
def setupTests(test_dir, root_dir, rvmonitor_bin_dir, framework_dir, setup_dir,
test_name):
"""
Full setup for a RVM unit-test.
Args:
test_dir (str): Input directory containing the test.
It should contain a P spec and one or more Java test
files using that spec.
root_dir (str): The root directory for the P compiler
repository.
rvmonitor_bin_dir (str): Directory containing the rv-monitor
binary.
framework_dir (str): Directory containing the test framework files.
setup_dir (str): Output directory that will contain the test
setup, ready for testing with Maven.
test_name (str): The name of the test, used for user-friendly
messages.
Raises:
SubprocessError if one of the tools used (the P compiler and
rv-monitor) returns an error code.
"""
tools.progress("Setup for test %s..." % test_name)
if not os.path.exists(setup_dir):
os.makedirs(setup_dir)
shutil.copy(os.path.join(framework_dir, "pom.xml"), setup_dir)
src_setup_dir = os.path.join(setup_dir, "src")
if os.path.exists(src_setup_dir):
shutil.rmtree(src_setup_dir)
shutil.copytree(os.path.join(framework_dir, "src"), src_setup_dir)
test_setup_dir = os.path.join(src_setup_dir, "test", "java", "unittest")
if not os.path.exists(test_setup_dir):
os.makedirs(test_setup_dir)
for f in glob.glob(os.path.join(test_dir, "*.java")):
shutil.copy(f, test_setup_dir)
shutil.copy(os.path.join(test_dir, "spec.p"), setup_dir)
monitor_setup_dir = os.path.join(setup_dir, "monitor")
if not os.path.exists(monitor_setup_dir):
os.makedirs(monitor_setup_dir)
for f in glob.glob(os.path.join(framework_dir, "monitor", "*.txt")):
shutil.copy(f, monitor_setup_dir)
gen_monitor_setup_dir = os.path.join(monitor_setup_dir, "generated")
if not os.path.exists(gen_monitor_setup_dir):
os.makedirs(gen_monitor_setup_dir)
translate(test_dir, root_dir, gen_monitor_setup_dir)
mop_setup_dir = os.path.join(src_setup_dir, "main", "java", "mop")
aspectj_setup_dir = os.path.join(mop_setup_dir, "aspectJ")
if not os.path.exists(aspectj_setup_dir):
os.makedirs(aspectj_setup_dir)
fillAspect(aspectj_setup_dir, monitor_setup_dir, gen_monitor_setup_dir)
createRvm(rvmonitor_bin_dir, gen_monitor_setup_dir, mop_setup_dir)
for f in glob.glob(os.path.join(gen_monitor_setup_dir, "*.java")):
shutil.copy(f, mop_setup_dir)
def initialize(self):
f = open(self.ret_file, 'r')
data_q = json.load(f)
abstracts_needed = set()
for i in range(len(data_q["questions"])):
abstracts_needed = abstracts_needed | set(
data_q["questions"][i]["retrieved"])
f.close()
print "Collecting Abstracts.."
f = open(self.corpus_file, 'r')
corpus = ijson.items(f, 'articles.item')
for article in corpus:
pmid = article["pmid"]
if pmid in abstracts_needed:
self.corpus_index[
pmid] = article["title"] + ' ' + article["abstractText"]
abstracts_needed.remove(pmid)
if not abstracts_needed:
break
f.close()
print len(self.corpus_index)
q_array_q = []
q_array_d = []
q_array_max = []
print "Reranking.."
n_questions = len(data_q["questions"])
for i in range(n_questions):
#print i
progress(i + 1, n_questions, 'questions')
q_id = data_q["questions"][i]["id"]
q_body = data_q["questions"][i]["body"]
q_retrieved = data_q["questions"][i]["retrieved"]
retr_array_q, retr_array_d, retr_array_max = self.rerank(
q_body, q_retrieved)
q_array_q.append(
Question(q_body, q_id, [x[0] for x in retr_array_q],
[x[1] for x in retr_array_q]))
q_array_d.append(
Question(q_body, q_id, [x[0] for x in retr_array_d],
[x[1] for x in retr_array_d]))
q_array_max.append(
Question(q_body, q_id, [x[0] for x in retr_array_max],
[x[1] for x in retr_array_max]))
with open('.'.join(self.ret_file.split('.')[:-1]) + '_RWMD_Q.json',
'w+') as outfile:
outfile.write(
json.dumps({"questions": [ob.__dict__ for ob in q_array_q]},
indent=2))
with open('.'.join(self.ret_file.split('.')[:-1]) + '_RWMD_D.json',
'w+') as outfile:
outfile.write(
json.dumps({"questions": [ob.__dict__ for ob in q_array_d]},
indent=2))
with open('.'.join(self.ret_file.split('.')[:-1]) + '_RWMD_MAX.json',
'w+') as outfile:
outfile.write(
json.dumps({"questions": [ob.__dict__ for ob in q_array_max]},
indent=2))