def resolve(self, kb, parameter): print("Resolving KB with parameter: " + parameter) resolved_kb = KnowledgeBase() super(StructuredResolver, self).copy_all(resolved_kb, kb) # Load document to ID mappings # TODO: Need to determine what to do about zips # Structured JSON data contains the full name for the zip, # i.e. the "rel_path": # "World_Bank_Data\API_BEN_DS2_en_csv_v2.zip\API_BEN_DS2_en_csv_v2.csv" # but the current ID data file only goes to the zip filename # TODO: is this now outdated based on file ids in json to be processed? with io.open(os.path.dirname(os.path.realpath(__file__)) + "/../data_files/structured_data_unique_ids.txt", mode="r", encoding="utf-8") as f: for line in f: (data_id, f_name) = line.split('|') data_id = data_id.strip() f_name = f_name.strip() f_name = ascii_me(ntpath.basename(f_name)) self.id_manager.structured_document_name_to_id[ f_name] = data_id resolved_kb.structured_documents = self._resolve_structured_inputs(kb) resolved_kb.structured_relationships = \ self._resolve_structured_relationships(kb) return resolved_kb
def test_CPTBuilder(self): kb = KnowledgeBase('..\\..\\..\\test_data\\doug_example.csv', '..\\..\\..\\test_data\\doug_example.csv') data = kb.get_query(['Success', 'Smart', 'Work Hard']) builder = CPTBuilder(data, kb.get_scale()) print()
def __init__(self): self.kb = KnowledgeBase() self.lock = threading.Lock() self.location = Location(self.kb, self.lock) self.motion = MotionSubsystem(self.kb, self.lock)
def resolve(self, kb): print("RedundantEventResolver RESOLVE") resolved_kb = KnowledgeBase() super(RedundantEventResolver, self).copy_all(resolved_kb, kb) resolved_kb.clear_events_relations_and_groups() # Organize events by sentence sentence_to_event_mention_list = dict() event_mention_to_event = dict() for evid, event in kb.get_events(): for event_mention in event.event_mentions: event_mention_to_event[event_mention] = event if event_mention.model == "ACCENT": continue sentence = event_mention.sentence if sentence not in sentence_to_event_mention_list: sentence_to_event_mention_list[sentence] = [] sentence_to_event_mention_list[sentence].append(event_mention) event_mentions_to_remove = set() for sentence, event_mention_list in sentence_to_event_mention_list.items( ): # Looking at event mentions for a particular sentence for em1 in event_mention_list: for em2 in event_mention_list: if em1 == em2: continue if em1.is_similar_and_better_than(em2): #print "Throwing out: " + em2.id + " because it is worse than " + em1.id event_mentions_to_remove.add(em2) bad_event_ids = set() for evid, event in kb.get_events(): found_good_event_mention = False for event_mention in event.event_mentions: if not event_mention in event_mentions_to_remove: found_good_event_mention = True break if found_good_event_mention: resolved_kb.add_event(event) else: bad_event_ids.add(evid) for relid, relation in kb.get_relations(): if relation.left_argument_id not in bad_event_ids and relation.right_argument_id not in bad_event_ids: resolved_kb.add_relation(relation) # add event group to event mapping: for evgid, event_group in kb.get_event_groups(): ev_group = KBEventGroup(event_group.id) for event in event_group.members: if event.id not in bad_event_ids: ev_group.members.append(event) if len(ev_group.members) > 0: resolved_kb.add_event_group(ev_group) return resolved_kb
def __init__(self): self.kb = KnowledgeBase() self.data = NodeBData() self.packet = Packet('B') self.radio = RadioAPI() self.tx_packet_number = 1 self.rx_packet_list = []
def resolve(self, kb): print("RemovalByTypeResolver RESOLVE") resolved_kb = KnowledgeBase() super(RemovalByTypeResolver, self).copy_all(resolved_kb, kb) resolved_kb.clear_events_relations_and_groups() bad_event_ids = set() for evid, event in kb.get_events(): for event_mention in event.event_mentions: rule_list = self.removal_info.get(event_mention.event_type) if not rule_list: break for rule in rule_list: if rule.matches_event_mention(event_mention, kb): bad_event_ids.add(evid) break bad_relation_ids = set() for relid, relation in kb.get_relations(): for relation_mention in relation.relation_mentions: rule_list = self.removal_info.get(relation.relation_type) if not rule_list: break for rule in rule_list: if rule.matches_relation_mention(relation_mention, kb): bad_relation_ids.add(relid) break # Add in non-bad events to resolved KB for evid, event in kb.get_events(): if evid not in bad_event_ids: resolved_kb.add_event(event) #else: # print "Removing: " + evid # Add in non-bad relations that didn't have an event removed for relid, relation in kb.get_relations(): if (relid not in bad_relation_ids and relation.left_argument_id not in bad_event_ids and relation.right_argument_id not in bad_event_ids): resolved_kb.add_relation(relation) #else: # print "Removing: " + relid # add event group to event mapping: for evgid, event_group in kb.get_event_groups(): ev_group = KBEventGroup(event_group.id) for event in event_group.members: if event.id not in bad_event_ids: ev_group.members.append(event) if len(ev_group.members) > 0: resolved_kb.add_event_group(ev_group) return resolved_kb
def __init__(self): self.kb = KnowledgeBase() self.radio = RadioAPI() self.packet = Packet('B') self.data = [] for i in range(50): self.data.append(0xff) self.tx_packet_number = 1
def test_apply_combination_filter(self): kb = KnowledgeBase('..\\..\\..\\test_data\\doug_example.csv', '..\\..\\..\\test_data\\doug_example.csv') data = kb.get_query(['Success', 'Smart', 'Work Hard']) builder = CPTBuilder(data, kb.get_scale()) print(builder._apply_combination_filter(['T', 'T'])) print(builder._apply_combination_filter(['F', 'T'])) print(builder._apply_combination_filter( ['A', 'B'])) # Combination is not apart of scale
def generate_to_knowledge_base(filename, sqlite_filename="knowledge_base.sql", scorer=fuzz.ratio): templates = generate_templates(filename, scorer) base = KnowledgeBase(sqlite_filename) for template in templates: if not template.generated: continue base.insert_exception_template(template)
def load_to_knowledge_base(filename, sqlite_filename="knowledge_base.sql"): exceptions = load_exceptions(filename) templates = [ ExceptionTemplate(exception.exception, [], exception.message) for exception in exceptions ] base = KnowledgeBase(sqlite_filename) for template in templates: if "{*}" in template.template: base.insert_exception_template(template)
def __init__(self): self.kb = KnowledgeBase() self.lock = Lock() self.data = NodeAData() self.packet = Packet('A') self.radio = RadioAPI() self.tx_packet_number = 1 self.ack_packet_number = 0 self.goodput = 0
def knowledge_base(): """ Initialises and returns a HuCit KnowledgeBase (new version, standalone package). """ try: config_file = pkg_resources.resource_filename('knowledge_base','config/virtuoso.ini') kb = KnowledgeBaseNew(config_file) kb.get_authors()[0] return kb except Exception, e: config_file = pkg_resources.resource_filename('knowledge_base','config/inmemory.ini') return KnowledgeBaseNew(config_file)
def resolve(self, kb): print("BadRelationResolver RESOLVE") resolved_kb = KnowledgeBase() super(BadRelationResolver, self).copy_all(resolved_kb, kb) resolved_kb.clear_relations_and_relation_groups() for relid, relation in kb.get_relations(): # Always let event-event relations through if relation.argument_pair_type == "event-event": resolved_kb.add_relation(relation) continue # Entity-level arguments are the same, skip if relation.left_argument_id == relation.right_argument_id: #print "Skipping relation (1): " + relation.id continue # Cross-document entities will end up the same if the # args have the same cameo_country_code, so skip left_entity = kb.entid_to_kb_entity[relation.left_argument_id] right_entity = kb.entid_to_kb_entity[relation.right_argument_id] if (left_entity.properties.get("cameo_country_code") is not None and right_entity.properties.get("cameo_country_code") is not None and left_entity.properties.get("cameo_country_code") == right_entity.properties.get("cameo_country_code")): #print "Skipping relation (2): " + relation.id continue resolved_kb.add_relation(relation) return resolved_kb
def __init__(self): self.kb = KnowledgeBase() self.lock = threading.Lock() self.location = Location(self.kb, self.lock) self.motion = SimpleMotion(self.kb, self.lock) self.rf = RadioSubsystem(self.kb, self.lock, self.radio_data_callback) self.fsm_state = 'at_beginning' self.sent_packet = np.array([]) self.ack_packet = np.array([]) self.goodput = np.array([])
def resolve(self, kb): print("EventRemovalResolver RESOLVE") resolved_kb = KnowledgeBase() super(EventRemovalResolver, self).copy_all(resolved_kb, kb) resolved_kb.clear_events_relations_and_groups() bad_event_ids = set() for evid, event in kb.get_events(): found_good_event_mention = False for event_mention in event.event_mentions: if event_mention.trigger is None or event_mention.trigger.lower() not in self.bad_trigger_words: found_good_event_mention = True break if found_good_event_mention: corrected_event = self.correct_event_type(event) if corrected_event is not None: resolved_kb.add_event(event) else: bad_event_ids.add(evid) for relid, relation in kb.get_relations(): if relation.left_argument_id not in bad_event_ids and relation.right_argument_id not in bad_event_ids: resolved_kb.add_relation(relation) return resolved_kb
def knowledge_base(): """ Initialises and returns a HuCit KnowledgeBase (new version, standalone package). """ try: config_file = pkg_resources.resource_filename('knowledge_base', 'config/virtuoso.ini') kb = KnowledgeBaseNew(config_file) kb.get_authors()[0] return kb except Exception, e: config_file = pkg_resources.resource_filename('knowledge_base', 'config/inmemory.ini') return KnowledgeBaseNew(config_file)
def __init__(self): self.lock = Lock() self.kb = KnowledgeBase() self.location = Location(self.kb, self.lock) self.motion = MotionSubsystem(self.kb, self.lock, self.motion_callback) self.rf = RadioSubsystem(self.kb, self.lock, self.radio_data_callback) self.fsm_state = 'at_beginning' self.sent_packet = np.array([]) self.ack_packet = np.array([]) self.goodput = np.array([]) self.color_values = np.array([]) self.arrived = False
def __init__(self): self.kb = KnowledgeBase() self.location = BarcodeServer(self.location_callback) self.flight_path = FlightPath() self.motion = Motion(self.kb) self.node_a = NodeAServer()
def test_get_class_data(self): kb = KnowledgeBase(None, '..\\..\\test_data\\Test_Data_AB.csv') kb.add_data('..\\..\\test_data\\Test_Data_C.csv') print(kb.get_data()) print() print(kb.get_class_data(['A', 'C'])) print() print(kb.get_class_data(['B'])) print(kb.get_class_data(['Z'])) print(kb.get_class_data(['A', 'B', 'Z']))
def main(): '''User-Inputted Recipie Title''' #url = generateURL() '''Hard Coded URLs''' # url = "http://allrecipes.com/recipe/brown-rice-and-quinoa-sushi-rolls/" # url = "http://allrecipes.com/recipe/Boilermaker-Tailgate-Chili/" #url = "http://allrecipes.com/recipe/jerk-chicken/" #link = urllib.urlopen(url) #page = link.read() '''Local Cached Webpages''' # url = "../data/Burger" # url = "../data/Cake" url = "../data/Stir-Fry" f = open(url + ".html") page = f.read() if len(sys.argv) < 2: recipe = parse_recipe(page) recipe = unabridgeMeasure(recipe) prettyPrintRecipe(recipe) save_output(url, recipe) elif len(sys.argv) == 2: case_num = int(sys.argv[1]) if case_num < 1 or case_num > 8: print('You can only pick from [1-8]') return recipe = parse_recipe(page) recipe = unabridgeMeasure(recipe) kb = KnowledgeBase() if case_num == 1: tf_recipe = kb.transform_cuisine("italian", recipe) elif case_num == 2: tf_recipe = kb.transform_cuisine("chinese", recipe) elif case_num == 3: tf_recipe = kb.transform_diet("vegetarian", recipe) elif case_num == 4: tf_recipe = kb.transform_diet("pescatarian", recipe) elif case_num == 5: tf_recipe = kb.transform_healthy("low-fat", recipe) elif case_num == 6: tf_recipe = kb.transform_healthy("low-sodium", recipe) elif case_num == 7: tf_recipe = transformQty(2, recipe) elif case_num == 8: tf_recipe = transformQty(3, recipe) prettyPrintRecipe(tf_recipe) save_output(url, tf_recipe) else: print( 'Too many arguments. You can either either just call main.py to see the recipe or pass in a single integer to select a transformation.' )
def resolve(self, kb): resolved_kb = KnowledgeBase() super(DropNegativePolarityCausalAssertionResolver, self).copy_all(resolved_kb, kb) new_relid_to_kb_relation = dict() for relid, kb_relation in resolved_kb.relid_to_kb_relation.items(): if kb_relation.argument_pair_type != "event-event": new_relid_to_kb_relation[relid] = kb_relation elif kb_relation.polarity != "Negative": new_relid_to_kb_relation[relid] = kb_relation else: src_kb_event = resolved_kb.evid_to_kb_event[ kb_relation.left_argument_id] tar_kb_event = resolved_kb.evid_to_kb_event[ kb_relation.right_argument_id] logger.debug("NCA Dropping {}".format( get_marked_up_string_for_event_event_relation( kb_relation, src_kb_event, tar_kb_event))) resolved_kb.relid_to_kb_relation = new_relid_to_kb_relation return resolved_kb
def resolve(self, kb): print("RelevantKBEntityMentionResolver RESOLVE") resolved_kb = KnowledgeBase() super(RelevantKBEntityMentionResolver, self).copy_all(resolved_kb, kb) self.kb_entity_mention_to_kb_entity = dict() self.kb_entity_to_kb_entity_group = dict() self.actor_id_to_kb_entity_group = dict() self.marked_kb_elements = set() for entgroupid, kb_entity_group in resolved_kb.entgroupid_to_kb_entity_group.items(): kb_entity_group.is_referred_in_kb = False for kb_entity in kb_entity_group.members: kb_entity.is_referred_in_kb = False self.kb_entity_to_kb_entity_group[kb_entity] = kb_entity_group for kb_entity_mention in kb_entity.mentions: kb_entity_mention.is_referred_in_kb = False self.kb_entity_mention_to_kb_entity[kb_entity_mention] = kb_entity if kb_entity_group.actor_id is not None: self.actor_id_to_kb_entity_group[kb_entity_group.actor_id] = kb_entity_group start_searching_points = set() for evt_id,kb_event in resolved_kb.evid_to_kb_event.items(): for kb_event_mention in kb_event.event_mentions: for arg_role,args in kb_event_mention.arguments.items(): for arg,score in args: if isinstance(arg, KBMention): self.mark_from_bottom_to_top(arg) start_searching_points.add(self.kb_entity_mention_to_kb_entity[arg]) OUT_DEGREE = 2 while OUT_DEGREE > 0: alternative_searching_points = set() for relid, kb_relation in resolved_kb.relid_to_kb_relation.items(): if kb_relation.argument_pair_type == "entity-entity": left_entity = resolved_kb.entid_to_kb_entity[kb_relation.left_argument_id] right_entity = resolved_kb.entid_to_kb_entity[kb_relation.right_argument_id] if left_entity in start_searching_points: if right_entity not in start_searching_points and right_entity.is_referred_in_kb is False: alternative_searching_points.add(right_entity) self.mark_from_bottom_to_top(right_entity) if right_entity in start_searching_points: if left_entity not in start_searching_points and left_entity.is_referred_in_kb is False: alternative_searching_points.add(left_entity) self.mark_from_bottom_to_top(left_entity) OUT_DEGREE -= 1 start_searching_points = alternative_searching_points return resolved_kb
def resolve(self, kb): print("EntityAddPropertyResolver RESOLVE") resolved_kb = KnowledgeBase() super(EntityAddPropertyResolver, self).copy_all(resolved_kb, kb) for entid, kb_entity in resolved_kb.entid_to_kb_entity.items(): if kb_entity.canonical_name is None: self.pick_canonical_name(kb_entity) return resolved_kb
def resolve(self, kb): print("AddGenericEventTypeIfOnlyCausalFactorTypeAvailableResolver RESOLVE") generic_event_uri = "http://ontology.causeex.com/ontology/odps/Event#Event" resolved_kb = KnowledgeBase() super(AddGenericEventTypeIfOnlyCausalFactorTypeAvailableResolver, self).copy_all(resolved_kb, kb) for kb_event_id, kb_event in resolved_kb.evid_to_kb_event.items(): for kb_event_mention in kb_event.event_mentions: if len(kb_event_mention.external_ontology_sources) < 1 and len(kb_event_mention.causal_factors) > 0: highest_cf_score = max(cf.relevance for cf in kb_event_mention.causal_factors) kb_event_mention.external_ontology_sources.append([generic_event_uri,highest_cf_score]) return resolved_kb
def test_build_with_no_parents(self): kb = KnowledgeBase('..\\..\\..\\test_data\\doug_example.csv', '..\\..\\..\\test_data\\doug_example.csv') data = kb.get_query(['Work Hard']) builder = CPTBuilder(data, kb.get_scale()) print(builder.build_with_no_parents()) kb1 = KnowledgeBase('..\\..\\..\\test_data\\doug_example.csv', '..\\..\\..\\test_data\\doug_example.csv') data = kb1.get_query(['Smart']) builder1 = CPTBuilder(data, kb.get_scale()) print(builder1.build_with_no_parents())
def __init__(self, inputfile=None): # For reading/writing input/output if inputfile == None: self.inputFileName = self.getInputFileName() else: self.inputFileName = inputfile self.inputFile = open(self.inputFileName, 'r') self.outputFileName = "output.txt" self.outputFile = open(self.outputFileName, 'w') # Num queries self.numQueries = 0 # Num statements for the kb self.numStatements = 0 # List of queries. Stored as predicate objects. self.queryList = [] # The knowledge base for this set of queries self.kb = KnowledgeBase()
def resolve(self, kb, awake_db): print("ExternalURIResolver RESOLVE") resolved_kb = KnowledgeBase() super(ExternalURIResolver, self).copy_all(resolved_kb, kb) if awake_db == "NA": return resolved_kb kb_entity_to_entity_group = dict() for entgroupid, kb_entity_group in resolved_kb.get_entity_groups(): for kb_entity in kb_entity_group.members: kb_entity_to_entity_group[kb_entity] = kb_entity_group AwakeDB.initialize_awake_db(awake_db) for entid, kb_entity in resolved_kb.entid_to_kb_entity.items(): kb_entity_group = kb_entity_to_entity_group[kb_entity] source_string = AwakeDB.get_source_string(kb_entity_group.actor_id) if source_string is not None and source_string.find( "dbpedia.org") != -1: formatted_string = source_string.strip() if source_string.startswith("<"): source_string = source_string[1:] if source_string.endswith(">"): source_string = source_string[0:-1] source_string = source_string.replace("dbpedia.org/resource", "en.wikipedia.org/wiki", 1) kb_entity.properties["external_uri"] = source_string # For countries, add geoname_id to properties if (kb_entity_group.actor_id is not None and "external_uri" not in kb_entity.properties and "geonameid" not in kb_entity.properties): geonameid = AwakeDB.get_geonameid_from_actorid( kb_entity_group.actor_id) if geonameid is not None and len(str(geonameid).strip()) != 0: kb_entity.properties["geonameid"] = str(geonameid) return resolved_kb
class Controller(object): def __init__(self): self.kb = KnowledgeBase() self.lock = threading.Lock() self.location = Location(self.kb, self.lock) self.motion = MotionSubsystem(self.kb, self.lock) def run(self): """ Start the controller. """ self.kb.build_route() self.motion.start() self.location.start() while True: print "time: ", time.time() time.sleep(1) def shutdown(self): # self.kb.save_kb() # pprint.pprint(self.kb.get_state()) # print "\n\n\n\n\n" # self.kb.route_debug() # print "\n\n\n\n\n" self.motion.join() # self.motion.shutdown() # self.rf.join() time.sleep(0.1) self.location.join() # shut this down last
def resolve(self, kb): print("EventPolarityResolver RESOLVE") resolved_kb = KnowledgeBase() super(EventPolarityResolver, self).copy_all(resolved_kb, kb) for evid, kb_event in resolved_kb.get_events(): for kb_event_mention in kb_event.event_mentions: event_mention_text = kb_event_mention.trigger should_reverse_polarity = False tokens_in_mention = event_mention_text.split(" ") for token in tokens_in_mention: if token in negative_word_set and len( tokens_in_mention) > 1: should_reverse_polarity = True if should_reverse_polarity is True: for event_type, grounding in kb_event_mention.external_ontology_sources: for negative_type_keyword in negative_type_set: if negative_type_keyword in event_type: should_reverse_polarity = False if should_reverse_polarity is True: kb_event_mention.properties["polarity"] = "Negative" return resolved_kb
def __init__(self, agent): self._agent = agent self._cooperation = {} self._knowledge_base = KnowledgeBase() self._current_goal = self._knowledge_base.goals['find_trash'] # time awareness self._time_trash_found = self.time self._agent_trash_count_history = self._agent.trash_count # queue to maintain last 10 positions self._agent_position_history = deque([(0, 0)], 10) # domain awareness self._time_domain_strategy_applied = self.time
def resolve(self, kb): print("EntityGroupEntityTypeResolver RESOLVE") resolved_kb = KnowledgeBase() super(EntityGroupEntityTypeResolver, self).copy_all(resolved_kb, kb) # Make sure best entity type across each entity group is consistent for entgroupid, entity_group in resolved_kb.get_entity_groups(): entity_type_to_count = dict() # entity_type => count for entity in entity_group.members: entity_type = entity.get_best_entity_type() if entity_type not in entity_type_to_count: entity_type_to_count[entity_type] = 0 entity_type_to_count[entity_type] += 1 # Get best entity type from dict best_entity_type = None highest_count = None for et, count in entity_type_to_count.items(): if best_entity_type is None or count > highest_count: best_entity_type = et highest_count = count continue if count < highest_count: continue # count and highest count is equal best_entity_type = self.get_better_entity_type( best_entity_type, et) # set entity type for group if len(entity_type_to_count) > 1: #print "Setting entity type for " + unidecode.unidecode(entity_group.canonical_name) + " " + entity_group.id + " to " + best_entity_type #print "Based on: " + str(entity_type_to_count) for entity in entity_group.members: entity.add_entity_type(best_entity_type, 0.9) return resolved_kb
def __init__(self, inputfile = None): # For reading/writing input/output if inputfile == None : self.inputFileName = self.getInputFileName() else : self.inputFileName = inputfile self.inputFile = open(self.inputFileName, 'r') self.outputFileName = "output.txt" self.outputFile = open(self.outputFileName, 'w') # Num queries self.numQueries = 0 # Num statements for the kb self.numStatements = 0 # List of queries. Stored as predicate objects. self.queryList = [] # The knowledge base for this set of queries self.kb = KnowledgeBase()
class Controller(object): def __init__(self): self.kb = KnowledgeBase() self.lock = threading.Lock() self.location = Location(self.kb, self.lock) self.motion = SimpleMotion(self.kb, self.lock) self.rf = RadioSubsystem(self.kb, self.lock, self.radio_data_callback) self.fsm_state = 'at_beginning' self.sent_packet = np.array([]) self.ack_packet = np.array([]) self.goodput = np.array([]) def run(self): """ Start the controller. """ self.kb.build_route() self.location.start() self.rf.start() while True: self.fsm() def radio_data_callback(self, sent_packet, ack_packet, goodput): self.sent_packet = np.append(self.sent_packet, sent_packet) self.ack_packet = np.append(self.ack_packet, ack_packet) self.goodput = np.append(self.goodput, goodput) def reset_radio_data(self): self.sent_packet = np.array([]) self.ack_packet = np.array([]) self.goodput = np.array([]) def fsm(self): if self.fsm_state == 'at_beginning': print "\n\n\n" print "at_beginning" start_node = self.kb.get_start_node() self.motion.move_until_location(start_node, speed = 25) while not self.kb.get_state()['current_location'] == start_node: time.sleep(0.2) next_node = self.kb.get_next_node(start_node) # self.lock.acquire() self.kb.set_current_node(start_node) self.kb.set_next_node(next_node) self.kb.set_next_edge((start_node, next_node)) # self.lock.release() self.fsm_state = 'traversing_edge' return elif self.fsm_state == 'traversing_edge': print "\n\n\n" print "traversing_edge" kb_state = self.kb.get_state() current_edge = kb_state['next_edge'] next_edge = None last_node = kb_state['current_node'] current_node = None next_node = kb_state['next_node'] # self.lock.acquire() self.kb.set_current_edge(current_edge) self.kb.set_next_edge(next_edge) self.kb.set_last_node(last_node) self.kb.set_current_node(current_node) # self.lock.release() tic = time.time() # this is not threaded!!!!! self.motion.move_from_here_to_there(last_node, next_node, speed = 45) # print "self.kb.get_state()['current_location'] = ", self.kb.get_state()['current_location'] # print "next_node = ", next_node # print "self.kb.get_state()['current_location'] == next_node : ", self.kb.get_state()['current_location'] == next_node print "traversing_eddge, current_node = ", current_node print "traversing_edge, next_node = ", next_node while not self.kb.get_state()['current_location'] == next_node: # color = motion.get_color_reading() print "\n\n\n\n" print "Blah blah blah" # print "Detected color: ", color print "\n\n\n\n" time.sleep(0.01) toc = time.time() - tic weight = toc * np.average(self.goodput) print "weight value for edge %s = %0.2f" %(str(current_edge), weight) self.kb.set_edge_weight(current_edge, weight) # print self.goodput # print "average goodput for edge %s = %0.2f" %(str(current_edge), np.average(self.goodput)) self.fsm_state = 'at_a_node' return elif self.fsm_state == 'at_a_node': print "\n\n\n" print "at_a_node" self.rf.control_radio_operation('pause') kb_state = self.kb.get_state() current_node = kb_state['next_node'] next_node = self.kb.get_next_node(current_node) print "at_a_node, current_node = ", current_node print "at_a_node, next_node = ", next_node current_edge = None last_edge = kb_state['current_edge'] next_edge = (current_node, next_node) # self.lock.acquire() self.kb.set_current_node(current_node) self.kb.set_next_node(next_node) self.kb.set_current_edge(current_edge) self.kb.set_last_edge(last_edge) self.kb.set_next_edge(next_edge) # self.lock.release() self.fsm_state = 'traversing_edge' self.rf.control_radio_operation('continue') self.reset_radio_data() return else: if DEBUG: print "controller.fsm() error" print "state == ", state else: pass def shutdown(self): self.kb.save_kb() # pprint.pprint(self.kb.get_state()) # print "\n\n\n\n\n" # self.kb.route_debug() # print "\n\n\n\n\n" self.motion.shutdown() self.rf.join() time.sleep(0.1) self.location.join() # shut this down last
class StandAloneRadioB(object): def __init__(self): self.kb = KnowledgeBase() self.radio = RadioAPI() self.packet = Packet('B') self.data = [] for i in range(50): self.data.append(0xff) self.tx_packet_number = 1 def _configure_radio(self, power, frequency, data_rate, modulation): """ Configure radio for operation. """ self.radio.configure_radio(power, frequency, data_rate, modulation) def _send_packet(self): """ Transmit packet. """ self.packet.set_flags_node_b() location = self.kb.get_state()['current_location'] tx_packet = self.packet.make_packet(self.tx_packet_number, location, self.data) self.radio.transmit(tx_packet) self.tx_packet_number += 1 def _receive_packet(self): """ Receive packet. """ rx_packet = self.radio.receive(rx_fifo_threshold=63, timeout=None) if rx_packet == []: # this occurs when timeout has been exceeded return else: packet_number, time_stamp, location, flags, data = self.packet.parse_packet(rx_packet) print "packet_number=%d time_stamp=%f location=%d flags=0x%x" %(packet_number, time_stamp, location, flags) def _listen(self): """ Listen before talk. """ status = self.radio.listen(rssi_threshold=100, timeout=1.0) if status == 'clear': print "channel clear" def run(self): """ Run the radio subsystem. """ self.radio.startup() default_radio_profile = location = self.kb.get_state()['default_radio_profile'] power = default_radio_profile['power'] frequency = default_radio_profile['frequency'] data_rate = default_radio_profile['data_rate'] modulation = default_radio_profile['modulation'] self._configure_radio(power, frequency, data_rate, modulation) state = "listen" while True: if state == "listen": self._listen() state = "receive" elif state == "receive": self._receive_packet() state = "send" elif state == "send": self._send_packet() state = "listen" else: print "+++ Melon melon melon +++" state = "listen" def shutdown(self): self.radio.shutdown()
class Controller(object): def __init__(self): self.lock = Lock() self.kb = KnowledgeBase() self.location = Location(self.kb, self.lock) self.motion = MotionSubsystem(self.kb, self.lock, self.motion_callback) self.rf = RadioSubsystem(self.kb, self.lock, self.radio_data_callback) self.fsm_state = 'at_beginning' self.sent_packet = np.array([]) self.ack_packet = np.array([]) self.goodput = np.array([]) self.color_values = np.array([]) self.arrived = False def run(self): """ Start the controller. """ self.kb.build_route() self.location.start() self.motion.start() self.rf.start() # time.sleep(0.1) self.fsm() def motion_callback(self, has_arrived): self.arrived = has_arrived def radio_data_callback(self, sent_packet, ack_packet, goodput): """ Radio Subsystem IPC. """ self.sent_packet = np.append(self.sent_packet, sent_packet) self.ack_packet = np.append(self.ack_packet, ack_packet) self.goodput = np.append(self.goodput, goodput) def reset_radio_data(self): """ Reset local radio data storage. """ self.sent_packet = np.array([]) self.ack_packet = np.array([]) self.goodput = np.array([]) def fsm(self): while True: if self.fsm_state == 'at_beginning': before_start = 0 start_node = self.kb.get_start_node() self.motion.set_source_destination(before_start, start_node) self.motion.set_speed(25) self.motion.control_motion_operation('go') while not self.arrived: time.sleep(0.1) next_node = self.kb.get_next_node(start_node) self.kb.set_current_node(start_node) self.kb.set_next_node(next_node) self.kb.set_next_edge((start_node, next_node)) self.fsm_state = 'traversing_edge' continue elif self.fsm_state == 'traversing_edge': if DEBUG: print "traversing_edge" kb_state = self.kb.get_state() print kb_state current_edge = kb_state['next_edge'] next_edge = None last_node = kb_state['current_node'] current_node = None next_node = kb_state['next_node'] self.kb.set_current_edge(current_edge) self.kb.set_next_edge(next_edge) self.kb.set_last_node(last_node) self.kb.set_current_node(current_node) self.arrived = False self.motion.set_source_destination(current_edge[0], current_edge[1]) self.motion.set_speed(45) tic = time.time() self.motion.control_motion_operation('go') while not self.arrived: self.color_values = np.append(self.color_values, self.motion.color_reading()) time.sleep(0.1) toc = time.time() - tic # weight = toc * np.average(self.goodput) # targets = self.count_targets(self.color_values) # if DEBUG: # print "values for edge %s: weight = %0.2f, targets = %d" %(str(current_edge), # weight, # targets) # self.kb.set_edge_values(current_edge, weight, targets) metric_b = toc * np.average(self.goodput) targets = self.count_targets(self.color_values) if DEBUG: print "values for edge %s: targets = %d, metric_b = %f" %(str(current_edge), targets, metric_b) self.kb.set_edge_values(current_edge, targets, metric_b) self.fsm_state = 'at_a_node' continue elif self.fsm_state == 'at_a_node': self.rf.control_radio_operation('pause') kb_state = self.kb.get_state() current_node = kb_state['next_node'] next_node = self.kb.get_next_node(current_node) current_edge = None last_edge = kb_state['current_edge'] next_edge = (current_node, next_node) self.kb.set_current_node(current_node) self.kb.set_next_node(next_node) self.kb.set_current_edge(current_edge) self.kb.set_last_edge(last_edge) self.kb.set_next_edge(next_edge) self.fsm_state = 'traversing_edge' self.reset_radio_data() self.color_values = np.array([]) self.rf.control_radio_operation('continue') continue else: print "controller.fsm() error" print "state == ", state break def count_targets(self, a): a[a!=5] = 0 j = 0 for i in range(len(a)-1): if a[i] == 0 and a[i+1] == 5: j += 1 return j def shutdown(self): self.kb.save_kb() self.motion.join() self.rf.join() time.sleep(0.1) self.location.join() # shut this down last
#!/usr/bin/env python import cPickle as pickle import pprint import numpy as np from knowledge_base import KnowledgeBase from motion.simple_motion import SimpleMotion kb = KnowledgeBase() pprint.pprint(kb.get_state()) dump_file = open('dictionary_dump.p', 'wb') pickle.dump(kb.get_state(), dump_file) dump_file.close() # def move_from_here_to_there(here, there): # coords = kb.get_state()['node_coordinates'] # src = coords[str(here)] # dst = coords[str(there)] # print "src: ", src # print "dst: ", dst # angle = np.arctan2(dst[0] - src[0], dst[1] - src[1]) * 180/np.pi # print "angle: ", angle
class Inferences(): def __init__(self, inputfile = None): # For reading/writing input/output if inputfile == None : self.inputFileName = self.getInputFileName() else : self.inputFileName = inputfile self.inputFile = open(self.inputFileName, 'r') self.outputFileName = "output.txt" self.outputFile = open(self.outputFileName, 'w') # Num queries self.numQueries = 0 # Num statements for the kb self.numStatements = 0 # List of queries. Stored as predicate objects. self.queryList = [] # The knowledge base for this set of queries self.kb = KnowledgeBase() def getInputFileName(self): # Set up input and output files parser = argparse.ArgumentParser() parser.add_argument('-i', type=str) args = parser.parse_args() inputFile = args.i return inputFile # Parses input file def readInput(self): try : # Break up by line lines = self.inputFile.read().split('\n') for line in lines : line = line.strip('\r\n') # Get number of queries to make to the KB self.numQueries = int(lines[0]) # Read each query and store it as a predicate in self.queryList for i in range(1, self.numQueries + 1) : newQuery = Predicate(lines[i]) self.queryList.append(newQuery) # Read in number of statements for the KB. self.numStatements = int(lines[self.numQueries + 1]) for j in range(self.numQueries + 2, self.numQueries + 2 + self.numStatements) : statement = lines[j] # Check if statement is a rule or a fact if "=>" in statement : newRule = Rule(statement) self.kb.addRule(newRule) else : newFact = Predicate(statement) self.kb.addFact(newFact) except Exception as e : print "\nError reading input : ", e # Call this method to solve all queries in the queryList. def solveQueries(self): try : for q in self.queryList : try : if self.kb.bcs(q) : self.outputFile.write("TRUE\n") else : self.outputFile.write("FALSE\n") except Exception as e : print "\nError executing specific query : ", e, "...Name = ", q.name except Exception as e : self.outputFile.write("FALSE\n") print "\nError executing queries : ", e # Closes file input/output streams def cleanup(self) : self.inputFile.close() self.outputFile.close()
class StandAloneRadioA(object): def __init__(self): self.kb = KnowledgeBase() self.lock = Lock() self.data = NodeAData() self.packet = Packet('A') self.radio = RadioAPI() self.tx_packet_number = 1 self.ack_packet_number = 0 self.goodput = 0 # self.data = [] # for i in range(50): # self.data.append(0xff) def _configure_radio(self, power, frequency, data_rate, modulation): """ Configure radio for operation. """ self.radio.configure_radio(power, frequency, data_rate, modulation) def _send_packet(self): """ Transmit packet. """ self.packet.set_flags_node_a() location = self.kb.get_state()['current_location'] data = self.data.pack_data() tx_packet = self.packet.make_packet(self.tx_packet_number, location, data) self.radio.transmit(tx_packet) def _receive_packet(self): """ Receive packet. """ rx_packet = self.radio.receive(rx_fifo_threshold=64, timeout=1.0) if rx_packet == []: # this occurs when timeout has been exceeded return else: packet_number, time_stamp, location, flags, data = self.packet.parse_packet(rx_packet) self.ack_packet_number, self.goodput = self.data.unpack_data(data) # print "packet_number=%d time_stamp=%f location=%d flags=0x%x" %(packet_number, time_stamp, # location, flags) print "goodput for acknowledged packet #%d = %f bits/second" %(self.ack_packet_number, self.goodput) def _listen(self): """ Listen before talk. """ status = self.radio.listen(rssi_threshold=100, timeout=1.0) if status == 'clear': print "channel clear" def _fsm(self): self._listen() time.sleep(0.01) self._send_packet() time.sleep(0.01) self._receive_packet() time.sleep(0.01) def run(self): """ Run the radio subsystem. """ self.radio.startup() default_radio_profile = location = self.kb.get_state()['default_radio_profile'] power = default_radio_profile['power'] frequency = default_radio_profile['frequency'] data_rate = default_radio_profile['data_rate'] modulation = default_radio_profile['modulation'] self._configure_radio(power, frequency, data_rate, modulation) # state = "listen" while True: self._fsm() self.lock.acquire() self.kb.sent_packets.append(self.tx_packet_number) self.kb.ack_packets.append((self.ack_packet_number, self.goodput)) self.lock.release() self.tx_packet_number += 1 def shutdown(self): self.kb.save_kb() self.radio.shutdown()