def entailment_worker(premise, hypothesis, manager_dict):
'''
Given a premise and hypothesis, add their similarity score and entailment
code to the process manager_dict
'''
aligner = al.Aligner()
p_tokens = word_tokenize(premise)
h_tokens = word_tokenize(hypothesis)
alignments, score = aligner.align(p_tokens, h_tokens, 'default')
#monotonicity_operators_file = os.path.join(os.path.dirname(__file__),
#'resources/monotonicity_operators_list.txt')
#with open(monotonicity_operators_file) as f:
#monotonicity_operators = f.readlines()
#monotonicity_operators = [l.rstrip() for l in monotonicity_operators]
#pipeline_start = time()
#if len([t for t in p_tokens if t in monotonicity_operators]) > 0:
#p_monotonicity_markings = Marker.get_monotonicity_markings(p_tokens)
#p_marked_tokens = dict(zip(p_tokens, p_monotonicity_markings))
#else:
#print 'Not marking p'
#p_monotonicity_markings = ['up'] * len(p_tokens)
#p_marked_tokens = dict(zip(p_tokens, p_monotonicity_markings))
#if len([t for t in h_tokens if t in monotonicity_operators]) > 0:
#h_mark_start = time()
#h_monotonicity_markings = Marker.get_monotonicity_markings(h_tokens)
#h_marked_tokens = dict(zip(h_tokens, h_monotonicity_markings))
#print 'H marked in %s' % (time() - h_mark_start)
#else:
#print 'Not marking h'
#h_monotonicity_markings = ['up'] * len(h_tokens)
#h_marked_tokens = dict(zip(h_tokens, h_monotonicity_markings))
#classify_start = time()
#Classifier.classify_edits(alignments)
#print 'Classified in %s' % (time() - classify_start)
#sequence_start = time()
#sequenced_edits = Sequencer.sequence(
#alignments, p_marked_tokens, h_marked_tokens)
#print 'Sequenced in %s' % (time() - sequence_start)
#project_start = time()
#projected_atomic_entailments = Projector.get_projected_atomic_entailments(
#sequenced_edits)
#print 'Projected in %s' % (time() - project_start)
#entailment = Joiner.join_atomic_entailments(projected_atomic_entailments)
#print 'Pipeline %s' % (time() - pipeline_start)
sequenced_edits, entailment_code = pipeline.get_entailment(
p_tokens, h_tokens, alignments)
manager_dict[premise] = {
'premise': premise,
'score': score,
'entailment_code': entailment_code
}
def alignment_worker(premise, p_tokens, h_tokens, manager_dict):
'''
Given a premise and hypothesis, add their similarity score and entailment
code to the process manager_dict
'''
aligner = al.Aligner()
alignments, score = aligner.align(p_tokens, h_tokens, 'default')
manager_dict[premise] = {
'alignments': alignments,
'score': score,
'p_tokens': p_tokens
}
def slow(self, premises, hypothesis):
aligner = al.Aligner()
h_tokens = word_tokenize(hypothesis)
all_start = time()
codes = []
for premise in premises:
start_time = time()
p_tokens = word_tokenize(premise)
alignments, score = aligner.align(p_tokens, h_tokens, 'default')
sequenced_edits, entailment_code = pipeline.get_entailment(
p_tokens, h_tokens, alignments)
codes.append(entailment_code)
print 'one:', time() - start_time
#print '\nCompleted serial processing'
#for i in codes:
#print i
print 'Completed all, serially in', time() - all_start
def process_image(image):
align = aligner.Aligner()
align.add_face_no_throttle(globals()["align_to"])
episode = image.split("/")[-1].replace(".jpg", "").split("_")[1]
if episode == globals()["last_episode"]:
os.remove(image)
return False
try:
align.add_face(image)
except:
print "removing " + image
os.remove(image)
return False
align.align(image)
globals()["last_episode"] = episode
return True
def run_experiments_with_aligner(roots1, roots2, initial_only=False):
"""Runs FLAGS.number_of_experiments experiments, using new aligner
Note we assume that the input and output can be split on space!
Args:
roots1: A Roots class instance
roots2: A Roots class instance
"""
for i in range(FLAGS.number_of_experiments):
zipped = [(c1.split(), c2.split())
for (c1, c2) in produce_paired_etyma(roots1, roots2)]
success = 0
the_aligner = aligner.Aligner()
success = the_aligner.compute_alignments(
zipped,
max_zeroes=FLAGS.max_zeroes,
max_allowed_mappings=FLAGS.max_allowed_mappings,
print_mappings=FLAGS.print_mappings,
initial_only=initial_only)
print("RUN:\t{}\t{}".format(i, success))
sys.stdout.flush()
print predicted_features
weights = weights + (learning_rate *
(gold_features - predicted_features))
#logging.warning('Summed rated weights:\n%s' % weights)
weights = weights / sqrt(sum([i ** 2 for i in weights]))
#logging.warning('L2 normalization:\n%s' % weights)
weights_history.append(weights)
#logging.warning('\n\nWeights history:\n%s' % weights_history)
weights_averaged = 1 / (learning_epochs
- burn_in_epochs) * sum(weights_history[burn_in_epochs:])
return weights_averaged
if __name__ == '__main__':
aligner = aligner.Aligner()
pickle_file = os.path.join(os.path.dirname(__file__),
'../training_data/alignment_problems.p')
training_set = open(pickle_file)
training_data = pickle.load(training_set)
training_set.close()
t0 = time.clock()
averaged_weights = learn_weights(training_data, 50, 10, 1, 0.8)
t = time.clock() - t0
print 'Trained in %s seconds' % t
print '\n\n\nAveraged weights:\n', averaged_weights
weights_file = open('../training_data/weights.p', 'w+b')
pickle.dump(averaged_weights, weights_file)
weights_file.close()
this_stepfile_name = pcb_project + ".step"
this_stepfile = Path(__file__).parent.parent.parent / "electronics" / pcb_project / "3dOut" / this_stepfile_name
crossbar = tb.u.import_step(this_stepfile)
crossbar_pcb_top_height = 19.5 # from crossbar PCB design
# get the adapter PCB step
adapter = chamber.adapter
adapter_width = chamber.adapter_width
# build an alignment endblock
ablock = tb.endblock.build(adapter_width=adapter_width, horzm3s=True, align_bumps=True, special_chamfer=1.6)
ablock = to_holder(ablock, chamber_floor)
ablock = ablock.translate((0, tb.endblock.height / 2, 0))
# build the aligner
ac = aligner.Aligner(tb)
al = ac.build()
al = to_holder(al, chamber_floor)
al = al.translate((0, tb.endblock.height, 0))
al = al.rotate((0, 0, 0), (0, 1, 0), -90)
ablock.add(al) # put them on the same workplane
# build an endblock
block = tb.endblock.build(adapter_width=adapter_width, horzm3s=True, align_bumps=True, special_chamfer=1.6)
block = to_holder(block, chamber_floor)
block = block.translate((0, tb.endblock.height / 2, 0))
gas_plate_thickness = 2 # thickness of the plate we'll use to redirect the gas
block_scrunch = 5.8 # move the blocks a further amount towards the center
blockA = block.translate(
(
