def __init__(self): """ Configuration """ # Camera settings self.FRAME_WIDTH = 341 self.FRAME_HEIGHT = 256 self.flip_camera = True # Mirror image self.camera = cv2.VideoCapture(1) # ...you can also use a test video for input #video = "/Users/matthiasendler/Code/snippets/python/tracker/final/assets/test_video/10.mov" #self.camera = cv2.VideoCapture(video) #self.skip_input(400) # Skip to an interesting part of the video if not self.camera.isOpened(): print "couldn't load webcam" return #self.camera.set(cv2.cv.CV_CAP_PROP_FRAME_WIDTH, self.FRAME_WIDTH) #self.camera.set(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT, self.FRAME_HEIGHT) self.filters_dir = "filters/" # Filter settings in trackbar self.filters_file = "filters_default" # Load filter settings current_config = self.filters_dir + self.filters_file self.filters = Filters(current_config) # No actions will be triggered in test mode # (can be used to adjust settings at runtime) self.test_mode = False # Create a hand detector # In fact, this is a wrapper for many detectors # to increase detection confidence self.detector = Detector(self.filters.config) # Knowledge base for all detectors self.kb = KB() # Create gesture recognizer. # A gesture consists of a motion and a hand state. self.gesture = Gesture() # The action module executes keyboard and mouse commands self.action = Action() # Show output of detectors self.output = Output() self.run()
class Tracker(object): """ This is the main program which gives a high-level view of all the running subsystems. It connects camera input with output in form of "actions" (such as keyboard shortcuts on the users behalf). This is done by locating a hand in an image and detecting features, like the number of fingers, and trying to match that data with a known gesture. """ def __init__(self): """ Configuration """ # Camera settings self.FRAME_WIDTH = 341 self.FRAME_HEIGHT = 256 self.flip_camera = True # Mirror image self.camera = cv2.VideoCapture(1) # ...you can also use a test video for input #video = "/Users/matthiasendler/Code/snippets/python/tracker/final/assets/test_video/10.mov" #self.camera = cv2.VideoCapture(video) #self.skip_input(400) # Skip to an interesting part of the video if not self.camera.isOpened(): print "couldn't load webcam" return #self.camera.set(cv2.cv.CV_CAP_PROP_FRAME_WIDTH, self.FRAME_WIDTH) #self.camera.set(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT, self.FRAME_HEIGHT) self.filters_dir = "filters/" # Filter settings in trackbar self.filters_file = "filters_default" # Load filter settings current_config = self.filters_dir + self.filters_file self.filters = Filters(current_config) # No actions will be triggered in test mode # (can be used to adjust settings at runtime) self.test_mode = False # Create a hand detector # In fact, this is a wrapper for many detectors # to increase detection confidence self.detector = Detector(self.filters.config) # Knowledge base for all detectors self.kb = KB() # Create gesture recognizer. # A gesture consists of a motion and a hand state. self.gesture = Gesture() # The action module executes keyboard and mouse commands self.action = Action() # Show output of detectors self.output = Output() self.run() def run(self): """ In each step: Read the input image and keys, process it and react on it (e.g. with an action). """ while True: img = self.get_input() hand = self.process(img) ref = self.action.get_reference_point() self.output.show(img, hand, ref) def process(self, img): """ Process input """ # Run detection hand = self.detector.detect(img) # Store result in knowledge base self.kb.update(hand) if not self.test_mode: # Try to interprete as gesture self.interprete(hand) return hand def interprete(self, hand): """ Try to interprete the input as a gesture """ self.gesture.add_hand(hand) operation = self.gesture.detect_gesture() self.action.execute(operation) def get_input(self): """ Get input from camera and keyboard """ self.get_key() _, img = self.camera.read() img = cv2.resize(img, (self.FRAME_WIDTH, self.FRAME_HEIGHT)) if self.flip_camera: img = cv2.flip(img, 1) return img def get_key(self): """ Read keyboard input """ key = cv2.waitKey(self.filters.config["wait_between_frames"]) if key == ord('+'): # Reduce program speed self.filters.config["wait_between_frames"] += 500 if key == ord('-'): # Increase program speed if self.filters.config["wait_between_frames"] >= 500: self.filters.config["wait_between_frames"] -= 500 #if key == ord('s'): # Save config # self.filters.save() if key == ord('r'): # Reset all detectors self.detector.reset() self.action.reset() if key == ord('d'): # Make a screenshot self.output.make_screenshot() if key == ord('p') or key == ord(' '): # Pause cv2.waitKey() if key == ord('t'): # Test mode self.test_mode = not self.test_mode if key == ord('1'): self.output.toggle_estimate() if key == ord('2'): self.output.toggle_detectors() if key == ord('3'): self.output.toggle_skin() if key == ord('f'): self.toggle_filters() if key == 63235: # Right arrow self.skip_input(20) if key == 27 or key == ord('q'): # Abort program on ESC, q or space exit() def toggle_filters(self): """ Load the next filter settings """ self.filters_file = self.next_filters_file() current_config = self.filters_dir + self.filters_file self.filters.set_config(current_config) def next_filters_file(self): """ Get the next filter settings """ filters = listdir(self.filters_dir) for i, f in enumerate(filters): if f == self.filters_file: return filters[(i+1) % len(filters)] def skip_input(self, x=1): """ Skip to a different part of a video sequence. """ for i in range(0,x): self.camera.grab()
hence we play the lowest possible card. If the played card is not from the trump suit, we first check for a card stronger than that card, then we look for a trump card to win that trick. If these conditions are not fulfilled, it can be predicted that we loose that trick, hence we simply play the lowest non-trump card. Again, if we don't have such a card, we play the lowest possible card. It loads general information about the game, as well as the definition of a strategy, from load.py. """ from api import State, util, Deck import random, load, copy from bots.ultra import kb from kb import KB, Boolean, Integer kb = KB() THRESHOLD = 10 class Bot: __RANKS = ["a", "t", "k", "q", "j"] def __init__(self): pass def get_move(self, state): whose_turn = state.whose_turn() leader = state.leader() trump_suit = state.get_trump_suit() if whose_turn == leader: global kb
def __init__(self, num_relations, num_entities, arities=[0.0, 1.0, 0.0], fb_densities=[0.0, 0.0, 0.0], arg_densities=[0., 0.1, 0.0], fact_prob=0.2, num_symm=2, num_impl=[0, 2, 0], num_impl_inv=2, num_impl_conj=[0, 2, 0], num_trans_single=2, num_trans_diff=2, seed=0, position_dependent_args=False, position_densities=[0., 0.5, 0.0]): """ :param num_relations: :param num_entities: number of distinct entities to generate :param arities: fraction of arities :param arg_densities: fraction of entity combinations that are observed :param fact_prob: :param num_inv: number of 'inv' formulae R(X0, X1) :- R(X1, X0) :param num_impl: :param num_impl_conj: :param num_trans: :param negated_head_prob: :param seed: :return: """ random.seed(seed) self.kb = KB(seed=seed) num_relations_per_arity = [int(x * num_relations) for x in arities] entities = list(map(lambda x: "e" + str(x), range(1, num_entities+1))) entities_arg1 = [] entities_arg2 = [] entities_arg3 = [] if position_dependent_args: arg1_boundary = int(len(entities)*position_densities[0]) arg2_boundary = arg1_boundary + int(len(entities)*position_densities[1]) entities_arg1 = entities[0:arg1_boundary] entities_arg2 = entities[arg1_boundary:arg2_boundary] entities_arg3 = entities[arg2_boundary:] else: entities_arg1 = entities entities_arg2 = entities entities_arg3 = entities pairs = [(x, y) for x in entities_arg1 for y in entities_arg2 if not x == y] triples = [(x, y, z) for x in entities_arg1 for y in entities_arg2 for z in entities_arg3 if not x == y and not y == z and not z == x] num_pair_samples = min(len(pairs), int(len(entities_arg1) * len(entities_arg2) * arg_densities[1])) num_triple_samples = min(len(triples), int(len(entities_arg1) * len(entities_arg2) * len(entities_arg3) * arg_densities[2])) entities_per_arity = { 1: entities_arg1, 2: random.sample(pairs, num_pair_samples), 3: random.sample(triples, num_triple_samples) } relations_per_arity = {} for arity in range(1, len(num_relations_per_arity) + 1): for i in range(1, num_relations_per_arity[arity - 1] + 1): fb_prefix = "" if fb_densities[arity-1] > random.uniform(0, 1.0): fb_prefix = "REL$" if arity == 1: rel = fb_prefix+"u" elif arity == 2: rel = fb_prefix+"b" else: rel = fb_prefix+"t" rel += str(i) if not arity in relations_per_arity: relations_per_arity[arity] = list() relations_per_arity[arity].append(rel) for args in random.sample(entities_per_arity[arity], int(len(entities_per_arity[arity]) * fact_prob)): self.kb.add_train(rel, args) inverse = [] # sample symmetric relations r(X,Y) => r(Y,X) if 2 in relations_per_arity: symm = random.sample([(x, x) for x in relations_per_arity[2]], num_symm) inverse += symm # sampling implication, reversed: r1(X,Y) => r2(Y,X) if 2 in relations_per_arity: inverse += random.sample([(x, y) for x in relations_per_arity[2] for y in relations_per_arity[2] if not x == y], num_impl_inv) if len(inverse) > 0: self.kb.add_formulae("inv", {2: inverse}) # sampling implications: # r1(X) => r2(X) # r1(X,Y) => r2(X,Y) implications_per_arity = {} for arity in range(1, len(num_relations_per_arity) + 1): if arity in relations_per_arity: implications_per_arity[arity] = \ random.sample([(x, y) for x in relations_per_arity[arity] for y in relations_per_arity[arity] if not x == y], num_impl[arity - 1]) self.kb.add_formulae("impl", implications_per_arity) # sampling implications with conjunction in body: # r1(X,Y) ^ r2(X,Y) => r3(X,Y) # r1(X) ^ r2(X) => r3(X) implications_with_conjunction_per_arity = {} for arity in range(1, len(num_relations_per_arity) + 1): if arity in relations_per_arity and len(relations_per_arity[arity]) >= 3: implications_with_conjunction_per_arity[arity] = \ random.sample([(x, y, z) for x in relations_per_arity[arity] for y in relations_per_arity[arity] for z in relations_per_arity[arity] if not x == y and not y == z and not z == x], num_impl_conj[arity - 1]) self.kb.add_formulae("impl_conj", implications_with_conjunction_per_arity) # sampling transitivities: transitivities = [] # (1) simple transitivities r(X,Y) ^ r(Y,Z) => r(X,Z) # (2) general transitivities r1(X,Y) ^ r2(Y,Z) => r3(X,Z) (r1, r2, r3 differ) if 2 in relations_per_arity: if num_trans_single > 0: transitivities += random.sample([(x, x, x) for x in relations_per_arity[2]], num_trans_single) if num_trans_diff > 0: transitivities += random.sample([(x, y, z) for x in relations_per_arity[2] for y in relations_per_arity[2] for z in relations_per_arity[2] if not x == y and not y == z and not z == x], num_trans_diff) if len(transitivities) > 0: self.kb.add_formulae("trans", {2: transitivities})
def init(self, kb_host="localhost", kb_port=6969, embeddedkb=False, defaultontology=None, data_path=None): if not data_path: # try to guess the current prefix and then the data directory data_path = os.path.abspath(__file__).split('lib')[0].split( 'src')[0] + 'share/dialogs/' logger.debug("Assuming Dialogs data dir is <%s>" % data_path) try: from kb import KB, KbError except ImportError: logger.error("Python bindings to access the knowledge are not available." + \ "Please install 'pykb' and restart Dialogs.") try: self.ontology_server = KB(kb_host, kb_port, embeddedkb, defaultontology) except KbError: logger.error("Error while trying to connect to the knowledge base on %s:%s" % (kb_host, kb_port) + \ ". Continuing without knowledge base. Amongst others, resolution won't work.") self.ontology_server = DummyKnowledgeBase() for line in open(os.path.join(data_path, "adjectives")): if line.startswith("#") or not line.strip(): continue try: adj, cat = line.split() except ValueError: # for adjectives without category, set a generic "Feature" category adj = line.split()[0] cat = "Feature" self.adjectives[adj] = cat verbs = [ list(line.split()) for line in open(os.path.join(data_path, "verbs")) ] verbs = self.split_list(verbs) self.irregular_verbs_past = verbs[0] self.irregular_verbs_present = verbs[1] self.preposition_verbs = verbs[2] self.modal = [k[0] for k in verbs[3]] self.adjective_verb = [k[0] for k in verbs[4]] self.auxiliary = [k[0] for k in verbs[5]] self.direct_transitive = [k[0] for k in verbs[6]] self.indirect_transitive = [k[0] for k in verbs[7]] self.state = [k[0] for k in verbs[8]] self.verb_need_to = [k[0] for k in verbs[9]] self.special_verbs = [k[0] for k in verbs[12]] # Action verbs such as 'see', 'hear' with no active behaviour self.action_verb_with_passive_behaviour = dict([(k[0], k[1]) for k in verbs[10]]) self.goal_verbs = [k[0] for k in verbs[11]] self.sentence_starts = [ tuple(line.split()) for line in open(os.path.join(data_path, "sentence_starts")) ] nouns = [ list(line.split()) for line in open(os.path.join(data_path, "nouns")) ] nouns = self.split_list(nouns) self.special_nouns = [k[0] for k in nouns[0]] self.pronouns = [k[0] for k in nouns[1]] for i in nouns[1]: if i[1] == '1': self.complement_pronouns = self.complement_pronouns + [i[0]] self.demonstrative_det = [k[0] for k in nouns[2]] self.determinants = [k[0] for k in nouns[3]] self.nouns_end_s = [k[0] for k in nouns[4]] self.relatives = [k[0] for k in nouns[5]] self.composed_nouns = [k[0] for k in nouns[6]] self.plural_nouns = nouns[7] self.noun_not_composed = [k[0] for k in nouns[8]] self.days_list = nouns[9] self.months_list = nouns[10] self.unusable_words = [k[0] for k in nouns[11]] # List of diection words, E.g: LEFT, RIGHT, TOP, etc ... self.direction_words = [k[0] for k in nouns[12]] self.compound_nouns = nouns[13] ### ### ADVERBIALS adverbials = [ list(line.split()) for line in open(os.path.join(data_path, "adverbial")) ] adverbials = self.split_list(adverbials) self.adverbs = [k[0] for k in adverbials[0]] self.time_adverbs = adverbials[0] self.time_adverbs = [ k[0] for k in adverbials[0] if k[1] in ["day", "hour"] ] self.time_adverbs += [ k[0] for k in adverbials[1] if k[1] in ["day", "hour"] ] self.location_adverbs = [ k[0] for k in adverbials[0] if k[1] == "location" ] self.location_adverbs += [ k[0] for k in adverbials[1] if k[1] == "location" ] self.adverbs_at_end = [k[0] for k in adverbials[1]] for k in adverbials[2]: if k[1] == '1': self.compelement_proposals = self.compelement_proposals + [ k[0] ] self.proposals = [k[0] for k in adverbials[2]] #Preposition with an existing object_property # E.g: next+to => isNextTo self.preposition_rdf_object_property = dict([(k[0], k[3:]) for k in adverbials[2]]) self.time_proposals = adverbials[2] self.subsentences = [k[0] for k in adverbials[3]] for k in adverbials[3]: if k[1] == '1': self.adv_sub = self.adv_sub + [k[0]] self.prep_change_place = [k[0] for k in adverbials[4]] grammatical_rules = [ list(line.split()) for line in open(os.path.join(data_path, "grammatical_rules")) ] grammatical_rules = self.split_list(grammatical_rules) self.numbers = grammatical_rules[0] self.det_quantifiers = grammatical_rules[1] self.capital_letters = [k[0] for k in grammatical_rules[2]] self.adjective_rules = [k[0] for k in grammatical_rules[3]] self.concatenate_proposals = grammatical_rules[4] self.change_tuples = grammatical_rules[5] self.adjective_numbers_digit = grammatical_rules[6] self.adjective_numbers = [k[0] for k in grammatical_rules[6]] self.be_pronoun = [k[0] for k in grammatical_rules[7]] self.adj_quantifiers = [k[0] for k in grammatical_rules[8]] for k in grammatical_rules[9]: self.replace_tuples = self.replace_tuples + [[k[0], k[1:]]] desc = "" for line in open(os.path.join(data_path, "thematic_roles")): if line.startswith("#") or not line.strip(): continue desc += line if line.startswith("}"): #end of block self.thematic_roles.add_verb(desc) desc = "" #Add action verbs to the ontology if self.ontology_server: stmts = [ verb.capitalize() + " rdfs:subClassOf cyc:PurposefulAction" for verb in self.thematic_roles.verbs.keys() if not self.thematic_roles.verbs[verb].is_synonym() ] self.ontology_server.revise(stmts, {"method": "add"}) """ List of ontology classes that are used in the adjectives list """ self.adjectives_ontology_classes = [ self.adjectives[adj].lower() for adj in self.adjectives ] adj_s = [] for k in self.adjectives_ontology_classes: if not k in adj_s: adj_s.append(k) self.adjectives_ontology_classes = adj_s
PA7 = Boolean('pa7') PA8 = Boolean('pa8') PA9 = Boolean('pa9') PA10 = Boolean('pa10') PA11 = Boolean('pa11') PA12 = Boolean('pa12') PA13 = Boolean('pa13') PA14 = Boolean('pa14') PA15 = Boolean('pa15') PA16 = Boolean('pa16') PA17 = Boolean('pa17') PA18 = Boolean('pa18') PA19 = Boolean('pa19') # Create a new knowledge base kb = KB() # GENERAL INFORMATION ABOUT THE CARDS # This adds information which cards are Jacks kb.add_clause(J4) kb.add_clause(J9) kb.add_clause(J14) kb.add_clause(J19) # Add here whatever is needed for your strategy. kb.add_clause(A0) kb.add_clause(A5) kb.add_clause(A10) kb.add_clause(A15) # DEFINITION OF THE STRATEGY # Add clauses (This list is sufficient for this strategy) # PJ is the strategy to play jacks first, so all we need to model is all x PJ(x) <-> J(x),
import sys from kb import KB, Boolean, Integer, Constant # Define our symbols P = Boolean('P') Q = Boolean('Q') R = Boolean('R') # Create a new knowledge base kb = KB() # Add clauses kb.add_clause(P, Q) kb.add_clause(~Q, R) kb.add_clause(~R, ~P) kb.add_clause(~P, ~Q) # Print all models of the knowledge base for model in kb.models(): print(model) # Print out whether the KB is satisfiable (if there are no models, it is not satisfiable) print(kb.satisfiable())
import sys from kb import KB, Boolean, Integer, Constant # Define our integer symbols x = Integer('x') y = Integer('y') q = x == y a = x + y > 2 b = x + y < 5 c = x + y < -2 d = x + y > -5 kb = KB() kb.add_clause(q) kb.add_clause(???) kb.add_clause(???) kb.add_clause(???) kb.add_clause(???) for model in kb.models(): print(model)
from kb import KB from fact import Fact import sys kb = KB() kb_file = sys.argv[1] query_file = sys.argv[2] answer_file = sys.argv[3] kb_file = open(kb_file, 'r') clauses = kb_file.readlines() KB.CreateKB(kb, clauses) query_file = open(query_file, 'r') answer_file = open(answer_file, 'w') count_query = 1 for query in query_file.readlines(): alpha = Fact.ParseFact(query) alpha_str = str(alpha) + '.' print(str(count_query) + "/", alpha_str) substs = set(kb.Query(alpha)) substs_str = ' ;\n'.join([str(subst) for subst in substs]) + '.\n' print(substs_str) answer_file.write(alpha_str + '\n') answer_file.write(substs_str + '\n') count_query += 1
def kb_consistent(self, state, move): # type: (State, move) -> bool # each time we check for consistency we initialise a new knowledge-base kb = KB() # Add general information about the game load.general_information(kb) # Add the necessary knowledge about the strategy load.strategy_knowledge(kb) # This line stores the index of the card in the deck. # If this doesn't make sense, refer to _deck.py for the card index mapping index = move[0] # This creates the string which is used to make the strategy_variable. # Note that as far as kb.py is concerned, two objects created with the same # string in the constructor are equivalent, and are seen as the same symbol. # Here we use "pj" to indicate that the card with index "index" should be played with the # PlayJack heuristics that was defined in class. Initialise a different variable if # you want to apply a different strategy (that you will have to define in load.py) # # Always play trump trump_suit = state.get_trump_suit() trump = trump_suit.lower() if trump == 'c': pj = Boolean('pj4') pq = Boolean('pq3') pk = Boolean('pk2') pt = Boolean('pt1') pa = Boolean('pa0') if trump == 'd': pj = Boolean('pj9') pq = Boolean('pq8') pk = Boolean('pk7') pt = Boolean('pt6') pa = Boolean('pa5') if trump == 'h': pj = Boolean('pj14') pq = Boolean('pq13') pk = Boolean('pk12') pt = Boolean('pt11') pa = Boolean('pa10') if trump == 's': pj = Boolean('pj19') pq = Boolean('pq18') pk = Boolean('pk17') pt = Boolean('pt16') pa = Boolean('pa15') kb.add_clause(~pj, ~pq, ~pk, ~pt, ~pa) # # always play Jack # variable_string = "pj" + str(index) # strategy_variable = Boolean(variable_string) # Add the relevant clause to the loaded knowledge base # kb.add_clause(~strategy_variable) # If the knowledge base is not satisfiable, the strategy variable is # entailed (proof by refutation) return kb.satisfiable()
PJ7 = Boolean('pj7') PJ8 = Boolean('pj8') PJ9 = Boolean('pj9') PJ10 = Boolean('pj10') PJ11 = Boolean('pj11') PJ12 = Boolean('pj12') PJ13 = Boolean('pj13') PJ14 = Boolean('pj14') PJ15 = Boolean('pj15') PJ16 = Boolean('pj16') PJ17 = Boolean('pj17') PJ18 = Boolean('pj18') PJ19 = Boolean('pj19') # Create a new knowledge base kb = KB() # GENERAL INFORMATION ABOUT THE CARDS # This adds information which cards are Jacks kb.add_clause(J4) kb.add_clause(J9) kb.add_clause(J14) kb.add_clause(J19) # Adds information on which cards are As kb.add_clause(J0) kb.add_clause(J5) kb.add_clause(J10) kb.add_clause(J15) # DEFINITION OF THE STRATEGY # Add clauses (This list is sufficient for this strategy)
def main(args): if (not args.do_train) and (not args.do_valid) and (not args.do_test): raise ValueError('one of train/val/test mode must be choosed.') if args.init_checkpoint: override_config(args) elif args.data_path is None: raise ValueError('one of init_checkpoint/data_path must be choosed.') if args.do_train and args.save_path is None: raise ValueError('Where do you want to save your trained model?') if args.save_path and not os.path.exists(args.save_path): os.makedirs(args.save_path) # Write logs to checkpoint and console set_logger(args) with open(os.path.join(args.data_path, 'entities.dict')) as fin: entity2id = dict() id2entity = dict() for line in fin: eid, entity = line.strip().split('\t') entity2id[entity] = int(eid) id2entity[int(eid)] = entity with open(os.path.join(args.data_path, 'relations.dict')) as fin: relation2id = dict() id2relationship = dict() for line in fin: rid, relation = line.strip().split('\t') relation2id[relation] = int(rid) id2relationship[int(rid)] = relation # Read regions for Countries S* datasets if args.countries: regions = list() with open(os.path.join(args.data_path, 'regions.list')) as fin: for line in fin: region = line.strip() regions.append(entity2id[region]) args.regions = regions e_vocab = Dictionary(tok2ind=entity2id, ind2tok=id2entity) r_vocab = Dictionary(tok2ind=relation2id, ind2tok=id2relationship) ## TODO: add graph file graph = KB(os.path.join(args.data_path, 'train.txt'), e_vocab=e_vocab, r_vocab=r_vocab) nentity = len(entity2id) nrelation = len(relation2id) args.nentity = nentity args.nrelation = nrelation logging.info('Model: %s' % args.model) logging.info('Data Path: %s' % args.data_path) logging.info('#entity: %d' % nentity) logging.info('#relation: %d' % nrelation) train_triples = read_triple(os.path.join(args.data_path, 'train.txt'), entity2id, relation2id) logging.info('#train: %d' % len(train_triples)) valid_triples = read_triple(os.path.join(args.data_path, 'valid.txt'), entity2id, relation2id) logging.info('#valid: %d' % len(valid_triples)) test_triples = read_triple(os.path.join(args.data_path, 'test.txt'), entity2id, relation2id) logging.info('#test: %d' % len(test_triples)) candidate_entities = None if args.rerank_minerva: candidate_entities = defaultdict(set) with open( "/home/shdhulia//Limits-of-Path-Reasoner/outputs/FB15K-237/thisone_test/all_answers.txt" ) as candidate_file: # with open("/home/shdhulia/minerva_answers/fb.txt") as candidate_file: for line in candidate_file: pt = line.strip().split("\t") e1 = entity2id[pt[0]] r = relation2id[pt[1]] predicted_es = set( [entity2id[p] for p in pt[2:] if p in entity2id]) candidate_entities[(e1, r)] = set(predicted_es) #All true triples all_true_triples = train_triples + valid_triples + test_triples kge_model = KGEModel( model_name=args.model, nentity=nentity, nrelation=nrelation, hidden_dim=args.hidden_dim, gamma=args.gamma, double_entity_embedding=args.double_entity_embedding, double_relation_embedding=args.double_relation_embedding) logging.info('Model Parameter Configuration:') for name, param in kge_model.named_parameters(): logging.info('Parameter %s: %s, require_grad = %s' % (name, str(param.size()), str(param.requires_grad))) if args.cuda: kge_model = kge_model.cuda() if args.do_train: # Set training dataloader iterator # train_dataloader_head = DataLoader( # TrainDataset(train_triples, nentity, nrelation, args.negative_sample_size, 'head-batch'), # batch_size=args.batch_size, # shuffle=True, # num_workers=max(1, args.cpu_num//2), # collate_fn=TrainDataset.collate_fn # ) train_dataloader_tail = DataLoader( TrainDataset(train_triples, nentity, nrelation, args.negative_sample_size, 'tail-batch', KB=graph), batch_size=args.batch_size, shuffle=True, num_workers=max(1, args.cpu_num // 2), collate_fn=TrainDataset.collate_fn) # train_iterator = BidirectionalOneShotIterator(train_dataloader_head, train_dataloader_tail) train_iterator = OneShotIterator(train_dataloader_tail) # Set training configuration current_learning_rate = args.learning_rate optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad, kge_model.parameters()), lr=current_learning_rate) if args.warm_up_steps: warm_up_steps = args.warm_up_steps else: warm_up_steps = args.max_steps // 2 if args.init_checkpoint: # Restore model from checkpoint directory logging.info('Loading checkpoint %s...' % args.init_checkpoint) checkpoint = torch.load( os.path.join(args.init_checkpoint, 'checkpoint')) init_step = checkpoint['step'] kge_model.load_state_dict(checkpoint['model_state_dict']) if args.do_train: current_learning_rate = checkpoint['current_learning_rate'] warm_up_steps = checkpoint['warm_up_steps'] optimizer.load_state_dict(checkpoint['optimizer_state_dict']) else: logging.info('Ramdomly Initializing %s Model...' % args.model) init_step = 0 step = init_step logging.info('Start Training...') logging.info('init_step = %d' % init_step) logging.info('batch_size = %d' % args.batch_size) logging.info('negative_adversarial_sampling = %d' % args.negative_adversarial_sampling) logging.info('hidden_dim = %d' % args.hidden_dim) logging.info('gamma = %f' % args.gamma) logging.info('negative_adversarial_sampling = %s' % str(args.negative_adversarial_sampling)) if args.negative_adversarial_sampling: logging.info('adversarial_temperature = %f' % args.adversarial_temperature) # Set valid dataloader as it would be evaluated during training if args.do_train: logging.info('learning_rate = %d' % current_learning_rate) training_logs = [] #Training Loop for step in range(init_step, args.max_steps): log = kge_model.train_step(kge_model, optimizer, train_iterator, args) training_logs.append(log) if step >= warm_up_steps: current_learning_rate = current_learning_rate / 10 logging.info('Change learning_rate to %f at step %d' % (current_learning_rate, step)) optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad, kge_model.parameters()), lr=current_learning_rate) warm_up_steps = warm_up_steps * 3 if step % args.save_checkpoint_steps == 0: save_variable_list = { 'step': step, 'current_learning_rate': current_learning_rate, 'warm_up_steps': warm_up_steps } save_model(kge_model, optimizer, save_variable_list, args) if step % args.log_steps == 0: metrics = {} for metric in training_logs[0].keys(): metrics[metric] = sum( [log[metric] for log in training_logs]) / len(training_logs) log_metrics('Training average', step, metrics) training_logs = [] if args.do_valid and step % args.valid_steps == 0: logging.info('Evaluating on Valid Dataset...') metrics = kge_model.test_step(kge_model, valid_triples, all_true_triples, args) log_metrics('Valid', step, metrics) save_variable_list = { 'step': step, 'current_learning_rate': current_learning_rate, 'warm_up_steps': warm_up_steps } save_model(kge_model, optimizer, save_variable_list, args) if args.do_valid: logging.info('Evaluating on Valid Dataset...') metrics = kge_model.test_step(kge_model, valid_triples, all_true_triples, args, candidate_entities, id2e=id2entity, id2rel=id2relationship) log_metrics('Valid', step, metrics) # if args.do_test: # logging.info('Evaluating on Test Dataset...') # metrics = kge_model.test_step(kge_model, test_triples, all_true_triples, args) # log_metrics('Test', step, metrics) if args.do_test: logging.info('Evaluating on Test Dataset...') metrics = kge_model.test_step(kge_model, test_triples, all_true_triples, args, candidate_entities, id2e=id2entity, id2rel=id2relationship) log_metrics('Test', step, metrics) if args.evaluate_train: logging.info('Evaluating on Training Dataset...') metrics = kge_model.test_step(kge_model, train_triples, all_true_triples, args) log_metrics('Test', step, metrics)
PJ7 = Boolean('pj7') PJ8 = Boolean('pj8') PJ9 = Boolean('pj9') PJ10 = Boolean('pj10') PJ11 = Boolean('pj11') PJ12 = Boolean('pj12') PJ13 = Boolean('pj13') PJ14 = Boolean('pj14') PJ15 = Boolean('pj15') PJ16 = Boolean('pj16') PJ17 = Boolean('pj17') PJ18 = Boolean('pj18') PJ19 = Boolean('pj19') # Create a new knowledge base kb = KB() # GENERAL INFORMATION ABOUT THE CARDS # This adds information which cards are Jacks kb.add_clause(J4) kb.add_clause(J9) kb.add_clause(J14) kb.add_clause(J19) # Add here whatever is needed for your strategy. kb.add_clause(J0) kb.add_clause(J5) kb.add_clause(J10) kb.add_clause(J15) # DEFINITION OF THE STRATEGY # Add clauses (This list is sufficient for this strategy) # PJ is the strategy to play jacks first, so all we need to model is all x PJ(x) <-> J(x),
import sys from kb import KB, Boolean, Integer, Constant # Define our integer symbols x = Integer('x') y = Integer('y') q = x == y a = x + y > 2 b = x + y < 5 c = x + y < -2 d = x + y > -5 kb = KB() kb.add_clause(q) kb.add_clause(c, a) kb.add_clause(d, a) kb.add_clause(c, b) kb.add_clause(d, b) for model in kb.models(): print(model)
import sys from kb import KB, Boolean, Integer, Constant # Define our symbols P = Boolean('P') Q = Boolean('Q') R = Boolean('R') # Create P new knowledge base kb = KB() # KB kb.add_clause(P, Q) kb.add_clause(R, ~Q) kb.add_clause(~P, ~R) # ~alpha kb.add_clause(P, ~Q) kb.add_clause(~P, Q) # Print all models of the knowledge base for model in kb.models(): print(model) # Print out whether the KB is satisfiable (if there are no models, it is not satisfiable) print(kb.satisfiable())
import sys from kb import KB, Boolean, Integer, Constant # Define our integer symbols x = Integer('x') y = Integer('y') q = x == y a = x + y > 2 b = x + y < 5 c = x + y < -2 d = x + y > -5 kb = KB() kb.add_clause(q) kb.add_clause(a, c) kb.add_clause(a, d) kb.add_clause(b, c) kb.add_clause(b, d) for model in kb.models(): print(model) # Print out whether the KB is satisfiable (if there are no models, it is not satisfiable) print(kb.satisfiable())
Pa7 = Boolean('pa7') Pa8 = Boolean('pa8') Pa9 = Boolean('pa9') Pa10 = Boolean('pa10') Pa11 = Boolean('pa11') Pa12 = Boolean('pa12') Pa13 = Boolean('pa13') Pa14 = Boolean('pa14') Pa15 = Boolean('pa15') Pa16 = Boolean('pa16') Pa17 = Boolean('pa17') Pa18 = Boolean('pa18') Pa19 = Boolean('pa19') # Create a new knowledge base kb = KB() # GENERAL INFORMATION ABOUT THE CARDS # This adds information which cards are aacks kb.add_clause(a0) kb.add_clause(a5) kb.add_clause(a10) kb.add_clause(a15) # Add here whatever is needed for your strategy. # DEFINITION OF THE STRATEGY # Add clauses (This list is sufficient for this strategy) # Pa is the strategy to play aces first, so all we need to model is all x Pa(x) <-> a(x), # In other words that the Pa strategy should play a card when it is an ace kb.add_clause(~a0, Pa0) kb.add_clause(~a5, Pa5)
import sys from kb import KB, Boolean, Integer, Constant # Define our integer symbols x = Integer('x') y = Integer('y') q = x == y a = x + y > 2 b = x + y < 5 c = x + y < -2 d = x + y > -5 kb = KB() kb.add_clause(q) kb.add_clause(a, d) kb.add_clause(a, c) kb.add_clause(b, d) kb.add_clause(b, c) for model in kb.models(): print(model)
PJ7 = Boolean('pj7') PJ8 = Boolean('pj8') PJ9 = Boolean('pj9') PJ10 = Boolean('pj10') PJ11 = Boolean('pj11') PJ12 = Boolean('pj12') PJ13 = Boolean('pj13') PJ14 = Boolean('pj14') PJ15 = Boolean('pj15') PJ16 = Boolean('pj16') PJ17 = Boolean('pj17') PJ18 = Boolean('pj18') PJ19 = Boolean('pj19') # Create a new knowledge base kb = KB() # GENERAL INFORMATION ABOUT THE CARDS # This adds information which cards are Jacks kb.add_clause(J1) kb.add_clause(J6) kb.add_clause(J11) kb.add_clause(J16) # Add here whatever is needed for your strategy. # DEFINITION OF THE STRATEGYcb # Add clauses (This list is sufficient for this strategy) # PJ is the strategy to play jacks first, so all we need to model is all x PJ(x) <-> J(x), # In other words that the PJ strategy should play a card when it is a jack kb.add_clause(~J1, PJ1) kb.add_clause(~J6, PJ6)
PC14 = Boolean('pc14') PC15 = Boolean('pc15') PC16 = Boolean('pc16') PC17 = Boolean('pc17') PC18 = Boolean('pc18') PC19 = Boolean('pc19') #Trump suit C = Boolean('c') D = Boolean('d') H = Boolean('h') S = Boolean('s') # Create a new knowledge base kb = KB() # GENERAL INFORMATION ABOUT THE CARDS # This adds information which cards are Kings, Queens and Jacks kb.add_clause(C2) kb.add_clause(C3) kb.add_clause(C4) kb.add_clause(C7) kb.add_clause(C8) kb.add_clause(C9) kb.add_clause(C12) kb.add_clause(C13) kb.add_clause(C14) kb.add_clause(C17)
class ResourcePool(object): default_model = "default" def split_list(self, word_list): # init flag = 0 list_list_word = our_list = [] for i in word_list: if i: if i[0].startswith("#"): if flag == 0: flag = 1 if our_list: list_list_word = list_list_word + [our_list] our_list = [] else: flag = 0 else: if flag == 0: our_list = our_list + [i] list_list_word = list_list_word + [our_list] return list_list_word def __init__(self): """ Empty constructor for the singleton decorator. Real initialization must be manually triggered by calling ResourcePool.init(). """ self.ontology_server = None self.adjectives = {} self.irregular_verbs_past = [] self.irregular_verbs_present = [] self.preposition_verbs = [] self.modal = [] self.adjective_verb = [] self.special_nouns = [] self.pronouns = [] self.numbers = [] self.demonstrative_det = [] self.adverbs = [] self.adverbs_at_end = [] self.proposals = [] self.preposition_rdf_object_property = {} self.compelement_proposals = [] self.capital_letters = [] self.determinants = [] self.nouns_end_s = [] self.relatives = [] self.subsentences = [] self.det_quantifiers = [] self.adjective_rules = [] self.composed_nouns = [] self.plural_nouns = [] self.auxiliary = [] self.direct_transitive = [] self.indirect_transitive = [] self.state = [] self.complement_pronouns = [] self.concatenate_proposals = [] self.change_tuples = [] self.adjective_numbers = [] self.be_pronoun = [] self.noun_not_composed = [] self.adj_quantifiers = [] self.verb_need_to = [] self.prep_change_place = [] self.replace_tuples = [] self.adjective_numbers_digit = [] self.days_list = [] self.months_list = [] self.time_adverbs = [] self.location_adverbs = [] self.unusable_words = [] self.time_proposals = [] self.action_verb_with_passive_behaviour = {} self.adjectives_ontology_classes = [] self.special_verbs = [] self.adv_sub = [] """list of tokens that can start a sentence""" self.sentence_starts = [] """ list of verbs that express a goal - ie, that would translate to a [S desires O] statement. """ self.goal_verbs = [] """ dictionnary of all verbs for which thematic roles are known. """ self.thematic_roles = ThematicRolesDict() def init(self, kb_host="localhost", kb_port=6969, embeddedkb=False, defaultontology=None, data_path=None): if not data_path: # try to guess the current prefix and then the data directory data_path = os.path.abspath(__file__).split("lib")[0].split("src")[0] + "share/dialogs/" logger.debug("Assuming Dialogs data dir is <%s>" % data_path) try: from kb import KB, KbError except ImportError: logger.error( "Python bindings to access the knowledge are not available." + "Please install 'pykb' and restart Dialogs." ) try: self.ontology_server = KB(kb_host, kb_port, embeddedkb, defaultontology) except KbError: logger.error( "Error while trying to connect to the knowledge base on %s:%s" % (kb_host, kb_port) + ". Continuing without knowledge base. Amongst others, resolution won't work." ) for line in open(os.path.join(data_path, "adjectives")): if line.startswith("#") or not line.strip(): continue try: adj, cat = line.split() except ValueError: # for adjectives without category, set a generic "Feature" category adj = line.split()[0] cat = "Feature" self.adjectives[adj] = cat verbs = [list(line.split()) for line in open(os.path.join(data_path, "verbs"))] verbs = self.split_list(verbs) self.irregular_verbs_past = verbs[0] self.irregular_verbs_present = verbs[1] self.preposition_verbs = verbs[2] self.modal = [k[0] for k in verbs[3]] self.adjective_verb = [k[0] for k in verbs[4]] self.auxiliary = [k[0] for k in verbs[5]] self.direct_transitive = [k[0] for k in verbs[6]] self.indirect_transitive = [k[0] for k in verbs[7]] self.state = [k[0] for k in verbs[8]] self.verb_need_to = [k[0] for k in verbs[9]] self.special_verbs = [k[0] for k in verbs[12]] # Action verbs such as 'see', 'hear' with no active behaviour self.action_verb_with_passive_behaviour = dict([(k[0], k[1]) for k in verbs[10]]) self.goal_verbs = [k[0] for k in verbs[11]] self.sentence_starts = [tuple(line.split()) for line in open(os.path.join(data_path, "sentence_starts"))] nouns = [list(line.split()) for line in open(os.path.join(data_path, "nouns"))] nouns = self.split_list(nouns) self.special_nouns = [k[0] for k in nouns[0]] self.pronouns = [k[0] for k in nouns[1]] for i in nouns[1]: if i[1] == "1": self.complement_pronouns = self.complement_pronouns + [i[0]] self.demonstrative_det = [k[0] for k in nouns[2]] self.determinants = [k[0] for k in nouns[3]] self.nouns_end_s = [k[0] for k in nouns[4]] self.relatives = [k[0] for k in nouns[5]] self.composed_nouns = [k[0] for k in nouns[6]] self.plural_nouns = nouns[7] self.noun_not_composed = [k[0] for k in nouns[8]] self.days_list = nouns[9] self.months_list = nouns[10] self.unusable_words = [k[0] for k in nouns[11]] # List of diection words, E.g: LEFT, RIGHT, TOP, etc ... self.direction_words = [k[0] for k in nouns[12]] self.compound_nouns = nouns[13] ### ### ADVERBIALS adverbials = [list(line.split()) for line in open(os.path.join(data_path, "adverbial"))] adverbials = self.split_list(adverbials) self.adverbs = [k[0] for k in adverbials[0]] self.time_adverbs = adverbials[0] self.time_adverbs = [k[0] for k in adverbials[0] if k[1] in ["day", "hour"]] self.time_adverbs += [k[0] for k in adverbials[1] if k[1] in ["day", "hour"]] self.location_adverbs = [k[0] for k in adverbials[0] if k[1] == "location"] self.location_adverbs += [k[0] for k in adverbials[1] if k[1] == "location"] self.adverbs_at_end = [k[0] for k in adverbials[1]] for k in adverbials[2]: if k[1] == "1": self.compelement_proposals = self.compelement_proposals + [k[0]] self.proposals = [k[0] for k in adverbials[2]] # Preposition with an existing object_property # E.g: next+to => isNextTo self.preposition_rdf_object_property = dict([(k[0], k[3:]) for k in adverbials[2]]) self.time_proposals = adverbials[2] self.subsentences = [k[0] for k in adverbials[3]] for k in adverbials[3]: if k[1] == "1": self.adv_sub = self.adv_sub + [k[0]] self.prep_change_place = [k[0] for k in adverbials[4]] grammatical_rules = [list(line.split()) for line in open(os.path.join(data_path, "grammatical_rules"))] grammatical_rules = self.split_list(grammatical_rules) self.numbers = grammatical_rules[0] self.det_quantifiers = grammatical_rules[1] self.capital_letters = [k[0] for k in grammatical_rules[2]] self.adjective_rules = [k[0] for k in grammatical_rules[3]] self.concatenate_proposals = grammatical_rules[4] self.change_tuples = grammatical_rules[5] self.adjective_numbers_digit = grammatical_rules[6] self.adjective_numbers = [k[0] for k in grammatical_rules[6]] self.be_pronoun = [k[0] for k in grammatical_rules[7]] self.adj_quantifiers = [k[0] for k in grammatical_rules[8]] for k in grammatical_rules[9]: self.replace_tuples = self.replace_tuples + [[k[0], k[1:]]] desc = "" for line in open(os.path.join(data_path, "thematic_roles")): if line.startswith("#") or not line.strip(): continue desc += line if line.startswith("}"): # end of block self.thematic_roles.add_verb(desc) desc = "" # Add action verbs to the ontology if self.ontology_server: stmts = [ verb.capitalize() + " rdfs:subClassOf cyc:PurposefulAction" for verb in self.thematic_roles.verbs.keys() if not self.thematic_roles.verbs[verb].is_synonym() ] self.ontology_server.revise(stmts, {"method": "add"}) """ List of ontology classes that are used in the adjectives list """ self.adjectives_ontology_classes = [self.adjectives[adj].lower() for adj in self.adjectives] adj_s = [] for k in self.adjectives_ontology_classes: if not k in adj_s: adj_s.append(k) self.adjectives_ontology_classes = adj_s def mark_active(self, ids): if not self.ontology_server: return if isinstance(ids, basestring): ids = [ids] try: self.ontology_server.revise( [id + " rdf:type ActiveConcept" for id in ids], {"method": "add", "models": [ResourcePool().default_model], "lifespan": 10}, ) except AttributeError: # No ontology server pass def __del__(self): self.close() def close(self): if self.ontology_server: self.ontology_server.close() self.ontology_server = None
import sys from kb import KB, Boolean, Integer, Constant # Define our symbols A = Boolean('A') B = Boolean('B') C = Boolean('C') D = Boolean('D') # Create a new knowledge base kb = KB() # Add clauses # kb.add_clause(A, B, C) # kb.add_clause(~A, B) # kb.add_clause(C) # kb.add_clause(C) # # Question 3 # kb.add_clause(A) # kb.add_clause(C) # kb.add_clause(D) # kb.add_clause(~A) # Question 4 kb.add_clause(A, B) kb.add_clause(B, ~C) kb.add_clause(~C, ~A) # This needs to be unsatisfiable for entailment kb.add_clause(A, ~B)
def init(self, kb_host="localhost", kb_port=6969, embeddedkb=False, defaultontology=None, data_path=None): if not data_path: # try to guess the current prefix and then the data directory data_path = os.path.abspath(__file__).split("lib")[0].split("src")[0] + "share/dialogs/" logger.debug("Assuming Dialogs data dir is <%s>" % data_path) try: from kb import KB, KbError except ImportError: logger.error( "Python bindings to access the knowledge are not available." + "Please install 'pykb' and restart Dialogs." ) try: self.ontology_server = KB(kb_host, kb_port, embeddedkb, defaultontology) except KbError: logger.error( "Error while trying to connect to the knowledge base on %s:%s" % (kb_host, kb_port) + ". Continuing without knowledge base. Amongst others, resolution won't work." ) for line in open(os.path.join(data_path, "adjectives")): if line.startswith("#") or not line.strip(): continue try: adj, cat = line.split() except ValueError: # for adjectives without category, set a generic "Feature" category adj = line.split()[0] cat = "Feature" self.adjectives[adj] = cat verbs = [list(line.split()) for line in open(os.path.join(data_path, "verbs"))] verbs = self.split_list(verbs) self.irregular_verbs_past = verbs[0] self.irregular_verbs_present = verbs[1] self.preposition_verbs = verbs[2] self.modal = [k[0] for k in verbs[3]] self.adjective_verb = [k[0] for k in verbs[4]] self.auxiliary = [k[0] for k in verbs[5]] self.direct_transitive = [k[0] for k in verbs[6]] self.indirect_transitive = [k[0] for k in verbs[7]] self.state = [k[0] for k in verbs[8]] self.verb_need_to = [k[0] for k in verbs[9]] self.special_verbs = [k[0] for k in verbs[12]] # Action verbs such as 'see', 'hear' with no active behaviour self.action_verb_with_passive_behaviour = dict([(k[0], k[1]) for k in verbs[10]]) self.goal_verbs = [k[0] for k in verbs[11]] self.sentence_starts = [tuple(line.split()) for line in open(os.path.join(data_path, "sentence_starts"))] nouns = [list(line.split()) for line in open(os.path.join(data_path, "nouns"))] nouns = self.split_list(nouns) self.special_nouns = [k[0] for k in nouns[0]] self.pronouns = [k[0] for k in nouns[1]] for i in nouns[1]: if i[1] == "1": self.complement_pronouns = self.complement_pronouns + [i[0]] self.demonstrative_det = [k[0] for k in nouns[2]] self.determinants = [k[0] for k in nouns[3]] self.nouns_end_s = [k[0] for k in nouns[4]] self.relatives = [k[0] for k in nouns[5]] self.composed_nouns = [k[0] for k in nouns[6]] self.plural_nouns = nouns[7] self.noun_not_composed = [k[0] for k in nouns[8]] self.days_list = nouns[9] self.months_list = nouns[10] self.unusable_words = [k[0] for k in nouns[11]] # List of diection words, E.g: LEFT, RIGHT, TOP, etc ... self.direction_words = [k[0] for k in nouns[12]] self.compound_nouns = nouns[13] ### ### ADVERBIALS adverbials = [list(line.split()) for line in open(os.path.join(data_path, "adverbial"))] adverbials = self.split_list(adverbials) self.adverbs = [k[0] for k in adverbials[0]] self.time_adverbs = adverbials[0] self.time_adverbs = [k[0] for k in adverbials[0] if k[1] in ["day", "hour"]] self.time_adverbs += [k[0] for k in adverbials[1] if k[1] in ["day", "hour"]] self.location_adverbs = [k[0] for k in adverbials[0] if k[1] == "location"] self.location_adverbs += [k[0] for k in adverbials[1] if k[1] == "location"] self.adverbs_at_end = [k[0] for k in adverbials[1]] for k in adverbials[2]: if k[1] == "1": self.compelement_proposals = self.compelement_proposals + [k[0]] self.proposals = [k[0] for k in adverbials[2]] # Preposition with an existing object_property # E.g: next+to => isNextTo self.preposition_rdf_object_property = dict([(k[0], k[3:]) for k in adverbials[2]]) self.time_proposals = adverbials[2] self.subsentences = [k[0] for k in adverbials[3]] for k in adverbials[3]: if k[1] == "1": self.adv_sub = self.adv_sub + [k[0]] self.prep_change_place = [k[0] for k in adverbials[4]] grammatical_rules = [list(line.split()) for line in open(os.path.join(data_path, "grammatical_rules"))] grammatical_rules = self.split_list(grammatical_rules) self.numbers = grammatical_rules[0] self.det_quantifiers = grammatical_rules[1] self.capital_letters = [k[0] for k in grammatical_rules[2]] self.adjective_rules = [k[0] for k in grammatical_rules[3]] self.concatenate_proposals = grammatical_rules[4] self.change_tuples = grammatical_rules[5] self.adjective_numbers_digit = grammatical_rules[6] self.adjective_numbers = [k[0] for k in grammatical_rules[6]] self.be_pronoun = [k[0] for k in grammatical_rules[7]] self.adj_quantifiers = [k[0] for k in grammatical_rules[8]] for k in grammatical_rules[9]: self.replace_tuples = self.replace_tuples + [[k[0], k[1:]]] desc = "" for line in open(os.path.join(data_path, "thematic_roles")): if line.startswith("#") or not line.strip(): continue desc += line if line.startswith("}"): # end of block self.thematic_roles.add_verb(desc) desc = "" # Add action verbs to the ontology if self.ontology_server: stmts = [ verb.capitalize() + " rdfs:subClassOf cyc:PurposefulAction" for verb in self.thematic_roles.verbs.keys() if not self.thematic_roles.verbs[verb].is_synonym() ] self.ontology_server.revise(stmts, {"method": "add"}) """ List of ontology classes that are used in the adjectives list """ self.adjectives_ontology_classes = [self.adjectives[adj].lower() for adj in self.adjectives] adj_s = [] for k in self.adjectives_ontology_classes: if not k in adj_s: adj_s.append(k) self.adjectives_ontology_classes = adj_s
from kb import KB # 在主程式中直接寫知識庫 code = "A<=B. B<=C&D. C<=E. D<=F. E. F. Z<=C&D&G." kb1 = KB() kb1.load(code) # 載入知識庫 kb1.forwardChaining() # 開始進行前向推論
import sys from kb import KB, Boolean, Integer, Constant # Define our symbols A = Boolean('A') B = Boolean('B') C = Boolean('C') # Create a new knowledge base kb = KB() # Add clauses kb.add_clause(A, B, C) kb.add_clause(~A, B) kb.add_clause(~B, C) kb.add_clause(B, ~C) # Print all models of the knowledge base for model in kb.models(): print(model) # Print out whether the KB is satisfiable (if there are no models, it is not satisfiable) print(kb.satisfiable())
class Tracker(object): """ This is the main program which gives a high-level view of all the running subsystems. It connects camera input with output in form of "actions" (such as keyboard shortcuts on the users behalf). This is done by locating a hand in an image and detecting features, like the number of fingers, and trying to match that data with a known gesture. """ def __init__(self): """ Configuration """ # Camera settings self.FRAME_WIDTH = 341 self.FRAME_HEIGHT = 256 self.flip_camera = True # Mirror image self.camera = cv2.VideoCapture(1) # ...you can also use a test video for input #video = "/Users/matthiasendler/Code/snippets/python/tracker/final/assets/test_video/10.mov" #self.camera = cv2.VideoCapture(video) #self.skip_input(400) # Skip to an interesting part of the video if not self.camera.isOpened(): print "couldn't load webcam" return #self.camera.set(cv2.cv.CV_CAP_PROP_FRAME_WIDTH, self.FRAME_WIDTH) #self.camera.set(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT, self.FRAME_HEIGHT) self.filters_dir = "filters/" # Filter settings in trackbar self.filters_file = "filters_default" # Load filter settings current_config = self.filters_dir + self.filters_file self.filters = Filters(current_config) # No actions will be triggered in test mode # (can be used to adjust settings at runtime) self.test_mode = False # Create a hand detector # In fact, this is a wrapper for many detectors # to increase detection confidence self.detector = Detector(self.filters.config) # Knowledge base for all detectors self.kb = KB() # Create gesture recognizer. # A gesture consists of a motion and a hand state. self.gesture = Gesture() # The action module executes keyboard and mouse commands self.action = Action() # Show output of detectors self.output = Output() self.run() def run(self): """ In each step: Read the input image and keys, process it and react on it (e.g. with an action). """ while True: img = self.get_input() hand = self.process(img) ref = self.action.get_reference_point() self.output.show(img, hand, ref) def process(self, img): """ Process input """ # Run detection hand = self.detector.detect(img) # Store result in knowledge base self.kb.update(hand) if not self.test_mode: # Try to interprete as gesture self.interprete(hand) return hand def interprete(self, hand): """ Try to interprete the input as a gesture """ self.gesture.add_hand(hand) operation = self.gesture.detect_gesture() self.action.execute(operation) def get_input(self): """ Get input from camera and keyboard """ self.get_key() _, img = self.camera.read() img = cv2.resize(img, (self.FRAME_WIDTH, self.FRAME_HEIGHT)) if self.flip_camera: img = cv2.flip(img, 1) return img def get_key(self): """ Read keyboard input """ key = cv2.waitKey(self.filters.config["wait_between_frames"]) if key == ord('+'): # Reduce program speed self.filters.config["wait_between_frames"] += 500 if key == ord('-'): # Increase program speed if self.filters.config["wait_between_frames"] >= 500: self.filters.config["wait_between_frames"] -= 500 #if key == ord('s'): # Save config # self.filters.save() if key == ord('r'): # Reset all detectors self.detector.reset() self.action.reset() if key == ord('d'): # Make a screenshot self.output.make_screenshot() if key == ord('p') or key == ord(' '): # Pause cv2.waitKey() if key == ord('t'): # Test mode self.test_mode = not self.test_mode if key == ord('1'): self.output.toggle_estimate() if key == ord('2'): self.output.toggle_detectors() if key == ord('3'): self.output.toggle_skin() if key == ord('f'): self.toggle_filters() if key == 63235: # Right arrow self.skip_input(20) if key == 27 or key == ord('q'): # Abort program on ESC, q or space exit() def toggle_filters(self): """ Load the next filter settings """ self.filters_file = self.next_filters_file() current_config = self.filters_dir + self.filters_file self.filters.set_config(current_config) def next_filters_file(self): """ Get the next filter settings """ filters = listdir(self.filters_dir) for i, f in enumerate(filters): if f == self.filters_file: return filters[(i + 1) % len(filters)] def skip_input(self, x=1): """ Skip to a different part of a video sequence. """ for i in range(0, x): self.camera.grab()
'-p', type=str, default='', help='file name for loading a saved knowledge base') parser.add_argument('--save_kb', '-s', type=str, default='', help='file name to save the knowledge base to') parser.add_argument('--responses', '-r', type=str, default='', help='file name for stored agent responses') parser.add_argument('--output', '-o', type=str, default='', help='file name for output') args = parser.parse_args() kb = KB(args.responses) print( 'Input looks like:\n\tA(n) <word1> is a(n) <word2>.\n\tA(n) <word1> is not a(n) <word2>.\n' + '\t<proper noun> is a <word1>.\n\t<proper noun> is not a <word1>.\n\t' + 'Is a(n) <word1> a(n) <word2>?\n\tIs <proper noun> a <word1>?\n\tIs a <word1> <proper noun>?' ) print('Type \'quit\' or \'q\' to exit.\n') Shell(kb).start(args.input, args.prior_kb, args.save_kb, args.output)
def kb_consistent_trumpmarriage(self, state, move): # type: (State, move) -> bool # each time we check for consistency we initialise a new knowledge-base kb = KB() # Add general information about the game suit = State.get_trump_suit(state) if suit == "C": card1 = 2 card2 = 3 variable_string = "m" + str(card1) + str(card2) strategy_variable = Boolean(variable_string) kb.add_clause(strategy_variable) elif suit == "D": card1 = 7 card2 = 8 variable_string = "m" + str(card1) + str(card2) strategy_variable = Boolean(variable_string) kb.add_clause(strategy_variable) elif suit == "H": card1 = 12 card2 = 13 variable_string = "m" + str(card1) + str(card2) strategy_variable = Boolean(variable_string) kb.add_clause(strategy_variable) elif suit == "S": card1 = 17 card2 = 18 variable_string = "m" + str(card1) + str(card2) strategy_variable = Boolean(variable_string) kb.add_clause(strategy_variable) load.general_information(kb) # Add the necessary knowledge about the strategy load.strategy_knowledge(kb) # This line stores the index of the card in the deck. # If this doesn't make sense, refer to _deck.py for the card index mapping index = move[0] variable_string = "pm" + str(index) strategy_variable = Boolean(variable_string) # Add the relevant clause to the loaded knowledge base kb.add_clause(~strategy_variable) # If the knowledge base is not satisfiable, the strategy variable is # entailed (proof by refutation) return kb.satisfiable()
import sys from kb import KB, Boolean, Integer, Constant # Define our symbols A = Boolean('A') B = Boolean('B') C = Boolean('C') D = Boolean('D') # Create a new knowledge base kb = KB() # Add clauses kb.add_clause(A, B) kb.add_clause(~B, A) kb.add_clause(~A, C) kb.add_clause(~A, D) kb.add_clause(~A, ~C, ~D) # Print all models of the knowledge base for model in kb.models(): print(model) # Print out whether the KB is satisfiable (if there are no models, it is not satisfiable) print(kb.satisfiable())
import sys from kb import KB kb1 = KB() with open(sys.argv[1], encoding='utf-8') as file: code = file.read().replace(r'\n', '') kb1.load(code) kb1.forwardChaining() while True: line = input('?-') if line == 'exit': break kb1.addFact(line.strip()) kb1.forwardChaining()
PC7 = Boolean('pc7') PC8 = Boolean('pc8') PC9 = Boolean('pc9') PC10 = Boolean('pc10') PC11 = Boolean('pc11') PC12 = Boolean('pc12') PC13 = Boolean('pc13') PC14 = Boolean('pc14') PC15 = Boolean('pc15') PC16 = Boolean('pc16') PC17 = Boolean('pc17') PC18 = Boolean('pc18') PC19 = Boolean('pc19') # Create a new knowledge base kb = KB() # strategy: plays cheap card first (J, Q, K) # This adds information which cards are Cheap kb.add_clause(C2) kb.add_clause(C3) kb.add_clause(C4) kb.add_clause(C7) kb.add_clause(C8) kb.add_clause(C9) kb.add_clause(C12) kb.add_clause(C13) kb.add_clause(C14) kb.add_clause(C17) kb.add_clause(C18) kb.add_clause(C19)