def pl_resolve(ci, cj):
"""Return al clauses that can be obtained by resolving clauses ci and cj."""
clauses = set()
clauses = clauses.union(set(disjuncts(ci)))
clauses = clauses.union(set(disjuncts(cj)))
needBreak = False
for di in disjuncts(ci):
if needBreak:
break
for dj in disjuncts(cj):
if di == ~dj or ~di == dj:
clauses = removeall(di, clauses)
clauses = removeall(dj, clauses)
needBreak = True
break
result = False
if not clauses:
result = False
else:
#check if we resolve a TRUE clauses, which is useless
for di in clauses:
for dj in clauses:
if di == ~dj or ~di == dj:
return True
result = associate('|', clauses)
print("pl_resolve called with {}, {}, and to return:{}".format(ci, cj, result))
return result
def pl_resolve(ci, cj):
"""Return all clauses that can be obtained by resolving clauses ci and cj."""
clauses = []
for di in disjuncts(ci):
for dj in disjuncts(cj):
if di == ~dj or ~di == dj:
dnew = unique(removeall(di, disjuncts(ci)) +
removeall(dj, disjuncts(cj)))
clauses.append(associate('|', dnew))
return clauses
def pl_resolve(ci, cj):
clauses = []
for di in disjuncts(ci):
for dj in disjuncts(cj):
if di == ~dj or ~di == dj:
dnew = unique(
removeall(di, disjuncts(ci)) +
removeall(dj, disjuncts(cj)))
clauses.append(associate('|', dnew))
return clauses
def pl_resolve(ci, cj):
"""Return all clauses that can be obtained by resolving clauses ci and cj."""
clauses = []
for di in disjuncts(ci):
for dj in disjuncts(cj):
if di == ~dj or ~di == dj:
dnew = unique(removeall(di, disjuncts(ci)) +
removeall(dj, disjuncts(cj)))
clauses.append(associate('|', dnew))
return clauses
def resolve(ci, cj):
#
disjunction_ci = disjuncts(ci)
disjunction_cj = disjuncts(cj)
clauses = []
for literal_i in disjunction_ci:
for literal_j in disjunction_cj:
if literal_i == ~literal_j or ~literal_i == literal_j:
remaining = removeall(literal_i, disjunction_ci) + removeall(
literal_j, disjunction_cj)
remaining = unique(remaining)
new_clause = associate(Or, remaining)
clauses.append(new_clause)
return clauses
def fol_resolve(ci, cj):
"""Return all clauses that can be obtained by resolving clauses ci and cj.
>>> for res in pl_resolve(to_cnf(A|B|C), to_cnf(~B|~C|F)):
... ppset(disjuncts(res))
set([A, C, F, ~C])
set([A, B, F, ~B])
"""
#print "TODO - fol_resolve: %s, %s" % (ci, cj)
clauses = []
for di in disjuncts(ci):
for dj in disjuncts(cj):
#print "TODO - di, dj: %s, %s" % (di, dj)
dnew = None
if di == ~dj or ~di == dj:
dnew = unique(
removeall(di, disjuncts(ci)) +
removeall(dj, disjuncts(cj)))
else:
notDj = ~dj
if (notDj.op == '~' and notDj.args[0].op == '~'):
notDj = notDj.args[0].args[0]
unifySubst = unify(di, notDj, {})
if (unifySubst != None):
#print "TODO - unifySubst is %s" % unifySubst
s = subst(unifySubst, di)
t = disjuncts(subst(unifySubst, ci))
#print "TODO - subst(unifySubst, di) is %s" % s
#print "TODO - disjuncts(subst(unifySubst, ci)) is %s" % t
#print "TODO - removeall(subst(unifySubst,di),disjuncts(subst(unifySubst,ci))) is %s" % removeall(s, t)
#print "TODO - subst(unifySubst, dj) is %s" % subst(unifySubst, dj)
#print "TODO - disjuncts(subst(unifySubst, cj)) is %s" % disjuncts(subst(unifySubst, cj))
dnew = unique(
removeall(subst(unifySubst, di),
disjuncts(subst(unifySubst, ci))) +
removeall(subst(unifySubst, dj),
disjuncts(subst(unifySubst, cj))))
#print "TODO - unified! dnew is %s" % dnew
if (dnew != None):
clauses.append(NaryExpr('|', *dnew))
#if len(clauses) > 0:
#print "TODO - fol_resolve %s, %s is %s" % (ci, cj, clauses)
return clauses
def dpll(clauses, symbols, model):
"See if the clauses are true in a partial model."
unknown_clauses = [] # clauses with an unknown truth value
for c in clauses:
val = pl_true(c, model)
if val is False:
return False
if val is not True:
unknown_clauses.append(c)
if not unknown_clauses:
return model
P, value = find_pure_symbol(symbols, unknown_clauses)
if P:
return dpll(clauses, removeall(P, symbols), extend(model, P, value))
P, value = find_unit_clause(clauses, model)
if P:
return dpll(clauses, removeall(P, symbols), extend(model, P, value))
if not symbols:
raise TypeError("Argument should be of the type Expr.")
P, symbols = symbols[0], symbols[1:]
return (dpll(clauses, symbols, extend(model, P, True)) or
dpll(clauses, symbols, extend(model, P, False)))
def dpll(clauses, symbols, model):
"""See if the clauses are true in a partial model."""
unknown_clauses = [] # clauses with an unknown truth value
for c in clauses:
val = pl_true(c, model)
if val is False:
return False
if val is not True:
unknown_clauses.append(c)
if not unknown_clauses:
return model
P, value = find_pure_symbol(symbols, unknown_clauses)
if P:
return dpll(clauses, removeall(P, symbols), extend(model, P, value))
P, value = find_unit_clause(clauses, model)
if P:
return dpll(clauses, removeall(P, symbols), extend(model, P, value))
if not symbols:
raise TypeError("Argument should be of the type Expr.")
P, symbols = symbols[0], symbols[1:]
return (dpll(clauses, symbols, extend(model, P, True))
or dpll(clauses, symbols, extend(model, P, False)))
def decision_tree_learning(examples, attrs, parent_examples=()):
if len(examples) == 0:
return plurality_value(parent_examples)
elif all_same_class(examples):
return DecisionLeaf(examples[0][target])
elif len(attrs) == 0:
return plurality_value(examples)
else:
A = choose_attribute(attrs, examples)
tree = DecisionFork(A, dataset.attrnames[A])
for (v_k, exs) in split_by(A, examples):
subtree = decision_tree_learning(exs, removeall(A, attrs),
examples)
tree.add(v_k, subtree)
return tree
def decision_tree_learning(examples, attrs, parent_examples=()):
if len(examples) == 0:
return plurality_value(parent_examples)
elif all_same_class(examples):
return DecisionLeaf(examples[0][target])
elif len(attrs) == 0:
return plurality_value(examples)
else:
A = choose_attribute(attrs, examples)
tree = DecisionFork(A, dataset.attrnames[A])
for (v_k, exs) in split_by(A, examples):
subtree = decision_tree_learning(
exs, removeall(A, attrs), examples)
tree.add(v_k, subtree)
return tree
def resolve(ci, cj):
"""
Generate all clauses that can be obtained by applying
the resolution rule on ci and cj.
"""
clauses = []
dci = disjuncts(ci)
dcj = disjuncts(cj)
for di in dci:
for dj in dcj:
# If di, dj are complementary
if di == ~dj or ~di == dj:
# Create list of all disjuncts except di and dj
res = removeall(di, dci) + removeall(dj, dcj)
# Remove duplicates
res = unique(res)
# Join into new clause
dnew = associate(Or, res)
clauses.append(dnew)
return clauses
def setproblem(self, target, inputs=None, exclude=()):
"""Set (or change) the target and/or inputs.
This way, one DataSet can be used multiple ways. inputs, if specified,
is a list of attributes, or specify exclude as a list of attributes
to not use in inputs. Attributes can be -n .. n, or an attrname.
Also computes the list of possible values, if that wasn't done yet."""
self.target = self.attrnum(target)
exclude = list(map(self.attrnum, exclude))
if inputs:
self.inputs = removeall(self.target, inputs)
else:
self.inputs = [a for a in self.attrs
if a != self.target and a not in exclude]
if not self.values:
self.values = list(map(unique, list(zip(*self.examples))))
self.check_me()
def setproblem(self, target, inputs=None, exclude=()):
"""Set (or change) the target and/or inputs.
This way, one DataSet can be used multiple ways. inputs, if specified,
is a list of attributes, or specify exclude as a list of attributes
to not use in inputs. Attributes can be -n .. n, or an attrname.
Also computes the list of possible values, if that wasn't done yet."""
self.target = self.attrnum(target)
exclude = list(map(self.attrnum, exclude))
if inputs:
self.inputs = removeall(self.target, inputs)
else:
self.inputs = [a for a in self.attrs
if a != self.target and a not in exclude]
if not self.values:
self.update_values()
self.check_me()
def information_content(values):
"""Number of bits to represent the probability distribution in values."""
probabilities = normalize(removeall(0, values))
return sum(-p * math.log2(p) for p in probabilities)
def information_content(values):
"Number of bits to represent the probability distribution in values."
probabilities = normalize(removeall(0, values))
return sum(-p * log2(p) for p in probabilities)
def main():
actionDatabaseDir = config.actionDatabaseDir
categories = config.actionCateogory
## Step.1 Data loading and features extraction
# Get features from training data over all categories
print "Data loading and feature extraction ..."
allFeatures = np.array([])
trainActionSequence = []
testActionSequence = []
if os.path.exists('allFeatures.npy') \
and os.path.exists('trainActionSequence.npy') \
and os.path.exists('testActionSequence.npy'):
allFeatures = np.load('allFeatures.npy')
trainActionSequence = np.load('trainActionSequence.npy')
testActionSequence = np.load('testActionSequence.npy')
else:
for category in categories:
categoryPath = os.path.join(actionDatabaseDir, category)
allData = os.listdir(categoryPath)
# Train data and test data loading
for data in allData:
filePath = os.path.join(categoryPath, data)
actionSequence = ActionSequence(filePath)
actionSequence.extractStip() # extract STIP
subject = actionSequence.subject
if subject in config.trainDataSubjects:
trainActionSequence.append(actionSequence)
if allFeatures.size == 0:
allFeatures = actionSequence.stipFeatures
else:
allFeatures = np.vstack((allFeatures,
actionSequence.stipFeatures))
elif subject in config.testDataSubjects:
testActionSequence.append(actionSequence)
np.save('allFeatures', allFeatures)
np.save('trainActionSequence', trainActionSequence)
np.save('testActionSequence', testActionSequence)
## Step.2 Codebook generation
print "Codebook generation ..."
bovw = BagOfWords(featureEncodingMethod = 'sparse-coding',
poolingMethod = 'max-pooling',
normalizationMethod = 'L2-norm')
# bovw = BagOfWords(featureEncodingMethod = 'vector-quantization',
# poolingMethod = 'sum-pooling',
# normalizationMethod = 'L1-norm')
if os.path.exists('codebook.npy'):
codebook = np.load('codebook.npy')
bovw.codebook = codebook
else:
bovw.generateCodebook(allFeatures)
np.save('codebook', bovw.codebook)
## Step.3 Feature encoding for train data
train_y = []
train_X = []
for actionSequence in trainActionSequence:
# Feature encoding, pooling, normalization
actionSequence.generateFinalFeatures(bovw)
# Format train data
train_y.append(actionSequence.categoryId)
train_X.append(actionSequence.finalFeatures)
# Cross validation
if config.is_cv:
# cross validation
crossValidate(train_y, train_X)
## Step.4 Classification
# Learning using SVM
svmTool = SvmTool()
print "Model learning ..."
svmTool.learnModel(train_y, train_X)
# Feature encoding for test data and classify data using learned model
print "Predicating ..."
numCorrect = 0
trueLabels = []
testPredLabels = []
removeall(config.predctDir)
for actionSequence in testActionSequence:
# Feature encoding, pooling, normalization
actionSequence.generateFinalFeatures(bovw)
# Format train data
test_y = [actionSequence.categoryId]
test_X = [actionSequence.finalFeatures]
p_label, _ = svmTool.doPredication(test_y, test_X)
predCagtegoryId = int(p_label[0])
predCategoryName = categories[predCagtegoryId]
# Write predicated action to predicated category
predCategoryPath = os.path.join(config.predctDir, predCategoryName)
if not os.path.exists(predCategoryPath):
os.makedirs(predCategoryPath)
predFilePath = os.path.join(predCategoryPath, actionSequence.filename)
f = open(predFilePath, 'w')
f.close()
if predCagtegoryId == actionSequence.categoryId:
numCorrect += 1
trueLabels.append(actionSequence.categoryName)
testPredLabels.append(predCategoryName)
# Calculate results
accuracy = numCorrect / float(len(testActionSequence))
print "accuracy: ", accuracy
# Plot confusion matrix
saveFilename = 'confusion_matrix.png'
plotConfusionMatrix(trueLabels, testPredLabels,
saveFilename, normalization = False)
saveFilename = 'confusion_matrix_norm.png'
plotConfusionMatrix(trueLabels, testPredLabels,
saveFilename, normalization = True)
