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