def test_learning_taxonomies():
p = '$PRACMLN_HOME/examples/taxonomies/taxonomies.pracmln'
mln = MLN(mlnfile=('%s:senses_and_roles.mln' % p), grammar='PRACGrammar')
mln.write()
dbs = Database.load(mln, dbfiles='%s:training.db' % p)
for method in ('DPLL', 'DBPLL_CG', 'DCLL'):
for multicore in (True, False):
print '=== LEARNING TEST:', method, '==='
learn(method=method, mln=mln, db=dbs, verbose=True, multicore=multicore, epreds='is_a', discr_preds=EVIDENCE_PREDS).run()
def test_learning_smokers():
p = '$PRACMLN_HOME/examples/smokers/smokers.pracmln'
mln = MLN(mlnfile=('%s:smoking.mln' % p), grammar='StandardGrammar')
mln.write()
db = Database(mln, dbfile='%s:smoking-train.db' % p)
for method in ('BPLL', 'BPLL_CG', 'CLL'):
for multicore in (True, False):
print '=== LEARNING TEST:', method, '==='
learn(method=method, mln=mln, db=db, verbose=True, multicore=multicore).run()
def test_GSMLN():
# mln = MLN(grammar='GSMLNGrammar')
# mln << 'residue(id, profile)'
# mln << 'partners(id, id)'
# f = "residue(a, $pa) v residue(b, $pb) => partners(a,b)"
# # f = "((a(x) ^ b(x)) v (c(x) ^ !(d(x) ^ e(x) ^ g(x)))) => f(x)"
# # f = "(a(x) v (b(x) ^ c(x))) => f(x)"
# f = mln.logic.grammar.parse_formula(f)
# f.print_structure()
# print(list(f.literals()))
# g = "partners(id, id)"
# g = mln.logic.grammar.parse_predicate(g)
# print(g)
# print(mln.predicates)
mln = MLN(mlnfile='smokers.mln', grammar='GSMLNGrammar')
# mln.write()
# print(mln.predicates)
dbs = Database.load(mln, dbfiles='smokers.db')
# dbs[0].write()
# print(mln.formulas[0].neural)
# print(mln.formulas[0].cnf())
# print(mln.nnformulas[0].idx)
# print(mln.domains)
# print(dbs[0].domains)
# mln.formulas[1].print_structure()
# mrf = mln.ground(dbs[0])
# grounder = DefaultGroundingFactory(mrf, simplify=False, unsatfailure=True, verbose=False, cache=0)
# for f in grounder.itergroundings():
# print(f)
# print((mrf.gndatoms))
# mln = MLN(grammar='GSMLNGrammar')
# mln << 'Cancer(&person)'
# mln << 'Friends(&person,&person)'
# mln << 'Smokes(&person)'
# f = 'Smokes($x) => Cancer($x)'
# g = 'Friends($x,$y) => (Smokes($x) <=> Smokes($y))'
# print(mln.logic.grammar.parse_formula(f))
# mln.formula(f)
# mln.formula(g)
# print(mln.predicates)
# print(mln.formulas)
# mln.formulas[0].print_structure()
# print(mln.domains)
# print(mln.formulas[0].cnf())
# this uses the method from base.py
learned_mln = mln.learn(databases=dbs, method=GSMLN_L, verbose=True)
def test_learning_smokers():
p = os.path.join(locs.examples, 'smokers', 'smokers.pracmln')
mln = MLN(mlnfile=('%s:smoking.mln' % p), grammar='StandardGrammar')
mln.write()
db = Database(mln, dbfile='%s:smoking-train.db' % p)
for method in ('BPLL', 'BPLL_CG', 'CLL'):
for multicore in (True, False):
print('=== LEARNING TEST:', method, '===')
learn(method=method,
mln=mln,
db=db,
verbose=True,
multicore=multicore).run()
def test_learning_taxonomies():
p = os.path.join(locs.examples, 'taxonomies', 'taxonomies.pracmln')
mln = MLN(mlnfile=('%s:senses_and_roles.mln' % p), grammar='PRACGrammar')
mln.write()
dbs = Database.load(mln, dbfiles='%s:training.db' % p)
for method in ('DPLL', 'DBPLL_CG', 'DCLL'):
for multicore in (True, False):
print('=== LEARNING TEST:', method, '===')
learn(method=method,
mln=mln,
db=dbs,
verbose=True,
multicore=multicore,
epreds='is_a',
discr_preds=EVIDENCE_PREDS).run()
def main(arg='.'): #(arg='..'):
#if (len(sys))
pth = os.path.join(arg, 'wts.pybpll.smoking-train-smoking.mln')
#pth = os.path.join(arg, 'learnt.cll.scenes-new-object-detection.mln')
mln = MLN(mlnfile=pth, grammar='StandardGrammar')
#mln = MLN(mlnfile=pth, grammar='PRACGrammar')
pth = os.path.join(arg, 'smoking-test.db')
#pth = os.path.join(arg, 'test.db')
db = Database(mln, dbfile=pth)
#with open(os.path.join(arg, 'man_performance.txt'), 'a') as fl:
#start = time.time()
#t = 1000* timeit.timeit("test(False)", setup="from __main__ import test, set; set()", number=10)
#MULTICORE:#
#query(queries='Cancer,Smokes,Friends', method='EnumerationAsk', mln=mln, db=db, verbose=False, multicore=True).run()
#t1 = time.time()-start
#print('single core exact inference test: {}'.format(t))
#fl.write(str(t))
#fl.write('\t(SingleCore)\n')
start = time.time()
#t = 1000* timeit.timeit("test(True)", setup="from __main__ import test, set; set()", number=10)
query(method='EnumerationAsk',
mln=mln,
db=db,
verbose=False,
multicore=False).run()
t2 = time.time() - start
print('exact inference test: {}'.format(t2))
def learning(self):
mln = MLN(mlnfile=self.mln_path, grammar='StandardGrammar')
db = Database(mln, dbfile=self.db_path)
for method in ('BPLL', 'BPLL_CG', 'CLL'):
print('=== LEARNING TEST:', method, '===')
learn(method=method, mln=mln, db=db, verbose=True,
multicore=False).run()
def initialize(self):
logger.debug('initializing nl_parsing')
self.mln = MLN(mlnfile=os.path.join(self.module_path, 'mln',
'predicates.mln'),
grammar='PRACGrammar',
logic='FuzzyLogic')
def main(arg='.'):
#if (len(sys))
pth = os.path.join(arg, 'wts.pybpll.smoking-train-smoking.mln')
mln = MLN(mlnfile=pth, grammar='StandardGrammar')
pth = os.path.join(arg, 'smoking-test-smaller.db')
db = Database(mln, dbfile=pth)
#with open(os.path.join(arg, 'man_performance.txt'), 'a') as fl:
start = time.time()
#t = 1000* timeit.timeit("test(False)", setup="from __main__ import test, set; set()", number=10)
query(queries='Cancer,Smokes,Friends',
method='MC-SAT',
mln=mln,
db=db,
verbose=False,
multicore=True).run()
t1 = time.time() - start
#print('single core exact inference test: {}'.format(t))
#fl.write(str(t))
#fl.write('\t(SingleCore)\n')
start = time.time()
#t = 1000* timeit.timeit("test(True)", setup="from __main__ import test, set; set()", number=10)
query(queries='Cancer,Smokes,Friends',
method='MC-SAT',
mln=mln,
db=db,
verbose=False,
multicore=False).run()
t2 = time.time() - start
#print('multi core exact inference test: {}'.format(t))
print('Inference, MC-SAT, {}, {}'.format(t1, t2))
def construct_global_mln(self):
'''
Reads all predicte declaration MLNs of all modules and returns an MLN
with all predicates declared.
'''
mln = MLN(logic='FuzzyLogic', grammar='PRACGrammar')
for name, manifest in list(self._manifests_by_name.items()):
module_path = manifest.module_path
decl_mlns = manifest.pred_decls
for mlnfile in decl_mlns:
tmpmln = MLN(mlnfile=os.path.join(praclocations.pracmodules,
module_path, 'mln', mlnfile),
logic='FuzzyLogic',
grammar='PRACGrammar')
mln.update_predicates(tmpmln)
return mln
def test_mln():
mln = MLN()
mln << 'foo(x)' # predicate declaration
mln << 'bar(y)' # another pred declaration
mln << 'bar(?x) => bar(?y).' # hard logical constraint
mln << 'logx(.75)/log(.25) foo(?x)' # weighted formula
print('mln write:')
mln.write()
print('mln predicates:')
for pred in mln.predicates:
print(repr(pred))
print('mln formulas:')
for f in mln.formulas:
print(f)
f.print_structure()
return mln
def main(args, options):
#===========================================================================
# Load the NL parsing MLN
#===========================================================================
mln = MLN(mlnfile=os.path.join(prac.locations.pracmodules, 'nl_parsing',
'mln', 'predicates.mln'),
grammar='PRACGrammar',
logic='FuzzyLogic')
#===========================================================================
# Load the Java VM
#===========================================================================
if not java.isJvmRunning():
java.initJvm()
if not jpype.isThreadAttachedToJVM():
jpype.attachThreadToJVM()
#===========================================================================
# # suppress the stderr outputs from the parser
#===========================================================================
jpype.java.lang.System.setErr(jpype.java.io.PrintStream(os.devnull))
#===========================================================================
# Initialize the parser
#===========================================================================
stanford_parser = StanfordParser(grammar_path)
dbs = []
sentences = args
for s in sentences:
db = ''
deps = stanford_parser.get_dependencies(json.loads(s), True)
deps = map(str, deps)
words = set()
for d in deps:
# replace : by _ in stanford predicates
res = re.match('(!?)(.+)\((.+)\)$', d)
if res:
d = '{}{}({})'.format(res.group(1),
res.group(2).replace(':', '_'),
res.group(3))
_, pred, args = mln.logic.parse_literal(str(d))
words.update(args)
db += '{}({})\n'.format(pred, ', '.join(args))
postags = stanford_parser.get_pos()
pos = []
for pos in postags.values():
if not pos[0] in words:
continue
postagatom = 'has_pos({},{})'.format(pos[0], pos[1])
pos.append(postagatom)
db += '{}\n'.format(postagatom)
postags[pos[0]] = pos[1]
dbs.append(db)
result = '---\n'.join(dbs)
if options.outfile is not None:
with open(options.outfile, 'w+') as f:
f.write(result)
else:
print result
def train(self, praclearning):
print prac_heading('Training knowledgebase')
mlnName = praclearning.otherParams.get('mln', None)
mlnLogic = praclearning.otherParams.get('logic', None)
objName = praclearning.otherParams.get('concept', None)
onTheFly = praclearning.otherParams.get('onthefly', False)
mln = MLN(mlnfile=os.path.abspath(mlnName), logic=mlnLogic,
grammar='PRACGrammar')
pracTrainingDBS = praclearning.training_dbs
trainingDBS = []
if len(pracTrainingDBS) >= 1 and type(
pracTrainingDBS[0]) is str: # db from file
logger.info('Learning from db files...')
inputdbs = Database.load(mln, dbfile=pracTrainingDBS,
ignore_unknown_preds=True)
trainingDBS += inputdbs
elif len(pracTrainingDBS) > 1:
logger.info('Learning from db files (xfold)...')
trainingDBS = pracTrainingDBS
else: # db from inference result
logger.info('Learning from inference result...')
inputdbs = pracTrainingDBS
for db in inputdbs:
db << 'object(cluster, {})'.format(objName)
trainingDBS.append(db)
outputfile = '{}_trained.mln'.format(mlnName.split('.')[0])
# learning mln
trainedMLN = mln.learnWeights(trainingDBS, LearningMethods.DCLL,
evidencePreds=possibleProps, partSize=1,
gaussianPriorSigma=10, useMultiCPU=0,
optimizer='cg', learningRate=0.9)
print prac_heading('Learnt Formulas')
trainedMLN.printFormulas()
trainedMLN.write(file(outputfile, "w"))
return trainedMLN
def model_config(self,predicate,formula,database,mln_path,db_path):
"""
Returns the database and mln objects in MLN format
--Inputs--
predicate: predicate object with parsed predicates
formula: formula object with parsed predicates
database:.txt file containing the database(s)
mln_path: .mln file name to save the learned weights per formula
db_path: .db file to save the progress of the database learning
"""
base_path = os.getcwd()
mln = MLN(grammar='PRACGrammar',logic='FirstOrderLogic') #Parsing with PRACGrammar since we are using clusters
for i in predicate:
mln << i
print('input predicate successful:'+i)
for i in formula:
mln << i
print('input formula successful :'+i)
mln.write()
mln.tofile(base_path + '/'+ mln_path)
db = Database.load(mln,database)
#db.write()
#db.tofile(base_path + '/'+ db_path)
return (db,mln)
def model_config(predicate, formula, database, mln_path,
db_path): # mln_path,db_path 為string
base_path = os.getcwd()
mln = MLN(grammar='StandardGrammar', logic='FirstOrderLogic')
for i in predicate:
mln << i
print('input predicate successful:' + i)
for i in formula:
mln << i
print('input formula successful :' + i)
mln.write()
mln.tofile(base_path + '\\' + mln_path) #把谓语数据储存成 mln_path.mln 档案
db = Database(mln)
try:
for i in enumerate(database):
db << i[1][1]
print('input database successful : ' + i[1][0] + ' : ' +
i[1][1])
except:
for j in database[i[0]::]:
db << j[1]
db.write()
db.tofile(base_path + '\\' + db_path) #把证据数据储存成 db_path.db 档案
return (db, mln)
def main(arg='.'):
pth = os.path.join(arg, 'wts.pybpll.smoking-train-smoking.mln')
mln = MLN(mlnfile=pth, grammar='StandardGrammar')
pth = os.path.join(arg, 'smoking-test-tiny.db')
db = Database(mln, dbfile=pth)
start = time.time()
query(method='EnumerationAsk',
mln=mln,
db=db,
verbose=False,
multicore=False).run()
t2 = time.time() - start
print('exact inference test: {}'.format(t2))
def test_inference_taxonomies():
p = os.path.join(locs.examples, 'taxonomies', 'taxonomies.pracmln')
mln = MLN(mlnfile=('%s:wts.learned.taxonomy.mln' % p),
grammar='PRACGrammar',
logic='FuzzyLogic')
db = Database(mln, dbfile='%s:evidence.db' % p)
for method in ('EnumerationAsk', 'WCSPInference'):
print('=== INFERENCE TEST:', method, '===')
query(queries='has_sense, action_role',
method=method,
mln=mln,
db=db,
verbose=False,
cw=True).run().write()
def test_inference_smokers():
p = os.path.join(locs.examples, 'smokers', 'smokers.pracmln')
mln = MLN(mlnfile=('%s:wts.pybpll.smoking-train-smoking.mln' % p),
grammar='StandardGrammar')
db = Database(mln, dbfile='%s:smoking-test-smaller.db' % p)
for method in ('EnumerationAsk', 'MC-SAT', 'WCSPInference',
'GibbsSampler'):
for multicore in (False, True):
print('=== INFERENCE TEST:', method, '===')
query(queries='Cancer,Smokes,Friends',
method=method,
mln=mln,
db=db,
verbose=True,
multicore=multicore).run()
def test_inference_smokers():
p = os.path.join(locs.examples, 'smokers', 'smokers')
# mln = MLN(mlnfile=('%s:wts.pybpll.smoking-train-smoking.mln' % p),
# grammar='StandardGrammar')
# db = Database(mln, dbfile='%s:smoking-test-smaller.db' % p)
print(p)
mln = MLN(mlnfile=('%s.mln' % p), grammar='StandardGrammar')
db = Database(mln, dbfile='%s.db' % p)
for method in ('GibbsSampler', ):
print('=== INFERENCE TEST:', method, '===')
query(queries='Cancer,Smokes,Friends',
method=method,
mln=mln,
db=db,
verbose=True,
multicore=False).run()
def main(arg='.'): #(arg='..'):
#if (len(sys))
pth = os.path.join(arg, 'wts.pybpll.smoking-train-smoking.mln')
#pth = os.path.join(arg, 'learnt.cll.scenes-new-object-detection.mln')
mln = MLN(mlnfile=pth, grammar='StandardGrammar')
#mln = MLN(mlnfile=pth, grammar='PRACGrammar')
pth = os.path.join(arg, 'smoking-test-small.db')
#pth = os.path.join(arg, 'test.db')
db = Database(mln, dbfile=pth)
start = time.time()
query(method='EnumerationAsk',
mln=mln,
db=db,
verbose=False,
multicore=False).run()
t2 = time.time() - start
print('exact inference test: {}'.format(t2))
def test_learning_smokers(arg='.', disp=False):
pth = os.path.join(arg, 'smoking.mln')
mln = MLN(mlnfile=pth, grammar='StandardGrammar')
pth = os.path.join(arg, 'smoking-train.db')
db = Database(mln, dbfile=pth)
for method in ('BPLL', 'BPLL_CG', 'CLL'):
for multicore in (True, False):
print('=== LEARNING TEST:', method, '===')
if disp:
query(queries='Cancer,Smokes,Friends',
method=method,
mln=mln,
db=db,
verbose=disp,
multicore=multicore).run().write()
else:
learn(method=method,
mln=mln,
db=db,
verbose=disp,
multicore=multicore).run()
def inference(self, inference_query):
mln = MLN(mlnfile=self.mln_path, grammar='StandardGrammar')
db = Database(mln, dbfile=self.db_path)
for method in [
'EnumerationAsk'
# 'MC-SAT',
# 'WCSPInference',
# 'GibbsSampler'
]:
print('=== INFERENCE TEST:', method, '===')
result = query(queries=inference_query,
method=method,
mln=mln,
db=db,
verbose=True,
multicore=False).run()
print(result)
if result:
return result
else:
return []
def test_inference_smokers(arg='.', disp=False):
pth = os.path.join(arg, 'wts.pybpll.smoking-train-smoking.mln')
mln = MLN(mlnfile=pth, grammar='StandardGrammar')
pth = os.path.join(arg, 'smoking-test-smaller.db')
db = Database(mln, dbfile=pth)
for method in ('EnumerationAsk', 'MC-SAT', 'WCSPInference',
'GibbsSampler'):
for multicore in (False, True):
print('=== INFERENCE TEST:', method, '===')
if disp:
query(queries='Cancer,Smokes,Friends',
method=method,
mln=mln,
db=db,
verbose=disp,
multicore=multicore).run().write()
else:
query(queries='Cancer,Smokes,Friends',
method=method,
mln=mln,
db=db,
verbose=disp,
multicore=multicore).run()
def main():
path = os.path.join('Vessel Traffic Data sub-areas April 2020',
'cts_sub-areas_04_2020_pt',
'cts_bass_st_04_2020_pt.shp')
df = gpd.read_file(path)
mln = MLN()
populatePredicates(mln)
populateFormulas(mln)
mln.write()
dbs = []
for i in range(100):
collection = df.sample(n=3)
lons = collection['LON'].tolist()
lats = collection['LAT'].tolist()
points = list(zip(lons, lats))
evidence = ThreePointEvidence(*points)
db = Database(mln)
evidence.generateEvidence(db)
dbs.append(db)
mln.learn(dbs)
def test_reasoning():
mln = MLN.load(files='./mln/alarm.mln')
db = Database.load(mln, './mln/alarm.db')
result = MLNQuery(mln=mln, db=db).run()
result.write()
parser.add_argument("-q", "--query", help="query MLN", action="store_true")
args = parser.parse_args()
if args.learn:
print('you chose learn the weights for the mln')
predicate = s.read_predicate('predicate.txt')
formula = s.read_formula('formula.txt',predicate)
data,mln = s.model_config(predicate,formula,'data.txt','results.mln','results.db')
with open('base.mln', 'wb') as base_mln_file:
pickle.dump(mln, base_mln_file)
output = s.activate_model(data,mln)
output.tofile(os.getcwd() + '/' + 'learnt_mln.mln')
elif args.query:
print('you chose to query the mln')
mln = MLN.load(files='learnt_mln.mln')
infer_world = Database.load(mln,'inference_data.txt')
s.inference('query.txt',infer_world,mln)
else:
print ('please input learn (-l) or query (-q) to proceed')
#query(queries='Cancer(x)', method='MC-SAT', mln=mln, db=data, verbose=False, multicore=True).run().results
# =============================================================================
# predicate_list = [(x,x.lower()) for x in predicate_list]
# predicate = [x.replace(' ','').lower() for x in predicate if x !='']
from pracmln import MLN
from pracmln import Database
from pracmln import MLNQuery
mln = MLN(mlnfile='./data/smokers/mlns/smoking_trained.mln',grammar='PRACGrammar', logic='FirstOrderLogic')
mln.write()
db = Database.load(mln,'./data/smokers/dbs/smoking-test.db')[0]
db.write()
print("Running Query...")
result = MLNQuery(mln=mln, db=db).run()
print(result)
parser.add_argument("--output_mln",
type=str,
help="(.mln)",
nargs="?",
default="./models/initial.mln")
args = parser.parse_args()
# loads the data for MLN
roles = utils.load_roles(args.roles_file)
instances = []
for dataset in args.input_datasets:
instances += utils.load_flattened_data(dataset)
role_constraints = utils.get_role_constraints(roles, instances)
formulas = get_formulas(args.formula_file)
domains = get_domains(roles, instances)
# generates the markov logic network
mln = MLN(logic="FirstOrderLogic", grammar="PRACGrammar")
for domain, values in domains.items(): # domains
for value in values:
if len(value) > 1:
const = ''.join(value)
elif len(value) > 0:
const = value[0]
else:
const = "None"
mln.update_domain({domain: [const]})
for role in roles.keys(): # predicates
mln.predicate(Predicate(
role, [role + "_d!"])) # hard-functional constraints only
for formula in formulas: # formulas
formula_str = "0.0 "
for idx in range(len(formula)):
def learn(self, savegeometry=True, options=None, *_):
if options is None:
options = {}
mln_content = self.mln_container.editor.get("1.0", END).strip()
db_content = self.db_container.editor.get("1.0", END).strip()
# create conf from current gui settings
self.update_config()
# write gui settings
self.write_gconfig(savegeometry=savegeometry)
# hide gui
self.master.withdraw()
try:
print((headline('PRAC LEARNING TOOL')))
print()
if options.get('mlnarg') is not None:
mlnobj = MLN(mlnfile=os.path.abspath(options.get('mlnarg')),
logic=self.config.get('logic', 'FirstOrderLogic'),
grammar=self.config.get('grammar', 'PRACGrammar'))
else:
mlnobj = parse_mln(mln_content, searchpaths=[self.project_dir],
projectpath=os.path.join(self.project_dir, self.project.name),
logic=self.config.get('logic', 'FirstOrderLogic'),
grammar=self.config.get('grammar', 'PRACGrammar'))
if options.get('dbarg') is not None:
dbobj = Database.load(mlnobj, dbfiles=[options.get('dbarg')], ignore_unknown_preds=self.config.get('ignore_unknown_preds', True))
else:
if self.config.get('pattern'):
local, dblist = self.get_training_db_paths(self.config.get('pattern').strip())
dbobj = []
# build database list from project dbs
if local:
for dbname in dblist:
dbobj.extend(parse_db(mlnobj, self.project.dbs[dbname].strip(),
ignore_unknown_preds=self.config.get('ignore_unknown_preds', True),
projectpath=os.path.join(self.dir, self.project.name)))
out(dbobj)
# build database list from filesystem dbs
else:
for dbpath in dblist:
dbobj.extend(Database.load(mlnobj, dbpath, ignore_unknown_preds= self.config.get('ignore_unknown_preds', True)))
# build single db from currently selected db
else:
dbobj = parse_db(mlnobj, db_content, projectpath=os.path.join(self.dir, self.project.name), dirs=[self.dir])
learning = MLNLearn(config=self.config, mln=mlnobj, db=dbobj)
result = learning.run()
# write to file if run from commandline, otherwise save result
# to project results
if options.get('outputfile') is not None:
output = io.StringIO()
result.write(output)
with open(os.path.abspath(options.get('outputfile')), 'w') as f:
f.write(output.getvalue())
logger.info('saved result to {}'.format(os.path.abspath(options.get('outputfile'))))
elif self.save.get():
output = io.StringIO()
result.write(output)
self.project.add_mln(self.output_filename.get(), output.getvalue())
self.mln_container.update_file_choices()
self.project.save(dirpath=self.project_dir)
logger.info('saved result to file mln/{} in project {}'.format(self.output_filename.get(), self.project.name))
else:
logger.debug("No output file given - results have not been saved.")
except:
traceback.print_exc()
# restore gui
sys.stdout.flush()
self.master.deiconify()
help="(.db)",
nargs="?",
default="./data/train.db")
parser.add_argument("--output_mln",
type=str,
help="models",
nargs="?",
default="./models/class_learned.mln")
parser.add_argument("--shuffle",
type=bool,
help="1 or 0",
nargs="?",
default="True")
args = parser.parse_args()
# loads the initial MLN and DBs
mln = MLN.load(args.input_mln)
dbs = Database.load(mln, args.input_database)
if args.shuffle:
shuffle(dbs)
# runs the learning on the markov logic network to get weights
start = time()
learned_mln = MLNLearn(mln=mln,
db=dbs,
verbose=True,
method="BPLL_CG",
use_prior=True,
multicore=True).run()
learned_mln.tofile(args.output_mln)
duration = int((time() - start) / 60.0)
with open(
"./results/" + args.output_mln.split("/")[2].split(".")[0] +
def initialize(self):
self.mln = MLN(mlnfile=os.path.join(self.module_path, 'mln',
'predicates.mln'),
logic='FuzzyLogic',
grammar='PRACGrammar')
self.wordnetKBs = {}
valmap = dict([(val, computeClosestCluster(val, self.clusters[domain])[1][0]) for val in newdb.domains[domain]])
newdb.domains[domain] = valmap.values()
# replace the affected evidences
for ev in newdb.evidence.keys():
truth = newdb.evidence[ev]
_, pred, params = db.mln.logic.parse_literal(ev)
if domain in self.mln.predicate(pred).argdoms: # domain is affected by the mapping
newdb.retract(ev)
newargs = [v if domain != self.mln.predicate(pred).argdoms[i] else valmap[v] for i, v in enumerate(params)]
atom = '%s%s(%s)' % ('' if truth else '!', pred, ','.join(newargs))
newdb << atom
newdbs.append(newdb)
return newdbs
if __name__ == '__main__':
mln = MLN.load('/home/nyga/code/pracmln/examples/object-recognition/object-recognition.pracmln:object-detection.mln')
dbs = Database.load(mln, '/home/nyga/code/pracmln/examples/object-recognition/object-recognition.pracmln:scenes-new.db')
# do some plain clustering on texts
s = ['otto', 'otte', 'obama', 'markov logic network', 'markov logic', 'otta', 'markov random field']
s = set([val for db in Database.load(mln, '/home/nyga/code/pracmln/examples/object-recognition/object-recognition.pracmln:scenes-new.db') for val in db.domains['text']])
clusters = SAHN(s)
for c in clusters:
print(c)
# apply clustering to a set of databases
cluster = NoisyStringClustering(mln, ['text'])
cluster.materialize(dbs)
