def conjugate_stuff():
"""
References:
http://stackoverflow.com/questions/18942096/how-to-conjugate-a-verb-in-nltk-given-pos-tag
pattern.en.conjugate(
verb,
tense="past", # INFINITIVE, PRESENT, PAST, FUTURE
person=3, # 1, 2, 3 or None
number="singular", # SG, PL
mood="indicative", # INDICATIVE, IMPERATIVE, CONDITIONAL, SUBJUNCTIVE
aspect="imperfective", # IMPERFECTIVE, PERFECTIVE, PROGRESSIVE
negated=False) # True or False
"""
import pattern.en
verb = 'score'
multi_dict = dict(
mood=['indicative', 'imperative', 'conditional', 'subjunctive'],
person=[1, 2, 3], # , None],
#number=['sg', 'pl'],
aspect=['imperfective', 'perfective', 'progressive'],
#negated=[False, True],
)
text = 'name score'
for conjkw in ut.all_dict_combinations(multi_dict):
words = text.split(' ')
verb = words[-1]
conj_verb = pattern.en.conjugate(verb, **conjkw)
if conj_verb is not None:
newtext = ' '.join(words[1:-1] +
[conj_verb] if len(words) > 1 else [conj_verb])
print(newtext)
print(conjkw)
print(conj_verb)
def run_inference2(model, min_labels=1, max_labels=10):
cut_params = ut.all_dict_combinations({
#'n_labels': list(range(min_labels, max_labels + 1)),
#'n_labels': list(range(min_labels, max_labels + 1)),
'n_labels':
list(range(max_labels, max_labels + 1)),
})
cut_energies = []
cut_labeling = []
for params in cut_params:
model.run_inference(**params)
nrg = model.total_energy
#complexity = .1 * model.n_nodes * model.thresh * params['n_labels']
complexity = 0
nrg2 = nrg + complexity
print('used %d labels' % (len(set(model.labeling))), )
print('complexity = %r' % (complexity, ))
print('nrg = %r' % (nrg, ))
print('nrg + complexity = %r' % (nrg2, ))
cut_energies.append(nrg2)
cut_labeling.append(model.labeling)
best_paramx = np.argmin(cut_energies)
print('best_paramx = %r' % (best_paramx, ))
params = cut_params[best_paramx]
print('params = %r' % (params, ))
labeling = cut_labeling[best_paramx]
model.labeling = labeling
#labeling = model.run_inference(**params)
return labeling, params
def customize_base_cfg(
cfgname,
cfgopt_strs,
base_cfg,
cfgtype,
alias_keys=None,
valid_keys=None,
offset=0,
strict=True,
):
"""
DEPRICATE
"""
import re
cfg = base_cfg.copy()
# Parse dict out of a string
# ANYTHING_NOT_BRACE = r'[^\[\]]*\]'
ANYTHING_NOT_PAREN_OR_BRACE = r'[^()\[\]]*[\]\)]'
cfgstr_options_list = re.split(
r',\s*' + ut.negative_lookahead(ANYTHING_NOT_PAREN_OR_BRACE), cfgopt_strs
)
# cfgstr_options_list = cfgopt_strs.split(',')
cfg_options = ut.parse_cfgstr_list(
cfgstr_list=cfgstr_options_list, smartcast=True, oldmode=False
)
# Hack for q/d-prefix specific configs
remove_prefix_hack(cfg, cfgtype, cfg_options, alias_keys)
# Remap keynames based on aliases
if alias_keys is not None:
# Use new standard keys and remove old aliased keys
for key in set(alias_keys.keys()):
if key in cfg_options:
cfg_options[alias_keys[key]] = cfg_options[key]
del cfg_options[key]
# Ensure that nothing bad is being updated
if strict:
parsed_keys = cfg_options.keys()
if valid_keys is not None:
ut.assert_all_in(parsed_keys, valid_keys, 'keys specified not in valid set')
else:
ut.assert_all_in(
parsed_keys, cfg.keys(), 'keys specified not in default options'
)
# Finalize configuration dict
cfg.update(cfg_options)
cfg['_cfgtype'] = cfgtype
cfg['_cfgname'] = cfgname
cfg_combo = ut.all_dict_combinations(cfg)
# if len(cfg_combo) > 1:
for combox, cfg_ in enumerate(cfg_combo, start=offset):
# cfg_['_cfgname'] += ';' + str(combox)
cfg_['_cfgindex'] = combox
for cfg_ in cfg_combo:
if len(cfgopt_strs) > 0:
cfg_['_cfgstr'] = cfg_['_cfgname'] + ut.NAMEVARSEP + cfgopt_strs
else:
cfg_['_cfgstr'] = cfg_['_cfgname']
return cfg_combo
def get_varied_params_list(test_cfg_name_list):
vary_dicts = get_vary_dicts(test_cfg_name_list)
dict_comb_list = [utool.all_dict_combinations(dict_) for dict_ in vary_dicts]
dict_comb_lbls = [utool.all_dict_combinations_lbls(dict_) for dict_ in vary_dicts]
# Append testname
dict_comb_lbls = [[name_lbl + lbl for lbl in comb_lbls] for name_lbl, comb_lbls in izip(test_cfg_name_list, dict_comb_lbls)]
varied_params_list = utool.flatten(dict_comb_list) # [comb for dict_comb in dict_comb_list for comb in dict_comb]
varied_param_lbls = utool.flatten(dict_comb_lbls)
return varied_params_list, varied_param_lbls
def main():
if True:
import pandas as pd
pd.options.display.max_rows = 1000
pd.options.display.width = 1000
basis = {
#'n_clusters': [10, 100, 1000, 2000][::-1],
#'n_features': [4, 32, 128, 512][::-1],
#'per_cluster': [1, 10, 100, 200][::-1],
'n_clusters': [10, 100, 500][::-1],
'n_features': [32, 128][::-1],
'per_cluster': [1, 10, 20][::-1],
'asint': [True, False],
}
vals = []
for kw in ut.ProgIter(ut.all_dict_combinations(basis),
lbl='gridsearch',
bs=False,
adjust=False,
freq=1):
print('kw = ' + ut.repr2(kw))
exec(ut.execstr_dict(kw))
centers1, new_speed = test_kmeans_plus_plus_speed(fix=True, **kw)
centers2, old_speed = test_kmeans_plus_plus_speed(fix=False, **kw)
import utool
with utool.embed_on_exception_context:
assert np.all(centers1 == centers2), 'new code disagrees'
kw['new_speed'] = new_speed
kw['old_speed'] = old_speed
vals.append(kw)
print('---------')
df = pd.DataFrame.from_dict(vals)
df['percent_change'] = 100 * (df['old_speed'] -
df['new_speed']) / df['old_speed']
df = df.reindex_axis(list(basis.keys()) +
['new_speed', 'old_speed', 'percent_change'],
axis=1)
df['absolute_change'] = (df['old_speed'] - df['new_speed'])
print(df.sort('absolute_change', ascending=False))
#print(df)
print(df['percent_change'][df['absolute_change'] > .1].mean())
#print(df.loc[df['percent_change'].argsort()[::-1]])
else:
new_speed = test_kmeans_plus_plus_speed()
try:
profile.dump_stats('out.lprof')
profile.print_stats(stripzeros=True)
except Exception:
pass
print('new_speed = %r' % (new_speed, ))
def gridsearch_ratio_thresh(matches):
import sklearn
import sklearn.metrics
import vtool as vt
# Param search for vsone
import wbia.plottool as pt
pt.qt4ensure()
skf = sklearn.model_selection.StratifiedKFold(n_splits=10, random_state=119372)
y = np.array([m.annot1['nid'] == m.annot2['nid'] for m in matches])
basis = {'ratio_thresh': np.linspace(0.6, 0.7, 50).tolist()}
grid = ut.all_dict_combinations(basis)
xdata = np.array(ut.take_column(grid, 'ratio_thresh'))
def _ratio_thresh(y_true, match_list):
# Try and find optional ratio threshold
auc_list = []
for cfgdict in ut.ProgIter(grid, lbl='gridsearch'):
y_score = [
match.fs.compress(match.ratio_test_flags(cfgdict)).sum()
for match in match_list
]
auc = sklearn.metrics.roc_auc_score(y_true, y_score)
auc_list.append(auc)
auc_list = np.array(auc_list)
return auc_list
auc_list = _ratio_thresh(y, matches)
pt.plot(xdata, auc_list)
subx, suby = vt.argsubmaxima(auc_list, xdata)
best_ratio_thresh = subx[suby.argmax()]
skf_results = []
y_true = y
for train_idx, test_idx in skf.split(matches, y):
match_list_ = ut.take(matches, train_idx)
y_true = y.take(train_idx)
auc_list = _ratio_thresh(y_true, match_list_)
subx, suby = vt.argsubmaxima(auc_list, xdata, maxima_thresh=0.8)
best_ratio_thresh = subx[suby.argmax()]
skf_results.append(best_ratio_thresh)
logger.info('skf_results.append = %r' % (np.mean(skf_results),))
import utool
utool.embed()
def customize_base_cfg(cfgname, cfgopt_strs, base_cfg, cfgtype,
alias_keys=None, valid_keys=None, offset=0,
strict=True):
"""
DEPRICATE
"""
import re
cfg = base_cfg.copy()
# Parse dict out of a string
#ANYTHING_NOT_BRACE = r'[^\[\]]*\]'
ANYTHING_NOT_PAREN_OR_BRACE = r'[^()\[\]]*[\]\)]'
cfgstr_options_list = re.split(
r',\s*' + ut.negative_lookahead(ANYTHING_NOT_PAREN_OR_BRACE), cfgopt_strs)
#cfgstr_options_list = cfgopt_strs.split(',')
cfg_options = ut.parse_cfgstr_list(
cfgstr_list=cfgstr_options_list, smartcast=True, oldmode=False)
# Hack for q/d-prefix specific configs
remove_prefix_hack(cfg, cfgtype, cfg_options, alias_keys)
# Remap keynames based on aliases
if alias_keys is not None:
# Use new standard keys and remove old aliased keys
for key in set(alias_keys.keys()):
if key in cfg_options:
cfg_options[alias_keys[key]] = cfg_options[key]
del cfg_options[key]
# Ensure that nothing bad is being updated
if strict:
parsed_keys = cfg_options.keys()
if valid_keys is not None:
ut.assert_all_in(parsed_keys, valid_keys,
'keys specified not in valid set')
else:
ut.assert_all_in(parsed_keys, cfg.keys(),
'keys specified not in default options')
# Finalize configuration dict
cfg.update(cfg_options)
cfg['_cfgtype'] = cfgtype
cfg['_cfgname'] = cfgname
cfg_combo = ut.all_dict_combinations(cfg)
#if len(cfg_combo) > 1:
for combox, cfg_ in enumerate(cfg_combo, start=offset):
#cfg_['_cfgname'] += ';' + str(combox)
cfg_['_cfgindex'] = combox
for cfg_ in cfg_combo:
if len(cfgopt_strs) > 0:
cfg_['_cfgstr'] = cfg_['_cfgname'] + ut.NAMEVARSEP + cfgopt_strs
else:
cfg_['_cfgstr'] = cfg_['_cfgname']
return cfg_combo
def test_training_data(varydict, nDaids_basis):
varydict['nDaids'] = nDaids_basis
cfgdict_list = ut.all_dict_combinations(varydict)
K_list = ut.get_list_column(cfgdict_list, 'K')
nDaids_list = ut.get_list_column(cfgdict_list, 'nDaids')
max_error = min(nDaids_basis)
nError_perterb = np.random.rand(len(K_list))
#def distance_point_polynomial(point, poly_coeff):
# """
# References:
# http://kitchingroup.cheme.cmu.edu/blog/2013/02/14/Find-the-minimum-distance-from-a-point-to-a-curve/
# """
# def f(x):
# return x ** 2
# def objective(X, *args):
# point = args[0]
# x, y = X
# px, py = point
# return np.sqrt((x - px) ** 2 + (y - py) ** 2)
# def c1(X, *args):
# x, y = X
# return f(x) - y
# X = sp.optimize.fmin_cobyla(objective, x0=[0.5, 0.5], args=(point,), cons=[c1], disp=False)
# return X
#point_list = np.array([point for point in zip(nDaids_list, K_list)])
#poly_coeff = [0.2, 0.5] # K model_params
#closest_point_list = np.array([distance_point_polynomial(point, poly_coeff) for point in point_list])
#dist_list = np.sqrt(((point_list - closest_point_list) ** 2).sum(axis=1))
#nError_list = max_error * dist_list / dist_list.max() + nError_perterb
nError_list = (np.array(nDaids_list) * .00001)
nError_list /= nError_list.max()
nError_list *= (max_error - 2)
nError_list += 1 + nError_perterb
#K_list = np.array([ 1, 1, 1, 4, 4, 4, 7, 7, 7, 10, 10, 10, 13, 13, 13])
#nDaids_list = np.array([100, 500, 1000, 100, 500, 1000, 100, 500, 1000, 100, 500, 1000, 100, 500, 1000])
#nError_list = np.array([ 5, 54, 130, 50, 50, 70, 14, 54, 40, 20, 9, 43, 90, 20, 130])
return nDaids_list, K_list, nError_list
def test_training_data(varydict, nDaids_basis):
varydict['nDaids'] = nDaids_basis
cfgdict_list = ut.all_dict_combinations(varydict)
K_list = ut.get_list_column(cfgdict_list, 'K')
nDaids_list = ut.get_list_column(cfgdict_list, 'nDaids')
max_error = min(nDaids_basis)
nError_perterb = np.random.rand(len(K_list))
#def distance_point_polynomial(point, poly_coeff):
# """
# References:
# http://kitchingroup.cheme.cmu.edu/blog/2013/02/14/Find-the-minimum-distance-from-a-point-to-a-curve/
# """
# def f(x):
# return x ** 2
# def objective(X, *args):
# point = args[0]
# x, y = X
# px, py = point
# return np.sqrt((x - px) ** 2 + (y - py) ** 2)
# def c1(X, *args):
# x, y = X
# return f(x) - y
# X = sp.optimize.fmin_cobyla(objective, x0=[0.5, 0.5], args=(point,), cons=[c1], disp=False)
# return X
#point_list = np.array([point for point in zip(nDaids_list, K_list)])
#poly_coeff = [0.2, 0.5] # K model_params
#closest_point_list = np.array([distance_point_polynomial(point, poly_coeff) for point in point_list])
#dist_list = np.sqrt(((point_list - closest_point_list) ** 2).sum(axis=1))
#nError_list = max_error * dist_list / dist_list.max() + nError_perterb
nError_list = (np.array(nDaids_list) * .00001)
nError_list /= nError_list.max()
nError_list *= (max_error - 2)
nError_list += 1 + nError_perterb
#K_list = np.array([ 1, 1, 1, 4, 4, 4, 7, 7, 7, 10, 10, 10, 13, 13, 13])
#nDaids_list = np.array([100, 500, 1000, 100, 500, 1000, 100, 500, 1000, 100, 500, 1000, 100, 500, 1000])
#nError_list = np.array([ 5, 54, 130, 50, 50, 70, 14, 54, 40, 20, 9, 43, 90, 20, 130])
return nDaids_list, K_list, nError_list
def evaluate_training_data(ibs,
qaids,
daids_list,
varydict,
nDaids_basis,
verbose=True):
nError_list = []
nDaids_list = []
cfgdict_list2 = []
cfgdict_list = ut.all_dict_combinations(varydict)
for daids in ut.ProgressIter(daids_list, lbl='testing dbsize'):
nDaids = len(daids)
print('\n---------------------------')
with ut.Indenter('[nDaids=%r]' % (nDaids)):
print('nDaids = %r' % nDaids)
for cfgdict in ut.ProgressIter(cfgdict_list,
lbl='testing cfgdict'):
qreq_ = ibs.new_query_request(qaids,
daids,
cfgdict=cfgdict,
verbose=verbose)
qres_list = ibs.query_chips(qreq_=qreq_, verbose=verbose)
gt_ranks_list = [
qres.get_gt_ranks(ibs=ibs) for qres in qres_list
]
incorrect_list = [
len(gt_ranks) == 0 or min(gt_ranks) != 0
for gt_ranks in gt_ranks_list
]
nErrors = sum(incorrect_list)
nError_list.append(nErrors)
nDaids_list.append(nDaids)
cfgdict_list2.append(cfgdict.copy())
nError_list = np.array(nError_list)
nDaids_list = np.array(nDaids_list)
K_list = np.array([cfgdict['K'] for cfgdict in cfgdict_list2])
return nDaids_list, K_list, nError_list
def run_inference2(model, max_labels=5):
cut_params = ut.all_dict_combinations({
'n_labels': list(range(1, max_labels)),
})
cut_energies = []
cut_labeling = []
for params in cut_params:
model.run_inference(**params)
nrg = model.total_energy
complexity = .1 * model.n_nodes * model.thresh * params['n_labels']
nrg2 = nrg + complexity
print('complexity = %r' % (complexity,))
print('nrg = %r' % (nrg,))
print('nrg2 = %r' % (nrg2,))
cut_energies.append(nrg2)
cut_labeling.append(model.labeling)
best_paramx = np.argmin(cut_energies)
print('best_paramx = %r' % (best_paramx,))
params = cut_params[best_paramx]
print('params = %r' % (params,))
labeling = model.run_inference(**params)
return labeling, params
def run_inference2(model, max_labels=5):
cut_params = ut.all_dict_combinations({
'n_labels':
list(range(1, max_labels)),
})
cut_energies = []
cut_labeling = []
for params in cut_params:
model.run_inference(**params)
nrg = model.total_energy
complexity = .1 * model.n_nodes * model.thresh * params['n_labels']
nrg2 = nrg + complexity
print('complexity = %r' % (complexity, ))
print('nrg = %r' % (nrg, ))
print('nrg2 = %r' % (nrg2, ))
cut_energies.append(nrg2)
cut_labeling.append(model.labeling)
best_paramx = np.argmin(cut_energies)
print('best_paramx = %r' % (best_paramx, ))
params = cut_params[best_paramx]
print('params = %r' % (params, ))
labeling = model.run_inference(**params)
return labeling, params
def evaluate_training_data(ibs, qaids, daids_list, varydict, nDaids_basis, verbose=True):
nError_list = []
nDaids_list = []
cfgdict_list2 = []
cfgdict_list = ut.all_dict_combinations(varydict)
for daids in ut.ProgressIter(daids_list, lbl='testing dbsize'):
nDaids = len(daids)
print('\n---------------------------')
with ut.Indenter('[nDaids=%r]' % (nDaids)):
print('nDaids = %r' % nDaids)
for cfgdict in ut.ProgressIter(cfgdict_list, lbl='testing cfgdict'):
qreq_ = ibs.new_query_request(qaids, daids, cfgdict=cfgdict, verbose=verbose)
qres_list = ibs.query_chips(qreq_=qreq_, verbose=verbose)
gt_ranks_list = [qres.get_gt_ranks(ibs=ibs) for qres in qres_list]
incorrect_list = [len(gt_ranks) == 0 or min(gt_ranks) != 0 for gt_ranks in gt_ranks_list]
nErrors = sum(incorrect_list)
nError_list.append(nErrors)
nDaids_list.append(nDaids)
cfgdict_list2.append(cfgdict.copy())
nError_list = np.array(nError_list)
nDaids_list = np.array(nDaids_list)
K_list = np.array([cfgdict['K'] for cfgdict in cfgdict_list2])
return nDaids_list, K_list, nError_list
def param_interaction():
r"""
CommandLine:
python -m vtool.test_constrained_matching --test-param_interaction
Notes:
python -m vtool.test_constrained_matching --test-param_interaction
setparam normalizer_mode=nearby
setparam normalizer_mode=far
setparam ratio_thresh=.625
setparam ratio_thresh=.5
setparam ratio_thresh2=.625
normalizer_mode=plus
Example:
>>> # DISABLE_DOCTEST
>>> from vtool.test_constrained_matching import * # NOQA
>>> # build test data
>>> # execute function
>>> testtup = param_interaction()
>>> # verify results
>>> result = str(testtup)
>>> print(result)
"""
import plottool as pt
USE_IBEIS = False and ut.is_developer()
if USE_IBEIS:
from ibeis.algo.hots import devcases
index = 2
fpath1, fpath2, fpath3 = devcases.get_dev_test_fpaths(index)
testtup1 = testdata_matcher(fpath1, fpath2)
testtup2 = testdata_matcher(fpath1, fpath3)
else:
testtup1 = testdata_matcher('easy1.png', 'easy2.png')
testtup2 = testdata_matcher('easy1.png', 'hard3.png')
testtup_list = [testtup1, testtup2]
simp_list = [SimpleMatcher(testtup) for testtup in testtup_list]
varied_dict = dict([
('sver_xy_thresh', .1),
('ratio_thresh', .625),
('search_K', 7),
('ratio_thresh2', .625),
('sver_xy_thresh2', .01),
('normalizer_mode', ['nearby', 'far', 'plus'][1]),
('match_xy_thresh', .1),
])
cfgdict_list = ut.all_dict_combinations(varied_dict)
tried_configs = []
# DEFINE CUSTOM INTRACTIONS
custom_actions, valid_vizmodes, viz_index_, offset_fnum_ = make_custom_interactions(simp_list)
# /DEFINE CUSTOM INTRACTIONS
for cfgdict in ut.InteractiveIter(cfgdict_list,
#default_action='reload',
custom_actions=custom_actions,
wraparound=True):
for simp in simp_list:
simp.run_matching(cfgdict=cfgdict)
vizkey = valid_vizmodes[viz_index_[0]].replace('visualize_', '')
print('vizkey = %r' % (vizkey,))
for fnum_, simp in enumerate(simp_list):
fnum = fnum_ + offset_fnum_[0]
simp.visualize(vizkey, fnum=fnum)
tried_configs.append(cfgdict.copy())
print('Current Config = ')
print(ut.dict_str(cfgdict))
pt.present()
pt.update()
def customize_base_cfg(cfgname, cfgopt_strs, base_cfg, cfgtype,
alias_keys=None, valid_keys=None, offset=0,
strict=True):
"""
Args:
cfgname (str): config name
cfgopt_strs (str): mini-language defining key variations
base_cfg (dict): specifies the default cfg to customize
cfgtype (?):
alias_keys (None): (default = None)
valid_keys (None): if base_cfg is not specied, this defines the valid
keys (default = None)
offset (int): (default = 0)
strict (bool): (default = True)
Returns:
list: cfg_combo - list of config dicts defining customized configs
based on cfgopt_strs. customized configs always are given an
_cfgindex, _cfgstr, and _cfgname key.
CommandLine:
python -m ibeis.expt.cfghelpers --exec-_customize_base_cfg
Example:
>>> # DISABLE_DOCTEST
>>> from ibeis.expt.cfghelpers import * # NOQA
>>> cfgname = 'default'
>>> cfgopt_strs = 'dsize=1000,per_name=[1,2]'
>>> base_cfg = '?'
>>> cfgtype = '?'
>>> alias_keys = None
>>> valid_keys = None
>>> offset = 0
>>> strict = True
>>> cfg_combo = customize_base_cfg(cfgname, cfgopt_strs, base_cfg, cfgtype, alias_keys, valid_keys, offset, strict)
>>> result = ('cfg_combo = %s' % (str(cfg_combo),))
>>> print(result)
"""
cfg = base_cfg.copy()
# Parse dict out of a string
#ANYTHING_NOT_BRACE = r'[^\[\]]*\]'
ANYTHING_NOT_PAREN_OR_BRACE = r'[^()\[\]]*[\]\)]'
cfgstr_options_list = re.split(
r',\s*' + ut.negative_lookahead(ANYTHING_NOT_PAREN_OR_BRACE), cfgopt_strs)
#cfgstr_options_list = cfgopt_strs.split(',')
cfg_options = ut.parse_cfgstr_list(
cfgstr_list=cfgstr_options_list, smartcast=True, oldmode=False)
# Hack for q/d-prefix specific configs
remove_prefix_hack(cfg, cfgtype, cfg_options, alias_keys)
# Remap keynames based on aliases
if alias_keys is not None:
# Use new standard keys and remove old aliased keys
for key in set(alias_keys.keys()):
if key in cfg_options:
cfg_options[alias_keys[key]] = cfg_options[key]
del cfg_options[key]
# Ensure that nothing bad is being updated
if strict:
parsed_keys = cfg_options.keys()
if valid_keys is not None:
ut.assert_all_in(parsed_keys, valid_keys,
'keys specified not in valid set')
else:
ut.assert_all_in(parsed_keys, cfg.keys(),
'keys specified not in default options')
# Finalize configuration dict
cfg.update(cfg_options)
cfg['_cfgtype'] = cfgtype
cfg['_cfgname'] = cfgname
cfg_combo = ut.all_dict_combinations(cfg)
#if len(cfg_combo) > 1:
for combox, cfg_ in enumerate(cfg_combo, start=offset):
#cfg_['_cfgname'] += ';' + str(combox)
cfg_['_cfgindex'] = combox
for cfg_ in cfg_combo:
if len(cfgopt_strs) > 0:
cfg_['_cfgstr'] = cfg_['_cfgname'] + NAMEVARSEP + cfgopt_strs
else:
cfg_['_cfgstr'] = cfg_['_cfgname']
return cfg_combo
def chunked_search():
"""
Computational complexity of building one kd-tree and searching vs building
many and searching.
--------------------------------
Normal Running Time:
Indexing:
D⋅log(D⋅p)
Query:
Q⋅log(D⋅p)
--------------------------------
--------------------------------
Chunked Running Time:
Indexing:
⎛D⋅p⎞
D⋅log⎜───⎟
⎝ C ⎠
Query:
⎛D⋅p⎞
C⋅Q⋅log⎜───⎟
⎝ C ⎠
--------------------------------
Conclusion: chunking provides a tradeoff in running time.
It can make indexing, faster, but it makes query-time slower. However, it
does allow for partial database search, which can speed up response time of
queries. It can also short-circuit itself once a match has been found.
"""
import sympy as sym
import utool as ut
ceil = sym.ceiling
ceil = ut.identity
log = sym.log
#
# ====================
# Define basic symbols
# ====================
# Number of database and query annotations
n_dannots, n_qannots = sym.symbols('D, Q')
# Average number of descriptors per annotation
n_vecs_per_annot = sym.symbols('p')
# Size of the shortlist to rerank
n_rr = sym.symbols('L')
# The number of chunks
C = sym.symbols('C')
#
# ===============================================
# Define helper functions and intermediate values
# ===============================================
n_dvecs = n_vecs_per_annot * n_dannots
# Could compute the maximum average matches something gets
# but for now just hack it
fmatch = sym.Function('fmatch')
n_fmatches = fmatch(n_vecs_per_annot)
# The complexity of spatial verification is roughly that of SVD
# SV_fn = lambda N: N ** 3 # NOQA
SV_fn = sym.Function('SV')
SV = SV_fn(n_fmatches)
class KDTree(object):
# A bit of a simplification
n_trees = sym.symbols('T')
params = {n_trees}
@classmethod
def build(self, N):
return N * log(N) * self.n_trees
@classmethod
def search(self, N):
# This is average case
return log(N) * self.n_trees
Indexer = KDTree
def sort(N):
return N * log(N)
#
# ========================
# Define normal complexity
# ========================
# The computational complexity of the normal hotspotter pipeline
normal = {}
normal['indexing'] = Indexer.build(n_dvecs)
normal['search'] = n_vecs_per_annot * Indexer.search(n_dvecs)
normal['rerank'] = (SV * n_rr)
normal['query'] = (normal['search'] + normal['rerank']) * n_qannots
normal['total'] = normal['indexing'] + normal['query']
n_cannots = ceil(n_dannots / C)
n_cvecs = n_vecs_per_annot * n_cannots
# How many annots should be re-ranked in each chunk?
# _n_rr_chunk = sym.Max(n_rr / C * log(n_rr / C), 1)
# _n_rr_chunk = n_rr / C
_n_rr_chunk = n_rr
_index_chunk = Indexer.build(n_cvecs)
_search_chunk = n_vecs_per_annot * Indexer.search(n_cvecs)
chunked = {}
chunked['indexing'] = C * _index_chunk
chunked['search'] = C * _search_chunk
# Cost to rerank in every chunk and then merge chunks into a single list
chunked['rerank'] = C * (SV * _n_rr_chunk) + sort(C * _n_rr_chunk)
chunked['query'] = (chunked['search'] + chunked['rerank']) * n_qannots
chunked['total'] = chunked['indexing'] + chunked['query']
typed_steps = {
'normal': normal,
'chunked': chunked,
}
#
# ===============
# Inspect results
# ===============
# Symbols that will not go to infinity
const_symbols = {n_rr, n_vecs_per_annot}.union(Indexer.params)
def measure_num(n_steps, step, type_):
print('nsteps(%s %s)' % (
step,
type_,
))
sym.pprint(n_steps)
def measure_order(n_steps, step, type_):
print('O(%s %s)' % (
step,
type_,
))
limiting = [(s, sym.oo) for s in n_steps.free_symbols - const_symbols]
step_order = sym.Order(n_steps, *limiting)
sym.pprint(step_order.args[0])
measure_dict = {
'num': measure_num,
'order': measure_order,
}
# Different methods for choosing C
C_methods = ut.odict([
('none', C),
('const', 512),
('linear', n_dannots / 512),
('log', log(n_dannots)),
])
# ---
# What to measure?
# ---
steps = ['indexing', 'query']
types_ = ['normal', 'chunked']
measures = [
# 'num',
'order'
]
C_method_keys = [
'none'
# 'const'
]
grid = ut.odict([
('step', steps),
('measure', measures),
('k', C_method_keys),
('type_', types_),
])
last = None
for params in ut.all_dict_combinations(grid):
type_ = params['type_']
step = params['step']
k = params['k']
# now = k
now = step
if last != now:
print('=========')
print('\n\n=========')
last = now
print('')
print(ut.repr2(params, stritems=True))
measure_fn = measure_dict[params['measure']]
info = typed_steps[type_]
n_steps = info[step]
n_steps = n_steps.subs(C, C_methods[k])
measure_fn(n_steps, step, type_)
def param_interaction():
r"""
CommandLine:
python -m vtool.test_constrained_matching --test-param_interaction
Notes:
python -m vtool.test_constrained_matching --test-param_interaction
setparam normalizer_mode=nearby
setparam normalizer_mode=far
setparam ratio_thresh=.625
setparam ratio_thresh=.5
setparam ratio_thresh2=.625
normalizer_mode=plus
Example:
>>> # DISABLE_DOCTEST
>>> from vtool.test_constrained_matching import * # NOQA
>>> # build test data
>>> # execute function
>>> testtup = param_interaction()
>>> # verify results
>>> result = str(testtup)
>>> print(result)
"""
import plottool as pt
USE_IBEIS = False and ut.is_developer()
if USE_IBEIS:
from ibeis.algo.hots import devcases
index = 2
fpath1, fpath2, fpath3 = devcases.get_dev_test_fpaths(index)
testtup1 = testdata_matcher(fpath1, fpath2)
testtup2 = testdata_matcher(fpath1, fpath3)
else:
testtup1 = testdata_matcher('easy1.png', 'easy2.png')
testtup2 = testdata_matcher('easy1.png', 'hard3.png')
testtup_list = [testtup1, testtup2]
simp_list = [SimpleMatcher(testtup) for testtup in testtup_list]
varied_dict = dict([
('sver_xy_thresh', .1),
('ratio_thresh', .625),
('search_K', 7),
('ratio_thresh2', .625),
('sver_xy_thresh2', .01),
('normalizer_mode', ['nearby', 'far', 'plus'][1]),
('match_xy_thresh', .1),
])
cfgdict_list = ut.all_dict_combinations(varied_dict)
tried_configs = []
# DEFINE CUSTOM INTRACTIONS
custom_actions, valid_vizmodes, viz_index_, offset_fnum_ = make_custom_interactions(
simp_list)
# /DEFINE CUSTOM INTRACTIONS
for cfgdict in ut.InteractiveIter(
cfgdict_list,
#default_action='reload',
custom_actions=custom_actions,
wraparound=True):
for simp in simp_list:
simp.run_matching(cfgdict=cfgdict)
vizkey = valid_vizmodes[viz_index_[0]].replace('visualize_', '')
print('vizkey = %r' % (vizkey, ))
for fnum_, simp in enumerate(simp_list):
fnum = fnum_ + offset_fnum_[0]
simp.visualize(vizkey, fnum=fnum)
tried_configs.append(cfgdict.copy())
print('Current Config = ')
print(ut.dict_str(cfgdict))
pt.present()
pt.update()
