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')