def destroy_repair(self, solution):
s, destroy_mask = deepcopy(solution), deepcopy(self.mask)
shuffle(destroy_mask)
for i, bit in enumerate(destroy_mask):
if bit and i not in [0, len(s) - 1]:
s[i] = None
holes = self._construct_holes(s)
for hole in holes:
# print(hole, s)
hole_cities = [s[hole[0]], s[hole[1]]]
while len(set(hole_cities)) <= hole[1] - hole[0]:
# print(set(hole_cities))
cities_id_to_check = list(
set(range(self.instance.length)) - set(hole_cities) -
set(s))
# print(cities_id_to_check)
city_insertions = defaultdict(list)
for city_id in cities_id_to_check:
for i, pair in enumerate(pairwise(hole_cities)):
insertion: Insertion = Insertion(
city_id, i + 1,
self._insertion_cost(*pair, city_id))
city_insertions[str(city_id)].append(insertion)
city_insertion_cost = self._map_insertions_on_insertion_costs(
city_insertions)
best_city_insertion: Insertion = min(
city_insertion_cost, key=lambda x: x.cost) # min cost
hole_cities.insert(best_city_insertion.position_in_solution,
best_city_insertion.city_id)
s[hole[0]:hole[1] + 1] = deepcopy(hole_cities)
return s
def get_weight(self, node_a, node_b):
"""
Given two nodes of a graph, build a relation text from the store
:param node_a: networkx node, e_1
:param node_b: networkx node, e_2
:return: weight of the relation
"""
# determine the relation
try:
path = nx.shortest_path(self.family, node_a, node_b)
if len(path) == 2:
# direct path
weight = self.family[node_a][node_b]['weight']
return weight
else:
# indirect path
weight = sum([
self.family[na][nb]['weight'] for na, nb in pairwise(path)
])
return weight
except nx.NetworkXNoPath as e:
# no direct path exists, check if they are siblings
for sibling in self.siblings:
if node_a in sibling and node_b in sibling:
weight = 0
return weight
return -1
def make_single_story(self, num_relations=6, num_stories=10):
"""
In single story mode, there will be only one abstract per story
Idea: Select any two nodes, get its longest connected path, form the story out of the path,
then form the abstract from the shortest connected path
:param: min_relations: min path of relations to consider
:param: max_relations: max path of relations to consider
:return:
"""
stories = []
abstracts = []
relation_path = [] # for debugging purposes
# for all pairs, calculate the min paths and max paths
all_pairs, _ = self.calc_all_pairs(num_relations=num_relations)
if len(all_pairs) == 0:
return [], []
# create story-abstract pairs
for path_pairs in all_pairs:
node_a, node_b, max_path, min_path = path_pairs
story = []
path_str = ''
for pi, (na, nb) in enumerate(pairwise(max_path)):
text = self.stringify(na, nb)
story.append(text)
if pi == 0:
story.extend(
self._get_attributes(
self.connected_family.node[na]['data']))
story.extend(
self._get_attributes(
self.connected_family.node[nb]['data']))
weight = self.inv_rel_type[self.connected_family[na][nb]
['weight']]
if not self.connected_forward.has_edge(
na, nb) and weight not in ['sibling', 'SO']:
weight = 'inv-' + weight
path_str += ' -- <{}> -- '.format(weight)
#story = '. '.join(story) + '.'
abstract = self.stringify(node_a, node_b) + '.'
fw = self.inv_rel_type[self.connected_family[node_a][node_b]
['weight']]
path_str += ' ===> {}'.format(fw)
stories.append(story)
abstracts.append(abstract)
relation_path.append(path_str)
num_stories = -1
if num_stories == 0:
break
return stories, abstracts, relation_path
def _solve(self, first_city_id=0):
solution = [first_city_id, first_city_id]
while len(set(solution)) < self.goal_length:
cities_id_to_check = list(set(range(self.instance.length)) - set(solution))
city_insertions = defaultdict(list)
for city_id in cities_id_to_check:
for i, pair in enumerate(pairwise(solution)):
insertion: Insertion = Insertion(city_id, i + 1, self._insertion_cost(*pair, city_id))
city_insertions[str(city_id)].append(insertion)
city_insertion_cost = self._map_insertions_on_insertion_costs(city_insertions)
best_city_insertion: Insertion = min(city_insertion_cost, key=lambda x: x.cost) # min cost
solution.insert(best_city_insertion.position_in_solution, best_city_insertion.city_id)
return solution, self._get_solution_cost(solution)
def _get_solution_cost(self, solution) -> int:
# if we dont want random solutions, change it to yielding before generated list
return sum([
self.instance.adjacency_matrix[id_source, id_destination]
for id_source, id_destination in pairwise(solution)
])
l.split('\t') for l in open(inputConceptPath[0]).read().splitlines()
], inputConceptPath[1]
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description=
'Predict concept pair class according to a trained classifier')
parser.add_argument("vocFilePath", help='voc file')
parser.add_argument("trainedClfPath", help='trained classifier file')
parser.add_argument("inputConceptPairPathAndClassList",
nargs='+',
help='concept pair file list followed by class name')
parser.add_argument("--compose",
help='try to compose concept',
action='store_false')
args = parser.parse_args()
vocFilePath = args.vocFilePath
trainedClfPath = args.trainedClfPath
inputConceptPairPathAndClassList = args.inputConceptPairPathAndClassList
annotedConceptPairStrList = [
extractAnnotedConceptPairStr(f)
for f in pairwise(args.inputConceptPairPathAndClassList)
]
strict = args.compose
detailConceptPairClfError(db.DB(vocFilePath),
dill.load(open(trainedClfPath)),
annotedConceptPairStrList, strict)
def get_average_hamming_distance(ciphertext: str,
chunk_size: int) -> float:
return sum(
RepeatingKeyXorEstimator.get_normalized_hamming_distance(i, j)
for i, j in pairwise(partition_string(ciphertext, chunk_size))
) / get_number_partitions(ciphertext, chunk_size)