def test08(self):
self.kb = KnowledgeBase()
file = 'dataFiles/diy_kb.txt'
data = tokenize_file(file)
classify(self.kb, data)
print("No data found because of test08, (txt files empty)")
# test/print inference engine nodes here
"""
for f in self.kb.facts:
print(f)
for r in self.kb.rules:
print(r)
"""
self.sb = SuggestionBase(self.kb)
file = "dataFiles/diy_suggestions.txt"
#ensure that the txt file has each subgoal on a separate line
data = tokenize_suggestion_file(file)
classify_suggestions(self.sb, data)
# ask question here
q = Question('question1', 'Insert question here',
"Insert question (text version) here?")
ans = self.sb.evaluate(q)
def test05(self):
self.kb = KnowledgeBase()
file = 'dataFiles/inferences.txt'
data = tokenize_file(file)
classify(self.kb, data)
expected1 = Fact(['isa', 'luke', 'mortal'])
expected2 = Fact(['happy', 'luke'])
expected3 = Fact(['perfect', 'luke'])
check = False
if expected1 in self.kb.facts and expected2 in self.kb.facts and expected3 in self.kb.facts:
check = True
self.assertTrue(check)
check = False
expected1 = Fact(['above', 'block1', 'block3'])
expected2 = Rule([['above', 'block2', '?z']],
['above', 'block1', '?z'])
expected3 = Rule([['above', 'block3', '?z']],
['above', 'block2', '?z'])
if expected1 in self.kb.facts and expected2 in self.kb.rules and expected3 in self.kb.rules:
check = True
self.assertTrue(check)
""" Add additional facts and rules to knowledgebase"""
check = False
self.kb.add(Fact(['isa', 'dave', 'human']))
expected1 = Fact(['isa', 'dave', 'mortal'])
expected2 = Fact(['happy', 'dave'])
expected3 = Fact(['perfect', 'dave'])
#print(expected1)
if expected1 in self.kb.facts and expected2 in self.kb.facts and expected3 in self.kb.facts:
check = True
self.assertEqual(check, True)
def evaluate(self, test_data, log=True):
correct = 0
for test_case in test_data:
if util.classify(self.run(test_case[0])) == util.classify(
test_case[1]):
correct += 1
error = 1 - (correct / len(test_data))
if log:
print('Network has an error of {:.2%}'.format(error))
def test02(self):
self.kb = KnowledgeBase()
file = "dataFiles/initial_test.txt"
data = tokenize_file(file)
classify(self.kb, data)
self.assertTrue(isinstance(self.kb.facts[0], Fact))
self.assertTrue(isinstance(self.kb.facts[1], Fact))
self.assertTrue(isinstance(self.kb.facts[2], Fact))
self.assertTrue(isinstance(self.kb.rules[0], Rule))
self.assertTrue(isinstance(self.kb.rules[1], Rule))
self.assertEqual(self.kb.facts[0].predicate, "isa")
self.assertEqual(self.kb.facts[0].terms, ["luke", "human"])
self.assertEqual(self.kb.rules[0].predicate[0], "on")
self.assertEqual(self.kb.rules[0].vars[0], ["?x", "table"])
self.assertEqual(self.kb.rules[0].predicate[1], "on")
self.assertEqual(self.kb.rules[0].vars[1], ["?y", "?x"])
self.assertEqual(self.kb.rules[0].asserted,
["3-Tower", "?x", "?y", "?z"])
def test07(self):
self.kb = KnowledgeBase()
file = 'dataFiles/data_for_suggestions.txt'
data = tokenize_file(file)
classify(self.kb, data)
self.sb = SuggestionBase(self.kb)
file = "dataFiles/suggestions.txt"
#ensure that the txt file has each subgoal on a separate line
data = tokenize_suggestion_file(file)
classify_suggestions(self.sb, data)
q = Question(
'question2', 'DurationFeedHumans moon ?time',
"How long can the moon feed humans if it was made of green cheese?"
)
ans = self.sb.evaluate(q)
ans = float(ans)
withinRange = False
if ans > 1e12 and ans < 1e13:
withinRange = True
self.assertTrue(withinRange)
def test03(self):
self.kb = KnowledgeBase()
file = 'dataFiles/data.txt'
data = tokenize_file(file)
classify(self.kb, data)
b1 = self.kb.ask("(ON ?X TABLE)")
b2 = self.kb.ask(
"(populationOfRegion ?Y ((UnitOfCountFn HomoSapiens) 6560608))")
b3 = self.kb.ask(
"(relationAllInstance outerRadius AutomobileTire (?Z 0.5 0.9))")
self.assertEqual(b1[0].vars[0], "?X")
self.assertEqual(b1[0].constants[0], "D")
self.assertEqual(b2[0].vars[0], "?Y")
self.assertEqual(b2[0].constants[0], "Honduras")
self.assertEqual(b3[0].vars[0], "?Z")
self.assertEqual(b3[0].constants[0], "Meter")
b4 = self.kb.ask("(ON ?first ?second)")
self.assertEqual(b4[0].vars, ["?first", "?second"])
self.assertEqual(b4[0].constants, ["D", "TABLE"])
self.assertEqual(b4[1].vars, ["?first", "?second"])
self.assertEqual(b4[1].constants, ["E", "D"])
self.assertEqual(b4[2].vars, ["?first", "?second"])
self.assertEqual(b4[2].constants, ["F", "E"])
self.assertEqual(len(b4), 3)
b5 = self.kb.ask("(this_does_not_exist ?x ?y)")
self.assertFalse(b5)
def NN(dataSet, T, Z1=0):
""" Implemention of NN classify
Input:
dataSet (list) : Input dataset
T (float) : Distance threshold
Z1 (int)) : Index of first clustering center
Output:
"""
zs, zsi = genClusters(dataSet, T, Z1)
clusteri, clusterz = util.classify(dataSet, zs, zsi)
return clusteri, clusterz
def validate(args):
##################
norm_map = args.norm.partition('-')[0]
if 'no' == args.norm.partition('-')[2]:
m_uniform ='0'
else:
m_uniform ='fair'
if args.model=="default":
if args.xy_size==0:
args.model="checkpoint/{}/no_xy/netG_model_epoch_250.pth".format(args.dataset)
loc="no_xy/"
elif args.xy_size==2 and norm_map=='cycle':
args.model="checkpoint/{}/rot_xy/netG_model_epoch_250.pth".format(args.dataset)
loc = "rot_xy/"
else:
args.model="checkpoint/{}/netG_model_epoch_250.pth".format(args.dataset)
loc = "{}/".format(args.norm)
elif args.model=="best":
args.model="best_model/netG_model_epoch_200_3D+2D*5D.pth"
loc = 'best'
elif os.path.exists(args.model):
True #args.model = args.model
else:
args.model="checkpoint/{}/{}/netG_model_epoch_{}.pth".format(args.dataset, norm_map, args.it)
if not os.path.exists(args.model):
args.model="checkpoint/{}/pix2pix/netG_model_epoch_{}.pth".format(args.dataset, args.it)
loc=args.norm
img_size = (args.img_rows, args.img_cols)
val_dir = "dataset/{}/val/{}val_image_{}/".format(args.dataset, loc, args.rotated)
if args.xy_size>0 and norm_map=='':
raise RuntimeError('Please choose norm parameter for coordconv e.g. linear, cycle, sigmoid')
##################
print(args)
np.save("dataset/{}/parameters_val_{}_{}_{}".format(args.dataset, args.xy_size, m_uniform, args.it), args)
print('===> Loading datasets')
root_path = "dataset/"
evaluation_set = get_evaluation_set(root_path + args.dataset, mode = args.mode, xy=args.xy_size, img_size=(args.img_cols, args.img_rows), norm=args.norm, rotated=args.rotated, val=True)
evaluation_data_loader = DataLoader(dataset=evaluation_set, num_workers=args.threads, batch_size=args.batch_size, shuffle=False)
#####################
# Setup Model
netG_model = torch.load(args.model)
#netG_model.eval()
if torch.cuda.is_available():
netG_model = netG_model.cuda()
#diagnose_network(netG_model)
####################
gts, preds = [], []
for i, (images, labels) in tqdm(enumerate(evaluation_data_loader)):
if torch.cuda.is_available():
images = Variable(images.cuda(0), volatile=True)
#labels = Variable(labels.cuda(0), volatile=True)
else:
images = Variable(images, volatile=True)
#labels = Variable(labels, volatile=True)
with torch.no_grad():
outputs = netG_model(images)
outputs = outputs.cpu()
out_img = outputs.data[0]
#print(np.unique(out_img), 'out')
if m_uniform!='0':
pred = encode_img_ids(out_img)
else:
pred = classify(outputs.cpu().data[0], m=m_uniform) #it is realy slow
#pred = trans_classe(out_img)
gt = encode_ĺbl_ids(labels[0].numpy(), m=m_uniform) #labels.data.cpu().numpy() #
##gt = classify(labels[0], img=False)
if args.save:
save_val(decode_ids(pred, m=m_uniform), decode_ids(gt, m=m_uniform), val_dir, "img_{}.png".format(i), args.alpha)
#print('saving ...', np.unique(pred), np.unique(gt))
for gt_, pred_ in zip(gt, pred):
gts.append(gt_)
preds.append(pred_)
val_list= np.array([[gts, preds]])
np.save("{}/validations_tg_pred_{}".format(val_dir, args.rotated), val_list)
score, class_iou = scores(gts, preds, n_class=args.n_classes)
for k, v in score.items():
print(k, v)
for i in range(args.n_classes):
print(i, class_iou[i])
#################
np.save("{}/parameters_{}".format(val_dir, args.rotated), args)
np.save("{}/result.txt".format(val_dir), np.array([score, class_iou]))
test = pca.transform(test)
# # Obtain best parameters
# num_processor = -1
# util.obtain_parameters('RF', train, label, num_processor)
# util.obtain_parameters('ET', train, label, num_processor)
# util.obtain_parameters('SVM', train, label, num_processor)
# util.obtain_parameters('KNN', train, label, num_processor)
# util.obtain_parameters('LR', train, label, num_processor)
# Training classifier
'''
classifier abbreviations:
RF - Random Forest
ET - Extra Trees
SVM - Support Vector Machine
KNN - K Nearest Neighbors
LR - Logistic Regression
'''
classifier_name = 'SVM'
print('Training and prediction with %s classifier...' %classifier_name)
prediction = util.classify(classifier_name, train, label, test)
# Exporting solution
index = list(range(1,len(test) +1))
print('Writing data to CSV file...')
df_prediction = pd.DataFrame(data = prediction, index = index, columns = ['Solution'])
df_prediction_csv = df_prediction.to_csv('prediction_%s.csv' % classifier_name, index_label = ["Id"])
def test04(self):
self.kb = KnowledgeBase()
file = 'dataFiles/inDepthFactsRules.txt'
data = tokenize_file(file)
classify(self.kb, data)
# f1 was inferred from a fact and rule in the knowledge base
f1 = Fact(['isa', 'D', 'bottomBlock'])
shouldBeTrue = False
if f1 in self.kb.facts:
shouldBeTrue = True
index = self.kb.facts.index(f1)
self.assertTrue(shouldBeTrue)
# check to see if the inferred fact (f1) has antecedents
actual_fact = self.kb.facts[index]
j1 = actual_fact.antecedent[0].fact
j2 = actual_fact.antecedent[0].rule
shouldBeTrue = False
f = Fact(['ON', 'D', 'TABLE'])
r = Rule([['ON', '?x', 'TABLE']], ['isa', '?x', 'bottomBlock'])
if f == j1 and r == j2:
shouldBeTrue = True
self.assertTrue(shouldBeTrue)
# check to see if the antecedents support the given fact (f1)
support1 = j1.consequent[1]
support2 = j2.consequent[0]
shouldBeTrue = False
#both support1 and support2 should point to the original inferred fact (ON D TABLE)
if f1 == support1 and f1 == support2:
shouldBeTrue = True
self.assertTrue(shouldBeTrue)
# Fact(['ON', 'D', 'TABLE']) also supports another fact/rule!
# Since it satisfies the first part of the rule:
# (rule (ON ?x TABLE)
# (rule (ON ?y ?x)
# (rule (ON ?z ?y) (assert! '(3-Tower ,?x ,?y ,?z)))))
# it will assert a new rule with the appropriate new bindings set
# expected:
# (rule (ON ?y D)
# (rule (ON ?z ?y))
# (assert! '(3-Tower D ,?y ,?z)))
support3 = j1.consequent[0]
r = Rule([['ON', '?y', 'D'], ['ON', '?z', '?y']],
['3-Tower', 'D', '?y', '?z'])
# Inferred facts and rules can infer more facts and rules ...
f1 = Fact(['thereIsOneBlockBetween', 'C', 'TABLE'])
f2 = Fact(['thereIsOneBlockBetween', 'B', 'D'])
f3 = Fact(['thereIsOneBlockBetween', 'A', 'C'])
shouldBeTrue = False
if f1 in self.kb.facts and f2 in self.kb.facts and f3 in self.kb.facts:
shouldBeTrue = True
self.assertTrue(shouldBeTrue)
f4 = Fact(['thereAreThreeBlocksBetween', 'A', 'TABLE'])
shouldBeTrue = False
if f4 in self.kb.facts:
shouldBeTrue = True
self.assertTrue(shouldBeTrue)
def test06(self):
self.kb = KnowledgeBase()
file = 'dataFiles/data_for_suggestions.txt'
data = tokenize_file(file)
classify(self.kb, data)
self.sb = SuggestionBase(self.kb)
file = "dataFiles/suggestions.txt"
#ensure that the txt file has each subgoal on a separate line
data = tokenize_suggestion_file(file)
classify_suggestions(self.sb, data)
original_suggestions = copy.deepcopy(self.sb)
# This question is the first test. The suggestion fetches for its subgoals
# if the subgoals are more suggestions. If not, it will fetch from facts.
# Since there is a fact that satisfies this suggestion, the answer is returned
q = Question('question0', 'humanPopulation ?p',
"what is the human population?")
ans = self.sb.evaluate(q)
self.assertEqual(float(ans), 7000000000.0)
# This question tests the overall functionality of "evaluate()"
self.sb = original_suggestions # restore original version of sb
q = Question('question1', 'CaloriesIn moon ?count',
'How many calories in object?')
ans = self.sb.evaluate(q)
ans = float(ans)
# Checking the evaluation process...
# "CaloriesIn" will call the subgoals "volumeOfObject" and "caloriesInCubicMeter"
# "volumeOfObject" is another suggestion that retrieves a radius then evaluates
# the volume of sphere formula: 4.187 * (r^3)
# the result is then put into ?vol, hence ?vol is replaced with the actual value:
eval1 = [
'2.1943324029411e+19', 'TimesFn', '4.187', 'TimesFn', '?radius',
'?radius', '?radius'
]
self.assertEqual(self.sb.eval[0], eval1)
# Once "volumeOfObject moon ?vol" -> ?vol = 2.1943324029411e+19,
# the next subgoal is checked. "caloriesInCubicMeter" is next.
# this is another defined suggestion in the "suggestions.txt" file.
# This suggestion has its own subgoals:
# 1. (madeOf ?obj greencheese) - this will return (?obj = moon)
# 2. (caloriesPerKilogram greencheese ?cpk) - this will search for a suggestion
# named "caloriesPerKilogram". Since none is found, it will then search
# facts (from data_for_suggestions.txt)
# in the knowledgebase to "ask()" if a fact exists that matches the description.
# This succeeds and returns (?cpk = 4000)
# Then it evaluates the next subgoal, "densityOfGreenCheese" which will
# go through the same logic as the previous subgoal. It will return (?dc = 947)
# The suggestion multiplies ?cpk and ?dc -> 4000 * 947 = 3788000.
eval2 = ['3788000.0', 'TimesFn', '?cpk', '?dc']
self.assertEqual(self.sb.eval[1], eval2)
# Now that all of the "CaloriesIn" subgoals have been evaluated,
# with ?vol = 2.19...e+19 and ?cal = 3788000, we can move on to its
# result-step. According to the the suggestions txt file, ?vol and ?cal
# get multiplied to return the final ?count. 2.19e+19 * 3788000 =
# 8.31e+25
eval3 = [
'8.312131142340886e+25', 'TimesFn', '2.1943324029411e+19',
'3788000.0'
]
self.assertEqual(self.sb.eval[2], eval3)
# double checking to make sure the answer is roughly equivalent to
# the answer given from FIRE reasoning engine.
withinRange = False
if ans > 1e25 and ans < 1e26:
withinRange = True
self.assertTrue(withinRange)
# D is now the transpose, so training points as columns
D = X.T
A = R.dot(D)
print('done loading finally')
# get alphas for each of the 32 images of individual 33
# via basis pursuit
λ = .001
class_ests = []
alphas = []
for row in Z:
alpha = _get_alpha(row, R, A, λ)
alphas.append(alpha)
class_est = classify(D, alpha, row, lab)
class_ests.append(class_est)
correct = sum((x == 33 for x in class_ests))
from concentration import concentration
z2alphas = [_get_alpha(row, R, A, .001) for row in Z2]
conc = [concentration(alpha, lab) for alpha in z2alphas]
outliers_recognized = [c > .5 for c in conc]
print("the following outliers (individual 38) were (erronously) recognized")
print("(note: these are in order in the directory)")
print([i for i, c in enumerate(outliers_recognized) if c])
rgb=rgb,
rotated=opt.rotated)
img = transform(img1)
#print(np.unique(img))
input = Variable(img, volatile=True).view(1, -1, opt.img_size[1],
opt.img_size[0])
if opt.cuda:
netG = netG.cuda()
input = input.cuda()
out = netG(input)
out = out.cpu()
out_img = out.data[0]
if not os.path.exists(os.path.join("result", opt.dataset)):
os.mkdir(os.path.join("result", opt.dataset))
save_img(out_img, "result/{}/t_{}".format(opt.dataset, image_name),
opt.img_size)
save_img_np(rm_2channel(img1, sz=opt.img_size),
"result/{}/o_{}".format(opt.dataset, image_name), opt.img_size)
#This classification(classify,encode_img_ids) will be updated to run on gpu
if opt.m == '0':
save_img_np(decode_ids(classify(out_img, m=opt.m), m=opt.m),
"result/{}/{}".format(opt.dataset,
image_name), opt.img_size) #quadtree
else:
save_img_np(decode_ids(encode_img_ids(out_img)),
"result/{}/{}".format(opt.dataset,
image_name), opt.img_size)
def MinMax(dataSet, thita=1 / 2, Z1=0):
zs, zsi = genClusters(dataSet, thita, Z1)
clusteri, clusterz = util.classify(dataSet, zs, zsi)
return clusteri, clusterz
