def auto(camera, rawCapture, cas_params, stop_event):
print("In Auto Detction System for PiCamera...")
g.track_flag
check_candidates(stop_event)
for frame in camera.capture_continuous(rawCapture,
format="bgr",
use_video_port=True):
flag = False
raw_img = frame.array
# cv2.imshow("Raw", img)
# img = preprocess(img)
# cv2.imshow("Preprocessed", img)
rects, detected_img = detect(raw_img, cas_params)
g.img = box(rects, detected_img)
# cv2.imshow("Cascaded", img)
measure(raw_img, rects)
# if there's no rects found, look around
# if not rects:
# look_around()
# Check time elapsed, if over 10 sec, invoke spiral search
# if (time.time()-start) > 10:
# spiral_search()
if g.track_flag:
track(g.avg_pos)
g.track_flag = False
#time.sleep(.1)
rawCapture.truncate(0)
def pi_detection_system(camera, rawCapture, cas_params):
print("In Auto Detction System for PiCamera...")
for frame in camera.capture_continuous(rawCapture,
format="bgr",
use_video_port=True):
flag = False
raw_img = frame.array
# cv2.imshow("Raw", img)
# img = preprocess(img)
# cv2.imshow("Preprocessed", img)
rects, detected_img = detect(raw_img, cas_params)
g.img = box(rects, detected_img)
# cv2.imshow("Cascaded", img)
measure(raw_img, rects)
# if there's no rects found, look around
# if not rects:
# look_around()
# Check time elapsed, if over 10 sec, invoke spiral search
# if (time.time()-start) > 10:
# spiral_search()
rawCapture.truncate(0)
if (cv2.waitKey(1) & 0xFF == ord('q')):
break
def nominal(dataset, attr, cls_attr, measure, impurity=None, normalize=True, _cmp=None):
'''
Distinct value without order
- Multiway partitioning
e.g. Color
'''
if impurity is None:
impurity = measure(dataset, cls_attr)
# TODO: may try to pass index instead of a set to impurity measure
cluster = {}
for instance in dataset:
val = instance[attr]
if not cluster.has_key(val):
cluster[val] = []
cluster[val].append(instance)
gain = impurity
size = len(dataset)
if normalize:
split = .0
for c in cluster.values():
ratio = float(len(c)) / size
gain -= ratio * measure(c, cls_attr)
if normalize:
# compute split info for normalization
split += -ratio * math.log(ratio, 2)
if normalize:
# normalize as gain ratio
gain /= split
return cluster.keys(), gain, cluster
def ratio(dataset,
attr,
cls_attr,
measure,
impurity=None,
normalize=True,
_cmp=None):
'''
Numeric value where both the differences and the ratio are meaningful
The number zero has meaning
- Binary partitioning
e.g. length, mass
'''
if _cmp is None:
_cmp = lambda x, y: cmp(x[attr], y[attr])
if impurity is None:
impurity = measure(dataset, cls_attr)
dataset = dataset[:] # create clone
dataset = sorted(dataset, cmp=_cmp)
best_gain = .0
best_pivot = None
cluster = None
size = len(dataset)
for i in xrange(1, size):
if dataset[i - 1][attr] == dataset[i][attr]:
# same value, skip
continue
else:
pivot = (dataset[i - 1][attr] + dataset[i][attr]) / 2.0
# TODO: may try to pass index instead of a set to impurity measure
head_partition = dataset[:i]
head_ratio = float(len(head_partition)) / size
head_impurity = measure(head_partition, cls_attr)
tail_partition = dataset[i:]
tail_ratio = float(len(tail_partition)) / size
tail_impurity = measure(tail_partition, cls_attr)
gain = impurity - (head_ratio * head_impurity) - (tail_ratio *
tail_impurity)
if normalize:
# compute split info
split = .0
split += -head_ratio * math.log(head_ratio, 2)
split += -tail_ratio * math.log(tail_ratio, 2)
gain /= split
if gain > best_gain:
best_gain = gain
best_pivot = pivot
cluster = {0: tail_partition, 1: head_partition}
return best_pivot, best_gain, cluster
def interval(dataset,
attr,
cls_attr,
measure,
impurity=None,
normalize=True,
_cmp=None):
'''
Numeric value where the differences between value is meaningful
Measured along a scale in which each position is equidistant from another
- Binary partitioning
e.g. calendar date
'''
if _cmp is None:
_cmp = lambda x, y: cmp(x[attr], y[attr])
if impurity is None:
impurity = measure(dataset, cls_attr)
dataset = dataset[:] # create clone
dataset = sorted(dataset, cmp=_cmp)
best_gain = .0
best_pivot = None
cluster = None
size = len(dataset)
for i in xrange(1, size):
if dataset[i - 1][attr] == dataset[i][attr]:
# same value, skip
continue
else:
pivot = dataset[i][attr]
# TODO: may try to pass index instead of a set to impurity measure
head_partition = dataset[:i]
head_ratio = float(len(head_partition)) / size
head_impurity = measure(head_partition, cls_attr)
tail_partition = dataset[i:]
tail_ratio = float(len(tail_partition)) / size
tail_impurity = measure(tail_partition, cls_attr)
gain = impurity - (head_ratio * head_impurity) - (tail_ratio *
tail_impurity)
if normalize:
# compute split info
split = .0
split += -head_ratio * math.log(head_ratio, 2)
split += -tail_ratio * math.log(tail_ratio, 2)
gain /= split
if gain > best_gain:
best_gain = gain
best_pivot = pivot
cluster = {0: tail_partition, 1: head_partition}
return best_pivot, best_gain, cluster
def ordinal(dataset,
attr,
cls_attr,
measure,
impurity=None,
normalize=True,
_cmp=None):
'''
Distinct value with order
- Binary partitioning
e.g. Grade {A, B, C, ..., F}
'''
if _cmp is None:
_cmp = lambda x, y: cmp(x[attr], y[attr])
if impurity is None:
impurity = measure(dataset, cls_attr)
dataset = dataset[:] # create clone
dataset = sorted(dataset, cmp=_cmp)
best_gain = .0
best_pivot = None
cluster = None
size = len(dataset)
for i in xrange(1, size):
if dataset[i - 1][attr] == dataset[i][attr]:
# same value, skip
continue
else:
pivot = dataset[i][attr]
# TODO: may try to pass index instead of a set to impurity measure
head_partition = dataset[:i]
head_ratio = float(len(head_partition)) / size
head_impurity = measure(head_partition, cls_attr)
tail_partition = dataset[i:]
tail_ratio = float(len(tail_partition)) / size
tail_impurity = measure(tail_partition, cls_attr)
gain = impurity - (head_ratio * head_impurity) - (tail_ratio *
tail_impurity)
if normalize:
# compute split info
split = .0
split += -head_ratio * math.log(head_ratio, 2)
split += -tail_ratio * math.log(tail_ratio, 2)
gain /= split
if gain > best_gain:
best_gain = gain
best_pivot = pivot
cluster = {0: tail_partition, 1: head_partition}
return best_pivot, best_gain, cluster
def detection_system(cap, cas_params):
print("In auto..")
while (True):
ret, raw_img = cap.read()
imshape = raw_img.shape
vertices = np.array([[(0, imshape[0]), (0, int(imshape[0] / 2)),
(int(imshape[1]), int(imshape[0] / 2)),
(imshape[1], imshape[0])]],
dtype=np.int32)
processed_img = region_of_interest(raw_img, vertices)
rects, detected_img = detect(processed_img, cas_params)
g.img = box(rects, detected_img)
measure(raw_img, rects)
def interval(dataset, attr, cls_attr, measure, impurity=None, normalize=True, _cmp=None):
'''
Numeric value where the differences between value is meaningful
Measured along a scale in which each position is equidistant from another
- Binary partitioning
e.g. calendar date
'''
if _cmp is None:
_cmp = lambda x,y: cmp(x[attr], y[attr])
if impurity is None:
impurity = measure(dataset, cls_attr)
dataset = dataset[:] # create clone
dataset = sorted(dataset, cmp=_cmp)
best_gain = .0
best_pivot = None
cluster = None
size = len(dataset)
for i in xrange(1, size):
if dataset[i-1][attr] == dataset[i][attr]:
# same value, skip
continue
else:
pivot = dataset[i][attr]
# TODO: may try to pass index instead of a set to impurity measure
head_partition = dataset[:i]
head_ratio = float(len(head_partition)) / size
head_impurity = measure(head_partition, cls_attr)
tail_partition = dataset[i:]
tail_ratio = float(len(tail_partition)) / size
tail_impurity = measure(tail_partition, cls_attr)
gain = impurity - (head_ratio * head_impurity) - (tail_ratio * tail_impurity)
if normalize:
# compute split info
split = .0
split += -head_ratio * math.log(head_ratio, 2)
split += -tail_ratio * math.log(tail_ratio, 2)
gain /= split
if gain > best_gain:
best_gain = gain
best_pivot = pivot
cluster = {0: tail_partition, 1: head_partition}
return best_pivot, best_gain, cluster
def ratio(dataset, attr, cls_attr, measure, impurity=None, normalize=True, _cmp=None):
'''
Numeric value where both the differences and the ratio are meaningful
The number zero has meaning
- Binary partitioning
e.g. length, mass
'''
if _cmp is None:
_cmp = lambda x,y: cmp(x[attr], y[attr])
if impurity is None:
impurity = measure(dataset, cls_attr)
dataset = dataset[:] # create clone
dataset = sorted(dataset, cmp=_cmp)
best_gain = .0
best_pivot = None
cluster = None
size = len(dataset)
for i in xrange(1, size):
if dataset[i-1][attr] == dataset[i][attr]:
# same value, skip
continue
else:
pivot = (dataset[i-1][attr] + dataset[i][attr]) / 2.0
# TODO: may try to pass index instead of a set to impurity measure
head_partition = dataset[:i]
head_ratio = float(len(head_partition)) / size
head_impurity = measure(head_partition, cls_attr)
tail_partition = dataset[i:]
tail_ratio = float(len(tail_partition)) / size
tail_impurity = measure(tail_partition, cls_attr)
gain = impurity - (head_ratio * head_impurity) - (tail_ratio * tail_impurity)
if normalize:
# compute split info
split = .0
split += -head_ratio * math.log(head_ratio, 2)
split += -tail_ratio * math.log(tail_ratio, 2)
gain /= split
if gain > best_gain:
best_gain = gain
best_pivot = pivot
cluster = {0: tail_partition, 1: head_partition}
return best_pivot, best_gain, cluster
def ordinal(dataset, attr, cls_attr, measure, impurity=None, normalize=True, _cmp=None):
'''
Distinct value with order
- Binary partitioning
e.g. Grade {A, B, C, ..., F}
'''
if _cmp is None:
_cmp = lambda x,y: cmp(x[attr], y[attr])
if impurity is None:
impurity = measure(dataset, cls_attr)
dataset = dataset[:] # create clone
dataset = sorted(dataset, cmp=_cmp)
best_gain = .0
best_pivot = None
cluster = None
size = len(dataset)
for i in xrange(1, size):
if dataset[i-1][attr] == dataset[i][attr]:
# same value, skip
continue
else:
pivot = dataset[i][attr]
# TODO: may try to pass index instead of a set to impurity measure
head_partition = dataset[:i]
head_ratio = float(len(head_partition)) / size
head_impurity = measure(head_partition, cls_attr)
tail_partition = dataset[i:]
tail_ratio = float(len(tail_partition)) / size
tail_impurity = measure(tail_partition, cls_attr)
gain = impurity - (head_ratio * head_impurity) - (tail_ratio * tail_impurity)
if normalize:
# compute split info
split = .0
split += -head_ratio * math.log(head_ratio, 2)
split += -tail_ratio * math.log(tail_ratio, 2)
gain /= split
if gain > best_gain:
best_gain = gain
best_pivot = pivot
cluster = {0: tail_partition, 1: head_partition}
return best_pivot, best_gain, cluster
def _calc_score(self, measure, params=None):
results = defaultdict(lambda: [])
count, passes = 0, 0
for graph_idx, (A, y_true) in tqdm(enumerate(self.graphs),
total=len(self.graphs),
desc=measure.name):
mg = measure(A)
if params is None:
params = mg.scaler.scale(np.linspace(0, 1, self.n_params))
for param in params:
try:
count += 1
K = mg.get_K(param)
y_pred = SpectralClustering(2).fit_predict(K)
results[graph_idx].append(FC(y_true, y_pred))
passes += 1
except:
pass
mins = [min(x) for x in results.values()]
quality = np.mean(mins)
# logging results for report
logging.info('{}; Passes: {}/{}; Min error: {:0.4f}'.format(
measure.name, passes, count, 1 - quality))
return quality
def nominal(dataset,
attr,
cls_attr,
measure,
impurity=None,
normalize=True,
_cmp=None):
'''
Distinct value without order
- Multiway partitioning
e.g. Color
'''
if impurity is None:
impurity = measure(dataset, cls_attr)
# TODO: may try to pass index instead of a set to impurity measure
cluster = {}
for instance in dataset:
val = instance[attr]
if not cluster.has_key(val):
cluster[val] = []
cluster[val].append(instance)
gain = impurity
size = len(dataset)
if normalize:
split = .0
for c in cluster.values():
ratio = float(len(c)) / size
gain -= ratio * measure(c, cls_attr)
if normalize:
# compute split info for normalization
split += -ratio * math.log(ratio, 2)
if normalize:
# normalize as gain ratio
gain /= split
return cluster.keys(), gain, cluster
def __init__(self, numMeasures, beatsInMeasure, options):
# List to hold the measures, all initialized in the constructor
# Measures are indexed from 0
self.measures = []
self.numMeasures = numMeasures
self.beatsInMeasure = beatsInMeasure
for i in range(0, numMeasures):
self.measures.append(measure(beatsInMeasure))
# List to hold the notes are currently being sounded
self.currentlyPlaying = []
self.timeStep = 0
self.maxTimeStep = (numMeasures * beatsInMeasure * 4) - 1
self.loop = options.getLoop()
self.harmonicTable = sndobj.HarmTable(options.getHarmTableLength(), options.getNumHarmonics(), options.getWaveType())
self.oscillators = dict([])
self.amplitude = options.getAmplitude()
def main():
global train, test
global labels, features, test_labels
process_options()
# read problem and get all labels
(labels, features) = read_problem(train)
all_labels = count_labels(labels)
build_test(test)
predict = []
for i in range(len(test_labels)):
predict.append([])
for i in range(len(all_labels)):
# train binary problem for the label all_labels[i]
lab = all_labels[i]
build_problem(lab)
train_problem(lab)
test_problem(lab)
index = get_output(lab)
for idx in index:
predict[idx].append("%s" % lab)
out_predict = open("tmp_predict", "w")
for i in range(len(predict)):
out_predict.write("%s\n" % join(predict[i], ","))
out_predict.close()
result = measure(test_labels, predict, all_labels)
print "Exact match ratio: %s" % result[0]
print "Microaverage F-measure: %s" % result[1]
print "Macroaverage F-measure: %s" % result[2]
sys.stdout.flush()
def build_tree(dataset,
cls_attr,
attr_strategy,
measure=None,
threshold=.0,
quiet=True,
_depth=0):
'''
Build a tree of decisions based on given the dataset to carry classification
Each tree node is a function to partition the dataset
Each leave node is a class
- attr_strategy is a list of tuple: [(attr, strategy, sorting fn), ...]
'''
if not quiet:
pad = ''
for p in xrange(0, _depth):
pad += ' '
if threshold is None:
threshold = .0
if measure is None:
import measure as m
measure = m.entropy
# if no more element for decision
# return a leaf node for unclassified
if len(dataset) == 0:
leaf = TreeNode()
leaf.depth = _depth
leaf.cluster = []
leaf.cls = 'Un-classified'
if not quiet:
print '%sleaf - %s' % (pad, leaf.cls)
return leaf
# if no more attribute for decision
# return a leaf node by majority
if len(attr_strategy) == 0:
leaf = TreeNode()
leaf.depth = _depth
leaf.cluster = dataset
leaf.cls_attr = cls_attr
leaf.cls = leaf.majority()
if not quiet:
print '%sleaf - %s by majority [no attr left]' % (pad, leaf.cls)
return leaf
# compute impurity for further processing
impurity = measure(dataset, cls_attr)
# if impurity of dataset is 0 ==> all instances belong to same class
# return a leaf node as of that class
if impurity == 0:
leaf = TreeNode()
leaf.depth = _depth
leaf.cluster = dataset
leaf.cls_attr = cls_attr
leaf.cls = dataset[0][cls_attr]
if not quiet:
print '%sleaf - %s' % (pad, leaf.cls)
return leaf
# if impurity of dataset is below threshold
# return a leaf node by majority
elif impurity < threshold:
leaf = TreeNode()
leaf.depth = _depth
leaf.cluster = dataset
leaf.cls_attr = cls_attr
leaf.cls = leaf.majority()
if not quiet:
print '%sleaf - %s by majority [threshold reach]' % (pad, leaf.cls)
return leaf
# pick a partition strategy by the best purity gain
else:
# get all gains
attr_gain_map = {}
for attr, strategy, _cmp in attr_strategy:
attr_gain_map[attr] = strategy(dataset, attr, cls_attr, measure,
impurity, _cmp)
# retrieve best gain
best_gain = .0
best_attr = None
pivot = None
clusters = None
for attr, result in attr_gain_map.items():
p, g, c = result
if g > best_gain:
best_attr = attr
pivot = p
best_gain = g
clusters = c
if best_attr is None:
# early return for gaining not much purity
leaf = TreeNode()
leaf.depth = _depth
leaf.cluster = dataset
leaf.cls_attr = cls_attr
leaf.cls = leaf.majority()
if not quiet:
print '%sleaf - %s by majority [no further gain]' % (pad,
leaf.cls)
return leaf
if not quiet:
if isinstance(pivot, list):
print '%simpurity: %s, gain: %s, attr: %s, decision: by %s' \
% (pad, impurity, best_gain, best_attr, pivot)
else:
print '%simpurity: %s, gain: %s, attr: %s, decision: val < %s' \
% (pad, impurity, best_gain, best_attr, pivot)
# remove best attribute from further levels of decision
attr_strategy = [(a, s, c) for a, s, c in attr_strategy
if a != best_attr]
tree = TreeNode()
tree.cls_attr = cls_attr
tree.depth = _depth
tree.pivot = pivot
tree.attr = best_attr
tree.branches = {}
for val, c in clusters.items():
tree.branches[val] = build_tree(c, cls_attr, attr_strategy,
measure, threshold, quiet,
_depth + 1)
return tree
else:
pass
print("Engaging...")
file = open("data.csv", "w")
embblink = PWM(emb, freq=4)
time.sleep(10)
embblink.deinit()
cycle = 0 #a cycle is ~1 second
file.write("Time,ADC Value,Std Deviation,Calibrated OD\n")
while (b1.value() == 1) and (
cycle <= 64800
): #continue until the button is pushed or when 18 hours worth of data is reached
blue.value(1)
if cycle % 30 == 0:
data = measure(current, init)
OD = -1 * (math.log10(data[0] / init)) #calculate OD
ODcali = 5.5099 * OD + 0.0471 #change OD to calibrated value
file.write("{},{},{},{}\n".format(cycle, data[0], data[1], ODcali))
print("{},{},{},{}\n".format(cycle, data[0], data[1], ODcali))
elif cycle % 2 == 0: #blink green every other second
if green.value() == 0:
pass
#green.value(1)
else:
pass
#green.value(0)
else:
pass
time.sleep(1) #wait a second between every cycle
cycle += 1
vs = PiVideoStream((win_w, win_h), 64).start()
time.sleep(2.0)
start_time = time.time()
monitor_start_time = 0.
while (True):
img = vs.read()
# cv2.imshow("Raw", img)
# img = preprocess(img)
# cv2.imshow("Preprocessed", img)
rects, img = detect(img, scale_factor, min_neighs, obj_w, obj_h)
img = box(rects, img)
# cv2.imshow("Cascaded", img)
measure(img, rects, candidates)
# if there's no rects found, look around
# if not rects:
# look_around()
# Check time elapsed, if over 10 sec, invoke spiral search
# if (time.time()-start) > 10:
# spiral_search()
#if (time.time()-start_time >.1):
if True: # if time.time() - start_time > 5:
if candidates:
avg_pos = mean(candidates)
track_flag = True
candidates[:] = []
start_time = time.time()
def build_tree(dataset, cls_attr, attr_strategy, measure=None, threshold=0.0, quiet=True, _depth=0):
"""
Build a tree of decisions based on given the dataset to carry classification
Each tree node is a function to partition the dataset
Each leave node is a class
- attr_strategy is a list of tuple: [(attr, strategy, sorting fn), ...]
"""
if not quiet:
pad = ""
for p in xrange(0, _depth):
pad += " "
if threshold is None:
threshold = 0.0
if measure is None:
import measure as m
measure = m.entropy
# if no more element for decision
# return a leaf node for unclassified
if len(dataset) == 0:
leaf = TreeNode()
leaf.depth = _depth
leaf.cluster = []
leaf.cls = "Un-classified"
if not quiet:
print "%sleaf - %s" % (pad, leaf.cls)
return leaf
# if no more attribute for decision
# return a leaf node by majority
if len(attr_strategy) == 0:
leaf = TreeNode()
leaf.depth = _depth
leaf.cluster = dataset
leaf.cls_attr = cls_attr
leaf.cls = leaf.majority()
if not quiet:
print "%sleaf - %s by majority [no attr left]" % (pad, leaf.cls)
return leaf
# compute impurity for further processing
impurity = measure(dataset, cls_attr)
# if impurity of dataset is 0 ==> all instances belong to same class
# return a leaf node as of that class
if impurity == 0:
leaf = TreeNode()
leaf.depth = _depth
leaf.cluster = dataset
leaf.cls_attr = cls_attr
leaf.cls = dataset[0][cls_attr]
if not quiet:
print "%sleaf - %s" % (pad, leaf.cls)
return leaf
# if impurity of dataset is below threshold
# return a leaf node by majority
elif impurity < threshold:
leaf = TreeNode()
leaf.depth = _depth
leaf.cluster = dataset
leaf.cls_attr = cls_attr
leaf.cls = leaf.majority()
if not quiet:
print "%sleaf - %s by majority [threshold reach]" % (pad, leaf.cls)
return leaf
# pick a partition strategy by the best purity gain
else:
# get all gains
attr_gain_map = {}
for attr, strategy, _cmp in attr_strategy:
attr_gain_map[attr] = strategy(dataset, attr, cls_attr, measure, impurity, _cmp)
# retrieve best gain
best_gain = 0.0
best_attr = None
pivot = None
clusters = None
for attr, result in attr_gain_map.items():
p, g, c = result
if g > best_gain:
best_attr = attr
pivot = p
best_gain = g
clusters = c
if best_attr is None:
# early return for gaining not much purity
leaf = TreeNode()
leaf.depth = _depth
leaf.cluster = dataset
leaf.cls_attr = cls_attr
leaf.cls = leaf.majority()
if not quiet:
print "%sleaf - %s by majority [no further gain]" % (pad, leaf.cls)
return leaf
if not quiet:
if isinstance(pivot, list):
print "%simpurity: %s, gain: %s, attr: %s, decision: by %s" % (
pad,
impurity,
best_gain,
best_attr,
pivot,
)
else:
print "%simpurity: %s, gain: %s, attr: %s, decision: val < %s" % (
pad,
impurity,
best_gain,
best_attr,
pivot,
)
# remove best attribute from further levels of decision
attr_strategy = [(a, s, c) for a, s, c in attr_strategy if a != best_attr]
tree = TreeNode()
tree.cls_attr = cls_attr
tree.depth = _depth
tree.pivot = pivot
tree.attr = best_attr
tree.branches = {}
for val, c in clusters.items():
tree.branches[val] = build_tree(c, cls_attr, attr_strategy, measure, threshold, quiet, _depth + 1)
return tree
