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
b_components = []
for component_id in xrange(p_num_components):
p_component_length = (int(p_lengths[p_train_masks[train_mask_id]][p_cluster_set[train_mask_id][component_id]].mean()+.5))
p_components.append(
np.clip(p_examples5[p_train_masks[train_mask_id]][p_cluster_set[train_mask_id][component_id]].mean(0)[:,:p_component_length],.05,.95))
for component_id in xrange(b_num_components):
b_component_length = (int(b_lengths[b_train_masks[train_mask_id]][b_cluster_set[train_mask_id][component_id]].mean()+.5))
b_components.append(
np.clip(b_examples5[b_train_masks[train_mask_id]][b_cluster_set[train_mask_id][component_id]].mean(0)[:,
:b_component_length],.05,.95))
p_components = tuple(p_components)
b_components = tuple(b_components)
p_dev_exs = p_examples3[True-p_train_masks[train_mask_id]]
p_dev_bgs = p_bgs[True-p_train_masks[train_mask_id]]
p_classify_p = np.array([
max((sum(tt.score_template_background_section(p_comp,p_dev_bg,p_dev_ex[:,:p_comp.shape[1]])) for p_comp in p_components)) for p_dev_bg, p_dev_ex in zip(p_dev_bgs, p_dev_exs)])
b_classify_p = np.array([
max((sum(tt.score_template_background_section(b_comp,p_dev_bg,p_dev_ex[:,:b_comp.shape[1]])) for b_comp in b_components)) for p_dev_bg, p_dev_ex in zip(p_dev_bgs, p_dev_exs)])
b_dev_exs = b_examples3[b_train_masks[train_mask_id]][True-b_cluster_set[train_mask_id][component_id]]
b_dev_bgs = b_bgs[b_train_masks[train_mask_id]][True-b_cluster_set[train_mask_id][component_id]]
p_classify_b = np.array([
max((sum(tt.score_template_background_section(p_comp,b_dev_bg,b_dev_ex[:,:p_comp.shape[1]])) for p_comp in p_components)) for b_dev_bg, b_dev_ex in zip(b_dev_bgs, b_dev_exs)])
b_classify_b = np.array([
max((sum(tt.score_template_background_section(b_comp,b_dev_bg,b_dev_ex[:,:b_comp.shape[1]])) for b_comp in b_components)) for b_dev_bg, b_dev_ex in zip(b_dev_bgs, b_dev_exs)])
p_errors = np.sum(p_classify_p < b_classify_p)/float(p_classify_p.shape[0])
b_errors = np.sum(p_classify_b > b_classify_b)/float(b_classify_b.shape[0])
p_error_rates[p_cluster_id,b_cluster_id,
train_mask_id] = p_errors
b_error_rates[p_cluster_id,b_cluster_id,
train_mask_id] = b_errors
print "p_errors:",p_errors
length = 20
E_test = (np.random.rand(length*num_features).reshape(num_features,length) > .6).astype(np.uint8)
bg_test = (np.random.rand(num_features)*.3 + .1).astype(np.float32)
template_test = (np.random.rand(num_features*length).reshape(num_features,length)*.9 + .05).astype(np.float32)
"""
timeit_run_statement = """
length = min(E_test.shape[1],template_test.shape[1])
sum(tt.score_template_background_section(template_test[:,:length],bg_test,E_test[:,:length]))"""
num_features = 384
length = 20
E_test = (np.random.rand(length*num_features).reshape(num_features,length) > .6).astype(np.uint8)
bg_test = (np.random.rand(num_features)*.3 + .1).astype(np.float32)
template_test = (np.random.rand(num_features*length).reshape(num_features,length)*.9 + .05).astype(np.float32)
out1 = sum(tt.score_template_background_section(template_test,bg_test,E_test))
log_template = np.log(template_test.T)
log_invtemplate = np.log(1-template_test.T)
E_test_transpose = E_test.T
out2 = tt.score_template_background_section_quantizer(log_template,
log_invtemplate,
bg_test,
E_test_transpose)
import timeit
t = timeit.Timer(timeit_run_statement,timeit_import_statement)
t.repeat(5,10000)
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
plosive_lengths = np.load(data_path+plosive+'class_examples_lengths.npy')
plosive_bgs = np.load(data_path+plosive+'class_examples_bgs.npy')
num_validate = plosive_train_mask[0].shape[0]-np.sum(plosive_train_mask[0])
num_folds = plosive_train_mask.shape[0]
classifier_output = np.empty((num_folds,num_validate,
len(classifiers),num_classifier_models),
dtype=np.float32)
for classifier_id, classifier in enumerate(classifiers):
print classifier
# 1 template classification
template0 = np.load(exp_path+classifier+'0template1_1_0.npy')
t_len = template0.shape[1]
valid_mask = np.logical_not(plosive_train_mask[0])
classifier_output[0][:,classifier_id,0] = np.array([
sum(tt.score_template_background_section(
template0[:,:min(t_len,l)],
bg,
E[:,:min(t_len,l)]))/np.float32(min(t_len,l)) for E,l,bg in zip(plosive_examples[valid_mask],
plosive_lengths[valid_mask],
plosive_bgs[valid_mask])]).astype(np.float32)[:]
# 2 template classification
template0 = np.load(exp_path+classifier+'0template2_1_0.npy')
template1 = np.load(exp_path+classifier+'0template2_1_1.npy')
templates = (template0,template1)
t_lens = (template0.shape[1], template1.shape[1])
classifier_output[0][:,classifier_id,1] = np.array([
max([sum(tt.score_template_background_section(
template[:,:min(t_len,l)],
bg,
E[:,:min(t_len,l)]))/np.float32(min(t_len,l)) for template,t_len in zip(
templates,t_lens)])
for E,l,bg in zip(plosive_examples[valid_mask],
"""
'''
'''
# get backgrounds in order to compute tests
template_height = 366;
num_patterns =registered_templates.shape[0]
bgds_mat = np.zeros((template_height,num_patterns))
template_length = 32
P,C = tt.score_template_background_section(mean_template,bgds_mat[:,0],
registered_templates[0])
# get negative examples for testing
neg_bdg_mat = np.zeros((template_height,exp.num_data))
neg_patterns = np.zeros((exp.num_data,template_height,template_length))
cur_bgd = 0
for path_idx in range(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 True:
s = exp.get_s(path_idx)
E,edge_feature_row_breaks,\
edge_orientations= exp.get_edgemap_no_threshold(s)
E_num_cols)).reshape(T_num_rows,E_num_cols).astype(np.uint8)
num_detections = 1
pad_front = 0
pad_back = 0
W_bg = np.empty(T_num_cols,dtype=np.float64)
detect_sums = np.zeros(num_detections, dtype=np.float64)
bg = np.maximum(.05,
np.random.rand(T_num_rows).astype(np.float64)*.4)
C_inv_long = np.empty((T_num_rows,T_num_cols),dtype=np.float64)
W = np.empty((T_num_rows,T_num_cols),dtype=np.float64)
s,C = tt.score_template_background_section(T,bg,E_window,front_bgd_pad=0,back_bgd_pad=0)
C2 = fast_like.fast_like(T,
bg,
C_inv_long,
W,
T_num_rows,
T_num_cols,
E_window,
E_num_cols,
num_detections,
pad_front,
W_bg,
detect_sums)
detect_sums[:] = 0.
def __init__(self,base_object, coarse_factor=2,
coarse_template_threshold = .7,
bg = None):
self.coarse_factor = coarse_factor
if base_object.__class__ == np.ndarray:
# this means that we just have a template which will be a
# 2-d ndarray, our function assumes this
template_height, template_length = base_object.shape
self.type = "template"
self.window = np.array((template_height,template_length))
self.template = base_object
self.score = lambda E_window,bg:\
sum(tt.score_template_background_section(self.template,
bg,E_window))
# just create a uniform background with .4 as the edge frequency
self.score_no_bg = lambda E_window:\
sum(tt.score_template_background_section(self.template,
self.bg,
E_window))
self.coarse_template = get_coarse_segment(self.template,
coarse_type="avg",
coarse_factor = self.coarse_factor)
self.coarse_length = self.coarse_template.shape[1]
self.coarse_template_mask = self.coarse_template > .7
self.coarse_score_like = lambda E_window,bg:\
sum(tt.score_template_background_section(self.coarse_template,
bg,
get_coarse_segment(E_window,
coarse_type='max',
coarse_factor=self.coarse_factor)))
self.coarse_score_like_no_bg = lambda E_window:\
sum(tt.score_template_background_section(self.coarse_template,
self.bg,
get_coarse_segment(E_window,
coarse_type='max',
coarse_factor=self.coarse_factor)))
self.coarse_score_count = lambda E_window:\
np.sum(get_coarse_segment(E_window,
coarse_type='max',
coarse_factor=self.coarse_factor)[self.coarse_template_mask])
elif base_object.__class__ == TwoPartModel:
template_height, template_length = base_object.bg.shape[0],base_object.length_range[1]
if bg is not None:
self.bg = bg
else:
self.bg = .4 * np.ones(template_height)
self.type = "TwoPartModel"
self.window = np.array((template_height,template_length))
self.template = base_object
self._score_sub_no_bg = lambda E_window,t_id:\
sum(tt.score_template_background_section(self.template.def_templates[t_id],
self.template.bg,E_window))
self.score_no_bg = lambda E_window:\
max([ self._score_sub_no_bg(E_window,t_id) for t_id in xrange(self.template.def_templates.shape[0])])
# just create a uniform background with .4 as the edge frequency
self.coarse_template = get_coarse_segment(self.template.base_template,
coarse_type="avg",
coarse_factor = self.coarse_factor)
self.coarse_length = self.coarse_template.shape[1]
self.coarse_template_mask = self.coarse_template > .7
self.coarse_score_like_no_bg = lambda E_window:\
sum(tt.score_template_background_section(self.coarse_template,
self.bg,
get_coarse_segment(E_window,
coarse_type='max',
coarse_factor=self.coarse_factor)[:,:self.coarse_length]))
self.coarse_score_count = lambda E_window:\
np.sum(get_coarse_segment(E_window,
coarse_type='max',
coarse_factor=self.coarse_factor)[:,:self.coarse_length][self.coarse_template_mask])
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(wait_for_positive_example=True,
compute_pattern_times=True,
max_template_length=classifier.window[1]):
pattern_times = data_iter.pattern_times
num_detections = data_iter.E.shape[1] - liy_template.shape[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+liy_template.shape[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)
scores[d] = sum(tt.score_template_background_section(liy_template,
mean_background,E_segment))
# now we get the indices sorted
indices = remove_overlapping_examples(np.argsort(scores),
liy_template.shape[1],
int(allowed_overlap*liy_template.shape[1]))
positives, negatives = get_pos_neg_scores(indices,pattern_times,
scores,classifier.window[1])
all_positives.extend(positives)
all_negatives.extend(negatives)
else:
break
liy_roc_full,liy_roc_vals_full = get_roc(np.sort(all_positives)[::-1],
np.sort(all_negatives)[::-1],
num_frames)
else:
cur_bgd = mean_background
if frame_idx >= 2:
if j0_scores[frame_idx-1] >= np.maximum(j0_threshold,
np.maximum(j0_scores[frame_idx-2],
j0_scores[frame_idx])):
j0_maxima.append((frame_idx,E_segment,cur_bgd))
j0_detections[frame_idx-1] = 1
j_detections = -np.inf * np.ones(num_detections)
for frame_idx,E_segment,cur_bgd in j0_maxima:
cur_max_score = -np.inf
for fd in xrange(-parts_model.front_def_radius,parts_model.front_def_radius):
for bd in xrange(-parts_model.back_def_radius,parts_model.back_def_radius):
dt = deformed_templates[parts_model.front_def_radius+fd,
parts_model.back_def_radius+bd].copy()
P,C = tt.score_template_background_section(dt,cur_bgd,E_segment)
cur_max_score = np.maximum(cur_max_score,P+C)
j_detections[frame_idx] = cur_max_score
print "Computed Scores"
detection_list = [ (j_detections[d],d) for d in xrange(j_detections.shape[0])]
detection_list = sorted(detection_list)
detect_bool = np.empty(num_detections,dtype=bool)
detect_bool[:] = False
detect_bool[j_detections > -np.inf] = True
# removing the overlapping detections
for val,loc in detection_list:
if detect_bool[loc]:
detect_bool[loc+1:loc+parts_model.deformed_max_length] = False
pattern_times = exp.get_pattern_times(phns,phn_times,s)
maxima_idx = np.arange(num_detections)[j_detections>-np.inf]
# see if we pick up the patterns
# for the data provenance from the simulation
#
#
#1 /p/ itself
# need to redo the feature extraction with the features being less spread
# it would make sense to do this with the whole training data, this time, simply let it run over night
# want to make sure that everything is in order
p_bgs = np.load(root_path+'Data/p_bgs.npy')
p_p_scores = np.zeros((phn_examples.shape[0],len(template_versions)))
for t_id, t in enumerate(template_versions):
for p_id,p_ex in enumerate(phn_examples):
p_p_scores[p_id,t_id] = sum(tt.score_template_background_section(t,p_bgs[p_id],p_ex[:,:t.shape[1]]))
# going to do a regression test based on length and look at
# the residuals from that
p_lengths_regress = np.vstack((np.ones(phn_lengths.shape[0]),
np.vstack((phn_lengths,
phn_lengths**2)))).T
p_p_max_idx = np.argsort(p_p_scores, axis=1)
p_p_least_squares = np.linalg.solve(np.dot(p_lengths_regress.T ,
p_lengths_regress),
np.dot(p_lengths_regress.T,
p_p_max_idx))
# try to build up the best abst threshold vector
cur_abst = abst_threshold.copy()
spread_length=5
for edge in xrange(num_edges):
for thresh in xrange(abst_threshold_check_range.shape[0]):
print "Considering edge",edge," and threshold",abst_threshold_check_range[thresh]
cur_abst[edge] = abst_threshold_check_range[thresh]
for pattern_id in xrange(all_raw_patterns_context_array.shape[0]):
cur_section = all_raw_patterns_context_array[pattern_id].copy()
scores = np.empty(cur_section.shape[1] - template_length)
for t in xrange(cur_section.shape[1] - template_length):
E_segment = cur_section[:,t:t+template_length].copy()
esp.threshold_edgemap(E_segment,.30,edge_feature_row_breaks,abst_threshold=cur_abst)
esp.spread_edgemap(E_segment,edge_feature_row_breaks,edge_orientations,spread_length=spread_length)
P,C = tt.score_template_background_section(mean_template,bgd,E_segment)
scores[t] = P+C
thresholds_score[pattern_id,edge,thresh] = np.max(scores)
# best peformance for the choice of edge type
mean_scores_edge = np.mean(thresholds_score,axis=0)[edge]
best_thresh = np.argmax(mean_scores_edge)
cur_abst[edge] = abst_threshold_check_range[best_thresh]
"""
>>> print cur_abst
[ 0.001 0.001 0.001 0.001 0.001 0.001 0.001 0.001]
"""
#
# very interesting, it appears that we might be better off with the edge
# thresholds much lower
bgd = np.load('/home/mark/projects/Template-Speech-Recognition/Experiments/042212/mean_background042212.npy')
template_length = template_shape[1]
max_detections = -np.inf * np.ones(len(all_patterns_context))
for p_id in xrange(len(all_patterns_context)):
print p_id
p = all_patterns_context[p_id]
num_detections = p.shape[1] - template_length
for d in xrange(num_detections):
E_segment = p[:,d:d+template_length].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)
P,C = tt.score_template_background_section(mean_template,bgd,E_segment)
cur_score = P+C
if cur_score > max_detections[p_id]:
max_detections[p_id] = cur_score
#
# want to see where the bad fits of the model are
# mainly want to see if we can improve these with the
# parts model
#
#
max_detections_pairs = sorted([(max_detections[s],s) for s in xrange(max_detections.shape[0])])
del(all_patterns_context)
