def add_frames(self,E,edge_feature_row_breaks,
edge_orientations,abst_threshold):
new_E = E.copy()
esp.threshold_edgemap(new_E,.30,edge_feature_row_breaks,abst_threshold=abst_threshold)
esp.spread_edgemap(new_E,edge_feature_row_breaks,edge_orientations,spread_length=3)
if not self.processed_frames:
self.E = np.mean(new_E,axis=1)
self.processed_frames = True
else:
self.E = (self.E * self.num_frames + np.sum(new_E,axis=1))/(self.num_frames+new_E.shape[1])
self.num_frames += new_E.shape[1]
def get_detections(neg_E,mean_template,bg_len,mean_bgd,
edge_feature_row_breaks,edge_orientations,
spread_length=3,abst_threshold = .0001*np.ones(8)):
num_detections = neg_E.shape[1] - mean_template.shape[1]
detections = []
for d in xrange(num_detections):
E_segment = neg_E[:,d:d+mean_template.shape[1]].copy()
esp.threshold_edgemap(E_segment,.30,edge_feature_row_breaks,abst_threshold=abst_threshold)
esp.spread_edgemap(E_segment,edge_feature_row_breaks,edge_orientations,spread_length=spread_length)
if d > bg_len:
bg = np.maximum(np.minimum(np.mean(neg_E[:,d-bg_len:d],
axis=1),
.4),
.01)
else:
bg = mean_bgd.copy()
P,C = tt.score_template_background_section(mean_template,
bg,E_segment)
detections.append((P+C,d))
return detections
def get_training_template(train_data_iter):
patterns = []
train_data_iter.reset_exp()
for datum_id in xrange(train_data_iter.num_data):
if datum_id % 10 == 0:
print datum_id
if train_data_iter.next(wait_for_positive_example=True,
compute_patterns=True,
max_template_length=40):
# the context length is 11
for p in train_data_iter.patterns:
pattern = p.copy()
esp.threshold_edgemap(pattern,.30,edge_feature_row_breaks,report_level=False,abst_threshold=abst_threshold)
esp.spread_edgemap(pattern,edge_feature_row_breaks,edge_orientations,spread_length=5)
patterns.append(pattern)
else:
break
_,_ ,\
registered_examples,template \
= et.simple_estimate_template(patterns)
return registered_examples, template
E,edge_feature_row_breaks,\
edge_orientations= exp.get_edgemap_no_threshold(s)
phn_times = exp.get_phn_times(path_idx)
# select the object
patterns = exp.get_patterns(E,phns,phn_times,s)
bgds = exp.get_pattern_bgds(E,phns,phn_times,s,bg_len)
pattern_num += len(patterns)
all_patterns.extend(patterns)
all_bgds.extend(bgds)
# now compute the pattern values
tau_alpha_vals = np.empty((len(all_patterns),8))
for i in xrange(len(all_patterns)):
a,tau_alpha_vals[i] = esp.threshold_edgemap(all_patterns[i],.30,edge_feature_row_breaks,report_level=True)
# looking at histograms from data
fig = plt.figure()
ax = fig.add_subplot(111)
n, bins, patches = ax.hist(np.log(tau_alpha_vals[:,0]), 20, normed=1, facecolor='green', alpha=0.75)
bincenters = 0.5*(bins[1:]+bins[:-1])
ax.grid(True)
plt.show()
p = all_patterns[i].copy()
all_def_templates = np.empty((def_range.shape[0],
tpm.def_template.shape[0],
tpm.def_template.shape[1]))
for d in xrange(def_range.shape[0]):
tpm.get_def_template(def_range[d])
all_def_templates[d] = tpm.def_template.copy()
optimal_detection_scores = -np.inf * np.ones((len(tuning_patterns_context),def_range.shape[0]))
optimal_detection_idx = np.zeros((len(tuning_patterns_context),def_range.shape[0]))
for c_id in xrange(len(tuning_patterns_context)):
print c_id
cur_context = tuning_patterns_context[c_id]
num_detections = cur_context.shape[1] - tpm.length_range[1]
win_length = tpm.length_range[1]
for d in xrange(num_detections):
E_window = cur_context[:,d:d+win_length].copy()
esp.threshold_edgemap(E_window,.30,edge_feature_row_breaks,report_level=False,abst_threshold=abst_threshold)
esp.spread_edgemap(E_window,edge_feature_row_breaks,edge_orientations,spread_length=3)
# base detection
for deformation in def_range:
def_template = all_def_templates[10+deformation]
P,C = tt.score_template_background_section(def_template,tpm.bg,E_window)
score = P+C
if score > optimal_detection_scores[c_id,deformation]:
optimal_detection_scores[c_id,deformation] = score
optimal_detection_idx[c_id,deformation] = d
E_copy = E.copy()
#E
template=mean_template
bgd_length=26
mean_background=mean_bgd
#edge_feature_row_breaks
#edge_orientations
abst_threshold=abst_threshold
spread_length=3
pbgd = E[:,pattern_times[0][0]-bg_len:pattern_times[0][0]].copy()
pbgd2 = pbgd.copy()
esp.threshold_edgemap(pbgd2,.30,edge_feature_row_breaks,
abst_threshold=abst_threshold)
esp.spread_edgemap(pbgd2,edge_feature_row_breaks,edge_orientations,
spread_length=spread_length)
pbgd2 = np.mean(pbgd2,axis=1)
pbgd2 = np.maximum(np.minimum(pbgd2,.4),.1)
template_height,template_length = template.shape
num_detections = E.shape[1]-template_length+1
E_background, estimated_background_idx = self._get_E_background(E,num_detections,bgd_length, mean_background,
edge_feature_row_breaks,
edge_orientations,
abst_threshold=abst_threshold,
spread_length=spread_length)
# found that
for path_idx in xrange(exp.num_data):
if path_idx % 10 ==0:
print "on path", path_idx
phns = exp.get_phns(path_idx)
# check if this datum has what we need
if exp.has_pattern(phns):
s = exp.get_s(path_idx)
E,edge_feature_row_breaks,\
edge_orientations= exp.get_edgemap_no_threshold(s)
phn_times = exp.get_phn_times(path_idx)
# select the object
patterns = exp.get_patterns(E,phns,phn_times,s)
bgds = exp.get_pattern_bgds(E,phns,phn_times,s,bg_len)
# threshold pattern edges
for i in xrange(len(patterns)):
esp.threshold_edgemap(patterns[i],.30,edge_feature_row_breaks)
esp.spread_edgemap(patterns[i],edge_feature_row_breaks,edge_orientations)
if bgds[i].shape[1] > 0:
esp.threshold_edgemap(bgds[i],.30,edge_feature_row_breaks)
esp.spread_edgemap(bgds[i],edge_feature_row_breaks,edge_orientations)
# compute background mean
bgds[i] = np.mean(bgds[i],axis=1)
# impose floor and ceiling constraints on values
bgds[i] = np.maximum(np.minimum(bgds[i],.4),.05)
else:
bgds[i] = np.random.rand(patterns[i].shape[0]).reshape(patterns[i].shape[0],1)
bgds[i] = np.mean(bgds[i],axis=1)
bgds[i] = np.maximum(np.minimum(bgds[i],.4),.05)
empty_bgds.append(pattern_num)
pattern_num += len(patterns)
all_patterns.extend(patterns)
def get_roc_coarse(data_iter, classifier,
allowed_overlap = .2,
edge_feature_row_breaks= np.array([ 0.,
45.,
90.,
138.,
186.,
231.,
276.,
321.,
366.]),
edge_orientations=np.array([[ 1., 0.],
[-1., 0.],
[ 0., 1.],
[ 0., -1.],
[ 1., 1.],
[-1., -1.],
[ 1., -1.],
[-1., 1.]]),
abst_threshold=np.array([.025,.025,.015,.015,
.02,.02,.02,.02]),
spread_radius=3):
"""
Find the appropriate threshold for the coarse classifier, this
should be run on tuning data, and then we can get a level for the
tradeoff between false positives and false negatives the first
pair is the roc curve for the count test and the second is for the
coarse likelihood test
The way this works is that we find the scores for each window and
then we rank them and remove overlapping windows that are lower
rank if the overlap is below a certain percentage
We are assuming that the classifier has been implemented and initialized properly
"""
num_frames = 0
all_positive_counts = []
all_positive_likes = []
all_negative_counts = []
all_negative_likes = []
data_iter.reset_exp()
for datum_id in xrange(data_iter.num_data):
if datum_id % 10 == 0:
print "working on example", datum_id
if data_iter.next(compute_pattern_times=True,
max_template_length=classifier.window[1]):
pattern_times = data_iter.pattern_times
num_detections = data_iter.E.shape[1] - classifier.window[1]
num_frames += data_iter.E.shape[1]
coarse_count_scores = -np.inf * np.ones(num_detections)
coarse_like_scores = -np.inf * np.ones(num_detections)
for d in xrange(num_detections):
E_segment = data_iter.E[:,d:d+classifier.window[1]].copy()
esp.threshold_edgemap(E_segment,.30,edge_feature_row_breaks,report_level=False,abst_threshold=abst_threshold)
esp.spread_edgemap(E_segment,edge_feature_row_breaks,edge_orientations,spread_length=3)
coarse_count_scores[d] = classifier.coarse_score_count(E_segment)
coarse_like_scores[d] = classifier.coarse_score_like_no_bg(E_segment)
# now we get the indices sorted
count_indices = remove_overlapping_examples(np.argsort(coarse_count_scores),
classifier.coarse_length,
int(allowed_overlap*classifier.coarse_length))
like_indices = remove_overlapping_examples(np.argsort(coarse_like_scores),
classifier.coarse_length,
int(allowed_overlap*classifier.coarse_length))
positive_counts, negative_counts = get_pos_neg_scores(count_indices,pattern_times,
coarse_count_scores)
positive_likes, negative_likes = get_pos_neg_scores(like_indices,pattern_times,
coarse_like_scores)
all_positive_counts.extend(positive_counts)
all_negative_counts.extend(negative_counts)
all_positive_likes.extend(positive_likes)
all_negative_likes.extend(negative_likes)
count_roc = get_roc(np.sort(all_positive_counts)[::-1],
np.sort(all_negative_counts)[::-1],
num_frames)
like_roc = get_roc(np.sort(all_positive_likes)[::-1],
np.sort(all_negative_likes)[::-1],
num_frames)
return count_roc, like_roc
all_negative_counts = []
all_negative_likes = []
data_iter.reset_exp()
for datum_id in xrange(data_iter.num_data):
if datum_id % 10 == 0:
print "working on example", datum_id
if data_iter.next(compute_pattern_times=True,
wait_for_true
max_template_length=classifier.window[1]):
pattern_times = data_iter.pattern_times
num_detections = data_iter.E.shape[1] - classifier.window[1]
num_frames += data_iter.E.shape[1]
scores = -np.inf * np.ones(num_detections)
for d in xrange(num_detections):
E_segment = data_iter.E[:,d:d+classifier.window[1]].copy()
esp.threshold_edgemap(E_segment,.30,edge_feature_row_breaks,report_level=False,abst_threshold=abst_threshold)
esp.spread_edgemap(E_segment,edge_feature_row_breaks,edge_orientations,spread_length=3)
coarse_count_score = classifier.coarse_score_count(E_segment)
if coarse_count_score > coarse_thresh:
scores[d] = classifier.score_no_bg(E_segment)
# now we get the indices sorted
score_indices = remove_overlapping_examples(np.argsort(scores),
classifier.window[1],
int(allowed_overlap*classifier.coarse_length))
positive_scores, negative_scores = get_pos_neg_scores(score_indices,pattern_times,
scores)
positive_likes, negative_likes = get_pos_neg_scores(like_indices,pattern_times,
coarse_like_scores)
all_positive_counts.extend(positive_counts)
all_negative_counts.extend(negative_counts)
all_positive_likes.extend(positive_likes)
s = exp.get_s(path_idx)
E,edge_feature_row_breaks,\
edge_orientations= exp.get_edgemap_no_threshold(s)
phn_times = exp.get_phn_times(path_idx)
# select the object
patterns = exp.get_patterns(E,phns,phn_times,s)
patterns_context = exp.get_patterns(E,phns,phn_times,s,context=True,template_length=33)
bgds = exp.get_pattern_bgds(E,phns,phn_times,s,bg_len)
fronts_backs = exp.get_pattern_fronts_backs(E,phns,phn_times,s,bg_len)
E_avg.add_frames(E,edge_feature_row_breaks,
edge_orientations,abst_threshold)
# threshold pattern edges
for i in xrange(len(patterns)):
all_raw_patterns_context.append(patterns_context[i].copy())
all_raw_bgds.append(bgds[i].copy())
_, edge_thresholds = esp.threshold_edgemap(patterns[i],.30,edge_feature_row_breaks,report_level=True,abst_threshold=abst_threshold)
# we record both the thresholds
# and the length to see if there is a relationship
pattern_edge_thresholds.append(edge_thresholds)
pattern_lengths.append(patterns[i].shape[1])
esp.spread_edgemap(patterns[i],edge_feature_row_breaks,edge_orientations,spread_length=5)
if bgds[i].shape[1] > 0:
_,edge_thresholds = esp.threshold_edgemap(bgds[i],.30,edge_feature_row_breaks,report_level=True,abst_threshold=abst_threshold)
bgd_edge_thresholds.append(edge_thresholds)
esp.spread_edgemap(bgds[i],edge_feature_row_breaks,edge_orientations,spread_length=5)
# compute background mean
bgds[i] = np.mean(bgds[i],axis=1)
# impose floor and ceiling constraints on values
bgds[i] = np.maximum(np.minimum(bgds[i],.4),.05)
else:
bgds[i] = np.random.rand(patterns[i].shape[0]).reshape(patterns[i].shape[0],1)
output = open('tune_data_iter050712.pkl','wb')
cPickle.dump(tune_data_iter,output)
output.close()
mean_background = E_avg.E.copy()
mean_background = np.maximum(np.minimum(mean_background,.4),.05)
for pattern in xrange(len(all_patterns)):
# do the thresholding
esp.threshold_edgemap(all_patterns[pattern],.30,
train_data_iter.edge_feature_row_breaks,
report_level=False,
abst_threshold=train_data_iter.abst_threshold)
esp.spread_edgemap(all_patterns[pattern],
train_data_iter.edge_feature_row_breaks,
train_data_iter.edge_orientations,spread_length=5)
template_height, template_length, \
registered_templates,mean_template \
= et.simple_estimate_template(all_patterns,
template_length=33)
template_shape = np.array([template_height,template_length])
np.save('mean_template050612',mean_template)
np.save('template_shape050612',template_shape)
)
E,edge_feature_row_breaks,\
edge_orientations= texp.get_edgemap_no_threshold(train_data_iter.s)
abst_threshold = np.array([0.025,0.025,0.015,0.015,
0.02,0.02,0.02,0.02])
del(E)
del(s)
for p in all_patterns[1:]:
esp.threshold_edgemap(p,.30,edge_feature_row_breaks,report_level=False,abst_threshold=abst_threshold)
esp.spread_edgemap(p,edge_feature_row_breaks,edge_orientations,spread_length=5)
template_height, template_length, \
registered_templates,mean_template \
= et.simple_estimate_template(all_patterns)
template_shape = np.array([template_height,template_length])
np.save('mean_template_piy050912',mean_template)
np.save('template_shape_piy050912',template_shape)
np.save('registered_templates_piy050912',registered_templates)
mean_template = np.load('mean_template_piy050912.npy')
template_shape = np.load('template_shape_piy050912.npy')
