예제 #1
0
    def generate_situation(self, **kwargs):
        if 'randomness' not in kwargs:
            randomness = 0
        else:
            randomness = kwargs['randomness']
        if 'type_descriptors' not in kwargs:
            type_descriptors = []
        else:
            type_descriptors = kwargs['type_descriptors']
        if 'spatial_relation_descriptors' not in kwargs:
            spatial_relation_descriptors = []
        else:
            spatial_relation_descriptors = kwargs[
                'spatial_relation_descriptors']

        entity_nodes = []
        for descriptor in spatial_relation_descriptors:
            for i in range(descriptor.weight):
                for first_descriptor, second_descriptor in subsets_of_len_two(
                        descriptor.type_descriptors):
                    for first_node in self._generate_block_entity_nodes_from_description(
                            first_descriptor):
                        entity_nodes.append(first_node)
                        for second_node in self._generate_block_entity_nodes_from_description(
                                second_descriptor):
                            entity_nodes.append(second_node)
                            list_link = self.atomspace.add_link(
                                types.ListLink, [first_node, second_node])
                            predicate_node = self.atomspace.add_node(
                                types.PredicateNode, descriptor.relation,
                                _default_tv)
                            self.atomspace.add_link(
                                types.EvaluationLink,
                                [predicate_node, list_link], _default_tv)

        for descriptor in type_descriptors:
            entity_nodes += self._generate_block_entity_nodes_from_description(
                descriptor)

        number_of_entities = len(entity_nodes)
        for i in range(int(round(randomness * number_of_entities))):
            # select two random entities
            index_of_first_entity = randrange(number_of_entities)
            while True:
                index_of_second_entity = randrange(number_of_entities)
                if index_of_first_entity != index_of_second_entity:
                    break
            list_link = self.atomspace.add_link(types.ListLink, [
                entity_nodes[index_of_first_entity],
                entity_nodes[index_of_second_entity]
            ])
            predicate_node = self.spatial_relations[randrange(
                len(self.spatial_relations))]
            self.atomspace.add_link(types.EvaluationLink,
                                    [predicate_node, list_link], _default_tv)
예제 #2
0
 def triangulate(self):
     junction_tree = JunctionTree()
     vertices = list(self)
     eliminated = set()
     while len(vertices) > 0:
         vertices.sort()  # based on number of neighbours
         node = vertices.pop()
         for neighbour1, neighbour2 in subsets_of_len_two(node.neighbours):
             if neighbour1 in eliminated or neighbour2 in eliminated:
                 continue
             link = neighbour1.add_neighbour(neighbour2)
             clique = Clique(neighbour1, node, neighbour2, junction_tree)
             #                clique = Clique(neighbour1)
             clique.connect_link(link)
         eliminated.add(self.pop(node))
     for node in eliminated:
         node.revert()
         self.add(node)
     return junction_tree
예제 #3
0
    def generate_situation(self, **kwargs):
        if 'randomness' not in kwargs:
            randomness = 0
        else:
            randomness = kwargs['randomness']
        if 'type_descriptors' not in kwargs:
            type_descriptors = []
        else:
            type_descriptors = kwargs['type_descriptors']
        if 'spatial_relation_descriptors' not in kwargs:
            spatial_relation_descriptors = []
        else:
            spatial_relation_descriptors = kwargs['spatial_relation_descriptors']

        entity_nodes = []
        for descriptor in spatial_relation_descriptors:
            for i in range(descriptor.weight):
                for first_descriptor, second_descriptor in subsets_of_len_two(descriptor.type_descriptors):
                    for first_node in self._generate_block_entity_nodes_from_description(first_descriptor):
                        entity_nodes.append(first_node)
                        for second_node in self._generate_block_entity_nodes_from_description(second_descriptor):
                            entity_nodes.append(second_node)
                            list_link = self.atomspace.add_link(types.ListLink, [first_node, second_node])
                            predicate_node = self.atomspace.add_node(types.PredicateNode, descriptor.relation,
                                                                     _default_tv)
                            self.atomspace.add_link(types.EvaluationLink, [predicate_node, list_link], _default_tv)

        for descriptor in type_descriptors:
            entity_nodes += self._generate_block_entity_nodes_from_description(descriptor)

        number_of_entities = len(entity_nodes)
        for i in range(int(round(randomness * number_of_entities))):
            # select two random entities
            index_of_first_entity = randrange(number_of_entities)
            while True:
                index_of_second_entity = randrange(number_of_entities)
                if index_of_first_entity != index_of_second_entity:
                    break
            list_link = self.atomspace.add_link(types.ListLink,
                                                [entity_nodes[index_of_first_entity],
                                                 entity_nodes[index_of_second_entity]])
            predicate_node = self.spatial_relations[randrange(len(self.spatial_relations))]
            self.atomspace.add_link(types.EvaluationLink, [predicate_node, list_link], _default_tv)
예제 #4
0
    def triangulate(self):
        junction_tree = JunctionTree()
        vertices = list(self)
        eliminated = set()
        while len(vertices) > 0:
            vertices.sort() # based on number of neighbours
            node = vertices.pop()
            for neighbour1, neighbour2 in subsets_of_len_two(node.neighbours):
                if neighbour1 in eliminated or neighbour2 in eliminated:
                    continue
                link = neighbour1.add_neighbour(neighbour2)
                clique = Clique(neighbour1, node, neighbour2, junction_tree)
#                clique = Clique(neighbour1)
                clique.connect_link(link)
            eliminated.add(self.pop(node))
        for node in eliminated:
            node.revert()
            self.add(node)
        return junction_tree
예제 #5
0
 def moralise(self):
     for node in self:
         for parent1, parent2 in subsets_of_len_two(node.parents):
             parent1.add_neighbour(parent2)
예제 #6
0
 def moralise(self):
     for node in self:
         for parent1, parent2 in subsets_of_len_two(node.parents):
             parent1.add_neighbour(parent2)