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
# important to think about the consequences of the # comparison mean_template_match = np.empty((quantile_level.shape[0], len(all_patterns))) for i in xrange(len(all_patterns)): # get the background signal processing done if all_bgds[i].shape[1] > 0: # process the edges for each of the different thresholds for j in xrange(quantile_levels.shape[0]): a,tau_alpha_vals[i] = esp.threshold_edgemap(all_patterns[i],.30,edge_feature_row_breaks, abst_threshold=) esp.spread_edgemap(a,edge_feature_row_breaks,edge_orientations) for i in xrange(len(all_patterns)): a,tau_alpha_vals[i] = esp.threshold_edgemap(p,.30,edge_feature_row_breaks,report_level=True) # 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)
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 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 frame_id in xrange(bg_len,E_background.shape[1]): bg_seg = E[:,frame_id-bg_len:frame_id].copy()
cPickle.dump(tune_data_iter,output) output.close() aar_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=2) aar_patterns.append(pattern) else: break _,_ ,\ registered_examples,template \ = et.simple_estimate_template(aar_patterns) np.save('aar_template053112',template) np.save('registered_examples_aar053112',registered_examples) mean_background = np.load(root_path+'Experiments/050812/mean_background_liy051012.npy') data_iter = tune_data_iter import template_speech_rec.classification as cl
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
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) 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)
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) ######################################### #
num_detections = data_iter.E.shape[1] - classifier.window[1] num_frames += data_iter.E.shape[1] scores_adapt_bg = -np.inf * np.ones(num_detections) scores_mel = -np.inf * np.ones(num_detections) bg = mean_background.copy() E_mel,e_breaks_mel,\ e_orientations_mel= esp.get_edgemap_no_threshold(train_data_iter.s, train_data_iter.sample_rate, train_data_iter.num_window_samples, train_data_iter.num_window_step_samples, train_data_iter.fft_length,8000,7, use_mel = True) 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) E_segment_mel = E_mel[:,d:d+classifier.window[1]].copy() esp.threshold_edgemap(E_segment_mel,.30,e_breaks_mel,report_level=False,abst_threshold=abst_threshold) esp.spread_edgemap(E_segment_mel,e_breaks_mel,e_orientations_mel,spread_length=3) bg = np.minimum(.4, np.maximum(np.mean(E_segment,axis=1), .1)) scores_adapt_bg[d] = classifier.score(E_segment,bg) scores_mel[d] = classifier.score_no_bg(E_segment_mel) # now we get the indices sorted indices_adapt_bg = cl.remove_overlapping_examples(np.argsort(scores_adapt_bg)[::-1], classifier.window[1], int(allowed_overlap*classifier.window[1])) indices_mel = cl.remove_overlapping_examples(np.argsort(scores_mel)[::-1], classifier.window[1], int(allowed_overlap*classifier.window[1]))
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') # time to get a baseline for how well the pattern applies to examples