def score_masks(masks_iter):
# DEPRICATE
id_score_list = [(id_, score_matching_mask(weight_mask_m, weight_mask))
for id_, weight_mask_m, weight_mask in masks_iter]
id_list = np.array(ut.get_list_column(id_score_list, 0))
coverage_score = np.array(ut.get_list_column(id_score_list, 1))
return id_list, coverage_score
def parse_items(cfg):
r"""
Returns:
list: param_list
CommandLine:
python -m dtool.base --exec-parse_items
Example:
>>> # ENABLE_DOCTEST
>>> from dtool.base import * # NOQA
>>> from dtool.example_depcache import DummyVsManyConfig
>>> cfg = DummyVsManyConfig()
>>> param_list = cfg.parse_items()
>>> result = ('param_list = %s' % (ut.repr2(param_list, nl=1),))
>>> print(result)
"""
namespace_param_list = cfg.parse_namespace_config_items()
param_names = ut.get_list_column(namespace_param_list, 1)
needs_namespace_keys = ut.find_duplicate_items(param_names)
param_list = ut.get_list_column(namespace_param_list, [1, 2])
# prepend namespaces to variables that need it
for idx in ut.flatten(needs_namespace_keys.values()):
name = namespace_param_list[idx][0]
param_list[idx][0] = name + '_' + param_list[idx][0]
duplicate_keys = ut.find_duplicate_items(ut.get_list_column(param_list, 0))
# hack to let version through
#import utool
#with utool.embed_on_exception_context:
assert len(duplicate_keys) == 0, (
'Configs have duplicate names: %r' % duplicate_keys)
return param_list
def group_review():
prefill = request.args.get('prefill', '')
if len(prefill) > 0:
ibs = current_app.ibs
aid_list = ibs.get_valid_aids()
bad_species_list, bad_viewpoint_list = ibs.validate_annot_species_viewpoint_cnn(aid_list)
GROUP_BY_PREDICTION = True
if GROUP_BY_PREDICTION:
grouped_dict = ut.group_items(bad_viewpoint_list, ut.get_list_column(bad_viewpoint_list, 3))
grouped_list = grouped_dict.values()
regrouped_items = ut.flatten(ut.sortedby(grouped_list, map(len, grouped_list)))
candidate_aid_list = ut.get_list_column(regrouped_items, 0)
else:
candidate_aid_list = [ bad_viewpoint[0] for bad_viewpoint in bad_viewpoint_list]
elif request.args.get('aid_list', None) is not None:
aid_list = request.args.get('aid_list', '')
if len(aid_list) > 0:
aid_list = aid_list.replace('[', '')
aid_list = aid_list.replace(']', '')
aid_list = aid_list.strip().split(',')
candidate_aid_list = [ int(aid_.strip()) for aid_ in aid_list ]
else:
candidate_aid_list = ''
else:
candidate_aid_list = ''
return appf.template(None, 'group_review', candidate_aid_list=candidate_aid_list, mode_list=appf.VALID_TURK_MODES)
def parse_items(cfg):
r"""
Returns:
list: param_list
CommandLine:
python -m dtool.base --exec-parse_items
Example:
>>> # ENABLE_DOCTEST
>>> from dtool.base import * # NOQA
>>> from dtool.example_depcache import DummyVsManyConfig
>>> cfg = DummyVsManyConfig()
>>> param_list = cfg.parse_items()
>>> result = ('param_list = %s' % (ut.repr2(param_list, nl=1),))
>>> print(result)
"""
namespace_param_list = cfg.parse_namespace_config_items()
param_names = ut.get_list_column(namespace_param_list, 1)
needs_namespace_keys = ut.find_duplicate_items(param_names)
param_list = ut.get_list_column(namespace_param_list, [1, 2])
# prepend namespaces to variables that need it
for idx in ut.flatten(needs_namespace_keys.values()):
name = namespace_param_list[idx][0]
param_list[idx][0] = name + '_' + param_list[idx][0]
duplicate_keys = ut.find_duplicate_items(ut.get_list_column(param_list, 0))
# hack to let version through
import utool
with utool.embed_on_exception_context:
assert len(duplicate_keys) == 0, (
'Configs have duplicate names: %r' % duplicate_keys)
return param_list
def get_name_rowid_edges_from_nids(ibs, nids):
aids_list = ibs.get_name_aids(nids)
import itertools
unflat_edges = (list(itertools.product(aids, aids)) for aids in aids_list)
aid_pairs = [tup for tup in ut.iflatten(unflat_edges) if tup[0] != tup[1]]
aids1 = ut.get_list_column(aid_pairs, 0)
aids2 = ut.get_list_column(aid_pairs, 1)
return aids1, aids2
def get_name_rowid_edges_from_nids(ibs, nids):
aids_list = ibs.get_name_aids(nids)
import itertools
unflat_edges = (list(itertools.product(aids, aids)) for aids in aids_list)
aid_pairs = [tup for tup in ut.iflatten(unflat_edges) if tup[0] != tup[1]]
aids1 = ut.get_list_column(aid_pairs, 0)
aids2 = ut.get_list_column(aid_pairs, 1)
return aids1, aids2
def plotdata(data_list):
count_arr = ut.get_list_column(data_list, 1)
time_arr = ut.get_list_column(data_list, 2)
pt.plot2(count_arr,
time_arr,
marker='-o',
equal_aspect=False,
x_label='num_vectors',
y_label='FLANN build time')
def get_name_rowid_edges_from_aids2(ibs, aids_list):
# grouped version
import itertools
unflat_edges = (list(itertools.product(aids, aids)) for aids in aids_list)
#if full:
aid_pairs = [tup for tup in ut.iflatten(unflat_edges) if tup[0] != tup[1]]
aids1 = ut.get_list_column(aid_pairs, 0)
aids2 = ut.get_list_column(aid_pairs, 1)
return aids1, aids2
def get_namescore_nonvoting_feature_flags(fm_list, fs_list, dnid_list, name_groupxs, kpts1=None):
r"""
DEPRICATE
fm_list = [fm[:min(len(fm), 10)] for fm in fm_list]
fs_list = [fs[:min(len(fs), 10)] for fs in fs_list]
"""
fx1_list = [fm.T[0] for fm in fm_list]
# Group annotation matches by name
name_grouped_fx1_list = vt.apply_grouping_(fx1_list, name_groupxs)
name_grouped_fs_list = vt.apply_grouping_(fs_list, name_groupxs)
# Stack up all matches to a particular name, keep track of original indicies via offets
name_invertable_flat_fx1_list = list(map(ut.invertible_flatten2_numpy, name_grouped_fx1_list))
name_grouped_fx1_flat = ut.get_list_column(name_invertable_flat_fx1_list, 0)
name_grouped_invertable_cumsum_list = ut.get_list_column(name_invertable_flat_fx1_list, 1)
name_grouped_fs_flat = list(map(np.hstack, name_grouped_fs_list))
if kpts1 is not None:
xys1_ = vt.get_xys(kpts1).T
kpts_xyid_list = vt.compute_unique_data_ids(xys1_)
# Make nested group for every name by query feature index (accounting for duplicate orientation)
name_grouped_comboid_flat = list(kpts_xyid_list.take(fx1) for fx1 in name_grouped_fx1_flat)
xyid_groupxs_list = list(vt.group_indices(xyid_flat)[1] for xyid_flat in name_grouped_comboid_flat)
name_group_fx1_groupxs_list = xyid_groupxs_list
else:
# Make nested group for every name by query feature index
fx1_groupxs_list = [vt.group_indices(fx1_flat)[1] for fx1_flat in name_grouped_fx1_flat]
name_group_fx1_groupxs_list = fx1_groupxs_list
name_grouped_fid_grouped_fs_list = [
vt.apply_grouping(fs_flat, fid_groupxs)
for fs_flat, fid_groupxs in zip(name_grouped_fs_flat, name_group_fx1_groupxs_list)
]
# Flag which features are valid in this grouped space. Only one keypoint should be able to vote
# for each group
name_grouped_fid_grouped_isvalid_list = [
np.array([fs_group.max() == fs_group for fs_group in fid_grouped_fs_list])
for fid_grouped_fs_list in name_grouped_fid_grouped_fs_list
]
# Go back to being grouped only in name space
#dtype = np.bool
name_grouped_isvalid_flat_list = [
vt.invert_apply_grouping2(fid_grouped_isvalid_list, fid_groupxs, dtype=np.bool)
for fid_grouped_isvalid_list, fid_groupxs in zip(name_grouped_fid_grouped_isvalid_list, name_group_fx1_groupxs_list)
]
name_grouped_isvalid_unflat_list = [
ut.unflatten2(isvalid_flat, invertable_cumsum_list)
for isvalid_flat, invertable_cumsum_list in zip(name_grouped_isvalid_flat_list, name_grouped_invertable_cumsum_list)
]
# Reports which features were valid in name scoring for every annotation
featflag_list = vt.invert_apply_grouping(name_grouped_isvalid_unflat_list, name_groupxs)
return featflag_list
def draw_map_histogram(top_assignments, fnum=None, pnum=(1, 1, 1)):
import plottool as pt
bin_labels = ut.get_list_column(top_assignments, 0)
bin_vals = ut.get_list_column(top_assignments, 1)
fnum = pt.ensure_fnum(fnum)
# bin_labels = ['\n'.join(ut.textwrap.wrap(_lbl, width=30)) for _lbl in bin_labels]
pt.draw_histogram(bin_labels, bin_vals, fnum=fnum, pnum=pnum,
transpose=True,
use_darkbackground=False,
#xtick_rotation=-10,
ylabel='Prob', xlabel='assignment')
pt.set_title('Assignment probabilities')
def get_namescore_nonvoting_feature_flags(fm_list, fs_list, dnid_list, name_groupxs, kpts1=None):
r"""
fm_list = [fm[:min(len(fm), 10)] for fm in fm_list]
fs_list = [fs[:min(len(fs), 10)] for fs in fs_list]
"""
fx1_list = [fm.T[0] for fm in fm_list]
# Group annotation matches by name
name_grouped_fx1_list = vt.apply_grouping_(fx1_list, name_groupxs)
name_grouped_fs_list = vt.apply_grouping_(fs_list, name_groupxs)
# Stack up all matches to a particular name, keep track of original indicies via offets
name_invertable_flat_fx1_list = list(map(ut.invertible_flatten2_numpy, name_grouped_fx1_list))
name_grouped_fx1_flat = ut.get_list_column(name_invertable_flat_fx1_list, 0)
name_grouped_invertable_cumsum_list = ut.get_list_column(name_invertable_flat_fx1_list, 1)
name_grouped_fs_flat = list(map(np.hstack, name_grouped_fs_list))
if kpts1 is not None:
xys1_ = vt.get_xys(kpts1).T
kpts_xyid_list = vt.compute_unique_data_ids(xys1_)
# Make nested group for every name by query feature index (accounting for duplicate orientation)
name_grouped_xyid_flat = list(kpts_xyid_list.take(fx1) for fx1 in name_grouped_fx1_flat)
xyid_groupxs_list = list(vt.group_indices(xyid_flat)[1] for xyid_flat in name_grouped_xyid_flat)
name_group_fx1_groupxs_list = xyid_groupxs_list
else:
# Make nested group for every name by query feature index
fx1_groupxs_list = [vt.group_indices(fx1_flat)[1] for fx1_flat in name_grouped_fx1_flat]
name_group_fx1_groupxs_list = fx1_groupxs_list
name_grouped_fid_grouped_fs_list = [
vt.apply_grouping(fs_flat, fid_groupxs)
for fs_flat, fid_groupxs in zip(name_grouped_fs_flat, name_group_fx1_groupxs_list)
]
# Flag which features are valid in this grouped space. Only one keypoint should be able to vote
# for each group
name_grouped_fid_grouped_isvalid_list = [
np.array([fs_group.max() == fs_group for fs_group in fid_grouped_fs_list])
for fid_grouped_fs_list in name_grouped_fid_grouped_fs_list
]
# Go back to being grouped only in name space
#dtype = np.bool
name_grouped_isvalid_flat_list = [
vt.invert_apply_grouping2(fid_grouped_isvalid_list, fid_groupxs, dtype=np.bool)
for fid_grouped_isvalid_list, fid_groupxs in zip(name_grouped_fid_grouped_isvalid_list, name_group_fx1_groupxs_list)
]
name_grouped_isvalid_unflat_list = [
ut.unflatten2(isvalid_flat, invertable_cumsum_list)
for isvalid_flat, invertable_cumsum_list in zip(name_grouped_isvalid_flat_list, name_grouped_invertable_cumsum_list)
]
# Reports which features were valid in name scoring for every annotation
featflag_list = vt.invert_apply_grouping(name_grouped_isvalid_unflat_list, name_groupxs)
return featflag_list
def define_named_aid_cfgs():
"""
Definitions for common aid configurations
TODO: potentially move to experiment configs
"""
from ibeis.expt import annotation_configs
named_defaults_dict = ut.dict_take(annotation_configs.__dict__, annotation_configs.TEST_NAMES)
named_qcfg_defaults = dict(zip(annotation_configs.TEST_NAMES, ut.get_list_column(named_defaults_dict, "qcfg")))
named_dcfg_defaults = dict(zip(annotation_configs.TEST_NAMES, ut.get_list_column(named_defaults_dict, "dcfg")))
alias_keys = annotation_configs.alias_keys
named_cfg_dict = {"qcfg": named_qcfg_defaults, "dcfg": named_dcfg_defaults}
return named_cfg_dict, alias_keys
def define_named_aid_cfgs():
"""
Definitions for common aid configurations
TODO: potentially move to experiment configs
"""
from ibeis.expt import annotation_configs
named_defaults_dict = ut.dict_take(annotation_configs.__dict__, annotation_configs.TEST_NAMES)
named_qcfg_defaults = dict(zip(annotation_configs.TEST_NAMES, ut.get_list_column(named_defaults_dict, 'qcfg')))
named_dcfg_defaults = dict(zip(annotation_configs.TEST_NAMES, ut.get_list_column(named_defaults_dict, 'dcfg')))
alias_keys = annotation_configs.alias_keys
named_cfg_dict = {
'qcfg': named_qcfg_defaults,
'dcfg': named_dcfg_defaults,
}
return named_cfg_dict, alias_keys
def get_oracle_name_decision(metatup, ibs, qaid, choicetup, oracle_method=1):
"""
Find what the correct decision should be ibs is the database we are working
with ibs_gt has pristine groundtruth
"""
if ut.VERBOSE:
print('Oracle is making decision using oracle_method=%r' % oracle_method)
if metatup is None:
print('WARNING METATUP IS NONE')
return None
MAX_LOOK = 3 # the oracle should only see what the user sees
(sorted_nids, sorted_nscore, sorted_rawscore, sorted_aids, sorted_ascores) = choicetup
(ibs_gt, aid1_to_aid2) = metatup
# Get the annotations that the user can see
aid_list2 = ut.get_list_column(sorted_aids, 0)
# Get the groundtruth name of the query
aid2_to_aid1 = ut.invert_dict(aid1_to_aid2)
qnid1 = ibs_gt.get_annot_name_rowids(aid2_to_aid1[qaid])
# Make an oracle decision by choosing a name (like a user would)
if oracle_method == 1:
chosen_names = oracle_method1(ibs_gt, ibs, qnid1, aid_list2, aid2_to_aid1, sorted_nids, MAX_LOOK)
elif oracle_method == 2:
chosen_names = oracle_method2(ibs_gt, qnid1)
else:
raise AssertionError('unknown oracle method %r' % (oracle_method,))
if ut.VERBOSE:
print('Oracle decision is chosen_names=%r' % (chosen_names,))
return chosen_names
def group_aids_by_featweight_species(ibs, aid_list, config2_=None):
""" helper
Example:
>>> # ENABLE_DOCTEST
>>> from ibeis.algo.preproc.preproc_probchip import * # NOQA
>>> import ibeis
>>> ibs = ibeis.opendb('testdb1')
>>> config2_ = None
>>> aid_list = ibs.get_valid_aids()
>>> grouped_aids, unique_species, groupxs = group_aids_by_featweight_species(ibs, aid_list, config2_)
"""
if config2_ is None:
featweight_species = ibs.cfg.featweight_cfg.featweight_species
else:
featweight_species = config2_.get('featweight_species')
assert featweight_species is not None
if featweight_species == 'uselabel':
# Use the labeled species for the detector
species_list = ibs.get_annot_species_texts(aid_list)
else:
species_list = [featweight_species]
aid_list = np.array(aid_list)
species_list = np.array(species_list)
species_rowid = np.array(ibs.get_species_rowids_from_text(species_list))
unique_species_rowids, groupxs = vtool.group_indices(species_rowid)
grouped_aids = vtool.apply_grouping(aid_list, groupxs)
grouped_species = vtool.apply_grouping(species_list, groupxs)
unique_species = ut.get_list_column(grouped_species, 0)
return grouped_aids, unique_species, groupxs
def testdb2_stuff():
"""
tar -zcvf testdb2.tar.gz testdb2/
"""
import ibeis
ibs = ibeis.opendb('testdb2')
#ibs.ensure_contributor_rowids()
gid_list = ibs.get_valid_gids()
# Group gids by species
image_species_list = ut.get_list_column(
ibs.unflat_map(ibs.get_annot_species_rowids,
ibs.get_image_aids(gid_list)), 0)
new_contributor_rowid1 = ibs.add_new_temp_contributor(
offset=len(ibs.get_valid_contributor_rowids()))
new_contributor_rowid2 = ibs.add_new_temp_contributor(
offset=len(ibs.get_valid_contributor_rowids()))
gids1, gids2 = list(ut.group_items(gid_list, image_species_list).values())
party_rowids = ibs.add_party(['TestCar1', 'TestCar2'])
partyid1, partyid2 = party_rowids
ibs.set_image_contributor_rowid(gids1,
[new_contributor_rowid1] * len(gids1))
ibs.set_image_contributor_rowid(gids2,
[new_contributor_rowid2] * len(gids2))
ibs.set_image_party_rowids(gids1, [partyid1] * len(gids1))
ibs.set_image_party_rowids(gids2, [partyid2] * len(gids2))
def testdb2_stuff():
"""
tar -zcvf testdb2.tar.gz testdb2/
"""
import ibeis
ibs = ibeis.opendb('testdb2')
#ibs.ensure_contributor_rowids()
gid_list = ibs.get_valid_gids()
# Group gids by species
image_species_list = ut.get_list_column(
ibs.unflat_map(ibs.get_annot_species_rowids, ibs.get_image_aids(gid_list)), 0)
new_contrib_rowid1 = ibs.add_new_temp_contributor(offset=len(ibs.get_valid_contrib_rowids()))
new_contrib_rowid2 = ibs.add_new_temp_contributor(offset=len(ibs.get_valid_contrib_rowids()))
gids1, gids2 = list(ut.group_items(gid_list, image_species_list).values())
party_rowids = ibs.add_party(['TestCar1', 'TestCar2'])
partyid1, partyid2 = party_rowids
ibs.set_image_contributor_rowid(gids1, [new_contrib_rowid1] * len(gids1))
ibs.set_image_contributor_rowid(gids2, [new_contrib_rowid2] * len(gids2))
ibs.set_image_party_rowids(gids1, [partyid1] * len(gids1))
ibs.set_image_party_rowids(gids2, [partyid2] * len(gids2))
def get_oracle_name_decision(metatup, ibs, qaid, choicetup, oracle_method=1):
"""
Find what the correct decision should be ibs is the database we are working
with ibs_gt has pristine groundtruth
"""
if ut.VERBOSE:
print('Oracle is making decision using oracle_method=%r' %
oracle_method)
if metatup is None:
print('WARNING METATUP IS NONE')
return None
MAX_LOOK = 3 # the oracle should only see what the user sees
(sorted_nids, sorted_nscore, sorted_rawscore, sorted_aids,
sorted_ascores) = choicetup
(ibs_gt, aid1_to_aid2) = metatup
# Get the annotations that the user can see
aid_list2 = ut.get_list_column(sorted_aids, 0)
# Get the groundtruth name of the query
aid2_to_aid1 = ut.invert_dict(aid1_to_aid2)
qnid1 = ibs_gt.get_annot_name_rowids(aid2_to_aid1[qaid])
# Make an oracle decision by choosing a name (like a user would)
if oracle_method == 1:
chosen_names = oracle_method1(ibs_gt, ibs, qnid1, aid_list2,
aid2_to_aid1, sorted_nids, MAX_LOOK)
elif oracle_method == 2:
chosen_names = oracle_method2(ibs_gt, qnid1)
else:
raise AssertionError('unknown oracle method %r' % (oracle_method, ))
if ut.VERBOSE:
print('Oracle decision is chosen_names=%r' % (chosen_names, ))
return chosen_names
def group_aids_by_featweight_species(ibs, aid_list, config2_=None):
""" helper
Example:
>>> # ENABLE_DOCTEST
>>> from ibeis.algo.preproc.preproc_probchip import * # NOQA
>>> import ibeis
>>> ibs = ibeis.opendb('testdb1')
>>> config2_ = None
>>> aid_list = ibs.get_valid_aids()
>>> grouped_aids, unique_species, groupxs = group_aids_by_featweight_species(ibs, aid_list, config2_)
"""
if config2_ is None:
featweight_species = ibs.cfg.featweight_cfg.featweight_species
else:
featweight_species = config2_.get('featweight_species')
assert featweight_species is not None
if featweight_species == 'uselabel':
# Use the labeled species for the detector
species_list = ibs.get_annot_species_texts(aid_list)
else:
species_list = [featweight_species]
aid_list = np.array(aid_list)
species_list = np.array(species_list)
species_rowid = np.array(ibs.get_species_rowids_from_text(species_list))
unique_species_rowids, groupxs = vtool.group_indices(species_rowid)
grouped_aids = vtool.apply_grouping(aid_list, groupxs)
grouped_species = vtool.apply_grouping(species_list, groupxs)
unique_species = ut.get_list_column(grouped_species, 0)
return grouped_aids, unique_species, groupxs
def draw_map_histogram(top_assignments, fnum=None, pnum=(1, 1, 1)):
import plottool as pt
bin_labels = ut.get_list_column(top_assignments, 0)
bin_vals = ut.get_list_column(top_assignments, 1)
fnum = pt.ensure_fnum(fnum)
# bin_labels = ['\n'.join(ut.textwrap.wrap(_lbl, width=30)) for _lbl in bin_labels]
pt.draw_histogram(
bin_labels,
bin_vals,
fnum=fnum,
pnum=pnum,
transpose=True,
use_darkbackground=False,
#xtick_rotation=-10,
ylabel='Prob',
xlabel='assignment')
pt.set_title('Assignment probabilities')
def _get_annot_pair_info(ibs, aid1, aid2, qreq_, draw_fmatches, **kwargs):
kpts1 = kwargs.get('kpts1', None)
kpts2 = kwargs.get('kpts2', None)
kpts2_list = None if kpts2 is None else [kpts2]
rchip1, kpts1 = get_query_annot_pair_info(ibs, aid1, qreq_, draw_fmatches,
kpts1=kpts1)
annot2_data_list = get_data_annot_pair_info(ibs, [aid2], qreq_,
draw_fmatches,
kpts2_list=kpts2_list)
rchip2, kpts2 = ut.get_list_column(annot2_data_list , 0)
return rchip1, rchip2, kpts1, kpts2
def get_aids_and_scores(qres, name_scoring=False, ibs=None):
""" returns a chip index list and associated score list """
if name_scoring:
assert ibs is not None, 'must specify ibs for name_scoring'
nscoretup = qres.get_nscoretup(ibs)
(sorted_nids, sorted_nscore, sorted_aids, sorted_scores) = nscoretup
score_arr = np.array(sorted_nscore)
aid_arr = np.array(ut.get_list_column(sorted_aids, 0))
else:
aid_arr, score_arr = qres.get_aids_and_chip_scores()
return aid_arr, score_arr
def get_aids_and_scores(qres, name_scoring=False, ibs=None):
""" returns a chip index list and associated score list """
if name_scoring:
assert ibs is not None, 'must specify ibs for name_scoring'
nscoretup = qres.get_nscoretup(ibs)
(sorted_nids, sorted_nscore, sorted_aids, sorted_scores) = nscoretup
score_arr = np.array(sorted_nscore)
aid_arr = np.array(ut.get_list_column(sorted_aids, 0))
else:
aid_arr, score_arr = qres.get_aids_and_chip_scores()
return aid_arr, score_arr
def _get_annot_pair_info(ibs, aid1, aid2, qreq_, draw_fmatches, **kwargs):
kpts1 = kwargs.get('kpts1', None)
kpts2 = kwargs.get('kpts2', None)
as_fpath = kwargs.get('as_fpath', False)
kpts2_list = None if kpts2 is None else [kpts2]
rchip1, kpts1 = get_query_annot_pair_info(
ibs, aid1, qreq_, draw_fmatches, kpts1=kpts1, as_fpath=as_fpath
)
annot2_data_list = get_data_annot_pair_info(
ibs, [aid2], qreq_, draw_fmatches, as_fpath=as_fpath, kpts2_list=kpts2_list
)
rchip2, kpts2 = ut.get_list_column(annot2_data_list, 0)
return rchip1, rchip2, kpts1, kpts2
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 setup_pzmtest_subgraph():
import ibeis
ibs = ibeis.opendb(db='PZ_MTEST')
nids = ibs.get_valid_nids()
aids_list = ibs.get_name_aids(nids)
import itertools
unflat_edges = (list(itertools.product(aids, aids)) for aids in aids_list)
aid_pairs = [tup for tup in ut.iflatten(unflat_edges) if tup[0] != tup[1]]
aids1 = ut.get_list_column(aid_pairs, 0)
aids2 = ut.get_list_column(aid_pairs, 1)
rng = np.random.RandomState(0)
flags = rng.rand(len(aids1)) > .878
aids1 = ut.compress(aids1, flags)
aids2 = ut.compress(aids2, flags)
for aid1, aid2 in zip(aids1, aids2):
ibs.set_annot_pair_as_positive_match(aid1, aid2)
ibs.set_annot_pair_as_positive_match(aid2, aid1)
rowids = ibs._get_all_annotmatch_rowids()
aids1 = ibs.get_annotmatch_aid1(rowids)
aids2 = ibs.get_annotmatch_aid2(rowids)
def setup_pzmtest_subgraph():
import ibeis
ibs = ibeis.opendb(db='PZ_MTEST')
nids = ibs.get_valid_nids()
aids_list = ibs.get_name_aids(nids)
import itertools
unflat_edges = (list(itertools.product(aids, aids)) for aids in aids_list)
aid_pairs = [tup for tup in ut.iflatten(unflat_edges) if tup[0] != tup[1]]
aids1 = ut.get_list_column(aid_pairs, 0)
aids2 = ut.get_list_column(aid_pairs, 1)
rng = np.random.RandomState(0)
flags = rng.rand(len(aids1)) > .878
aids1 = ut.compress(aids1, flags)
aids2 = ut.compress(aids2, flags)
for aid1, aid2 in zip(aids1, aids2):
ibs.set_annot_pair_as_positive_match(aid1, aid2)
ibs.set_annot_pair_as_positive_match(aid2, aid1)
rowids = ibs._get_all_annotmatch_rowids()
aids1 = ibs.get_annotmatch_aid1(rowids)
aids2 = ibs.get_annotmatch_aid2(rowids)
def compute_fgweights(ibs, aid_list, config2_=None):
"""
Example:
>>> # SLOW_DOCTEST
>>> from ibeis.algo.preproc.preproc_featweight import * # NOQA
>>> import ibeis
>>> ibs = ibeis.opendb('testdb1')
>>> aid_list = ibs.get_valid_aids()[1:2]
>>> config2_ = None
>>> featweight_list = compute_fgweights(ibs, aid_list)
>>> result = np.array_str(featweight_list[0][0:3], precision=3)
>>> print(result)
[ 0.125 0.061 0.053]
"""
nTasks = len(aid_list)
print('[preproc_featweight.compute_fgweights] Preparing to compute %d fgweights' % (nTasks,))
probchip_fpath_list = preproc_probchip.compute_and_write_probchip(ibs,
aid_list,
config2_=config2_)
chipsize_list = ibs.get_annot_chip_sizes(aid_list, config2_=config2_)
#if ut.DEBUG2:
# from PIL import Image
# probchip_size_list = [Image.open(fpath).size for fpath in probchip_fpath_list] # NOQA
# #with ut.embed_on_exception_context:
# # does not need to happen anymore
# assert chipsize_list == probchip_size_list, 'probably need to clear chip or probchip cache'
kpts_list = ibs.get_annot_kpts(aid_list, config2_=config2_)
# Force grayscale reading of chips
probchip_list = [vt.imread(fpath, grayscale=True) if exists(fpath) else None
for fpath in probchip_fpath_list]
print('[preproc_featweight.compute_fgweights] Computing %d fgweights' % (nTasks,))
arg_iter = zip(aid_list, kpts_list, probchip_list, chipsize_list)
featweight_gen = ut.generate(gen_featweight_worker, arg_iter,
nTasks=nTasks, ordered=True, freq=10)
featweight_param_list = list(featweight_gen)
#arg_iter = zip(aid_list, kpts_list, probchip_list)
#featweight_param_list1 = [gen_featweight_worker((aid, kpts, probchip)) for
#aid, kpts, probchip in arg_iter]
#featweight_aids = ut.get_list_column(featweight_param_list, 0)
featweight_list = ut.get_list_column(featweight_param_list, 1)
print('[preproc_featweight.compute_fgweights] Done computing %d fgweights' % (nTasks,))
return featweight_list
def interact(dataset, key='full', **kwargs):
"""
python -m ibeis_cnn --tf netrun --db mnist --ensuredata --show --datatype=category
python -m ibeis_cnn --tf netrun --db PZ_MTEST --acfg ctrl --ensuredata --show
"""
from ibeis_cnn import draw_results
#interact_func = draw_results.interact_siamsese_data_patches
interact_func = draw_results.interact_dataset
# Automatically infer which lazy properties are needed for the
# interaction.
kwarg_items = ut.recursive_parse_kwargs(interact_func)
kwarg_keys = ut.get_list_column(kwarg_items, 0)
interact_kw = {key_: dataset.getprop(key_)
for key_ in kwarg_keys if dataset.hasprop(key_)}
interact_kw.update(**kwargs)
# TODO : generalize
data = dataset.subset_data(key)
labels = dataset.subset_labels(key)
metadata = dataset.subset_metadata(key)
return interact_func(
labels, data, metadata, dataset._info['data_per_label'],
**interact_kw)
def group_review_submit():
"""
CommandLine:
python -m ibeis.web.app --exec-group_review_submit
Example:
>>> # UNSTABLE_DOCTEST
>>> from ibeis.web.app import * # NOQA
>>> import ibeis
>>> import ibeis.web
>>> ibs = ibeis.opendb('testdb1')
>>> aid_list = ibs.get_valid_aids()[::2]
>>> ibs.start_web_annot_groupreview(aid_list)
"""
ibs = current_app.ibs
method = request.form.get("group-review-submit", "")
if method.lower() == "populate":
redirection = request.referrer
if "prefill" not in redirection:
# Prevent multiple clears
if "?" in redirection:
redirection = "%s&prefill=true" % (redirection,)
else:
redirection = "%s?prefill=true" % (redirection,)
return redirect(redirection)
aid_list = request.form.get("aid_list", "")
if len(aid_list) > 0:
aid_list = aid_list.replace("[", "")
aid_list = aid_list.replace("]", "")
aid_list = aid_list.strip().split(",")
aid_list = [int(aid_.strip()) for aid_ in aid_list]
else:
aid_list = []
src_ag, dst_ag = ibs.prepare_annotgroup_review(aid_list)
valid_modes = ut.get_list_column(appf.VALID_TURK_MODES, 0)
mode = request.form.get("group-review-mode", None)
assert mode in valid_modes
return redirect(url_for(mode, src_ag=src_ag, dst_ag=dst_ag))
def group_review_submit():
"""
CommandLine:
python -m ibeis.web.app --exec-group_review_submit
Example:
>>> # UNSTABLE_DOCTEST
>>> from ibeis.web.app import * # NOQA
>>> import ibeis
>>> import ibeis.web
>>> ibs = ibeis.opendb('testdb1')
>>> aid_list = ibs.get_valid_aids()[::2]
>>> ibs.start_web_annot_groupreview(aid_list)
"""
ibs = current_app.ibs
method = request.form.get('group-review-submit', '')
if method.lower() == 'populate':
redirection = request.referrer
if 'prefill' not in redirection:
# Prevent multiple clears
if '?' in redirection:
redirection = '%s&prefill=true' % (redirection, )
else:
redirection = '%s?prefill=true' % (redirection, )
return redirect(redirection)
aid_list = request.form.get('aid_list', '')
if len(aid_list) > 0:
aid_list = aid_list.replace('[', '')
aid_list = aid_list.replace(']', '')
aid_list = aid_list.strip().split(',')
aid_list = [ int(aid_.strip()) for aid_ in aid_list ]
else:
aid_list = []
src_ag, dst_ag = ibs.prepare_annotgroup_review(aid_list)
valid_modes = ut.get_list_column(appf.VALID_TURK_MODES, 0)
mode = request.form.get('group-review-mode', None)
assert mode in valid_modes
return redirect(url_for(mode, src_ag=src_ag, dst_ag=dst_ag))
def compute_and_write_chips_lazy(ibs, aid_list, config2_=None):
r"""
Spanws compute chip procesess if a chip does not exist on disk
DEPRICATE
This is regardless of if it exists in the SQL database
Args:
ibs (IBEISController):
aid_list (list):
"""
if ut.VERBOSE:
print("[preproc_chip] compute_and_write_chips_lazy")
# Mark which aid's need their chips computed
cfpath_list = make_annot_chip_fpath_list(ibs, aid_list, config2_=config2_)
missing_flags = [not exists(cfpath) for cfpath in cfpath_list]
invalid_aids = ut.compress(aid_list, missing_flags)
if ut.VERBOSE:
print("[preproc_chip] %d / %d chips need to be computed" % (len(invalid_aids), len(aid_list)))
chip_result_list = list(compute_and_write_chips(ibs, invalid_aids))
chip_fpath_list = ut.get_list_column(chip_result_list, 0)
return chip_fpath_list
def convert_name_suggestion_to_aids(ibs, choicetup, name_suggest_tup):
"""
Example:
>>> # DISABLE_DOCTEST
>>> from ibeis.algo.hots.user_dialogs import * # NOQA
>>> import ibeis
>>> # build test data
>>> ibs = ibeis.opendb('testdb1')
>>> comp_aids = [2, 3, 4]
>>> comp_names = ['fred', 'sue', 'alice']
>>> chosen_names = ['fred']
>>> # execute function
>>> result = convert_name_suggestion_to_aids(ibs, choicetup, name_suggest_tup)
>>> # verify results
>>> print(result)
"""
num_top = 3
autoname_msg, chosen_names, name_confidence = name_suggest_tup
comp_aids_all = ut.get_list_column(choicetup.sorted_aids, 0)
comp_aids = ut.listclip(comp_aids_all, num_top)
comp_names = ibs.get_annot_names(comp_aids)
issuggested = ut.list_cover(comp_names, chosen_names)
suggest_aids = ut.compress(comp_aids, issuggested)
return comp_aids, suggest_aids
def compute_and_write_chips_lazy(ibs, aid_list, config2_=None):
r"""
Spanws compute chip procesess if a chip does not exist on disk
DEPRICATE
This is regardless of if it exists in the SQL database
Args:
ibs (IBEISController):
aid_list (list):
"""
if ut.VERBOSE:
print('[preproc_chip] compute_and_write_chips_lazy')
# Mark which aid's need their chips computed
cfpath_list = make_annot_chip_fpath_list(ibs, aid_list, config2_=config2_)
missing_flags = [not exists(cfpath) for cfpath in cfpath_list]
invalid_aids = ut.compress(aid_list, missing_flags)
if ut.VERBOSE:
print('[preproc_chip] %d / %d chips need to be computed' %
(len(invalid_aids), len(aid_list)))
chip_result_list = list(compute_and_write_chips(ibs, invalid_aids))
chip_fpath_list = ut.get_list_column(chip_result_list, 0)
return chip_fpath_list
def testdata_aids(defaultdb=None, a=None, adefault='default', ibs=None,
return_acfg=False, verbose=None, default_aids=None):
r"""
Grabs default testdata for functions, but is command line overrideable
CommandLine:
python -m ibeis --tf testdata_aids --verbtd --db PZ_ViewPoints
python -m ibeis --tf testdata_aids --verbtd --db NNP_Master3 -a is_known=True,view_pername='#primary>0&#primary1>=1'
python -m ibeis --tf testdata_aids --verbtd --db PZ_Master1 -a default:is_known=True,view_pername='#primary>0&#primary1>=1'
python -m ibeis --tf testdata_aids --verbtd --db PZ_Master1 -a default:species=primary,minqual=ok --verbtd
python -m ibeis.other.dbinfo --test-latex_dbstats --dblist
CommandLine:
python -m ibeis.init.main_helpers --exec-testdata_aids --show
Example:
>>> # ENABLE_DOCTEST
>>> from ibeis.init.main_helpers import * # NOQA
>>> from ibeis.expt import annotation_configs
>>> import ibeis
>>> #ibs = ibeis.opendb(defaultdb='PZ_ViewPoints')
>>> ibs = ibeis.opendb(defaultdb='testdb1')
>>> a = None
>>> adefault = 'default:is_known=True'
>>> aids, aidcfg = testdata_aids(ibs=ibs, a=a, adefault=adefault, return_acfg=True)
>>> print('\n RESULT:')
>>> annotation_configs.print_acfg(aidcfg, aids, ibs, per_name_vpedge=None)
"""
from ibeis.init import filter_annots
from ibeis.expt import annotation_configs
from ibeis.expt import cfghelpers
import ibeis
print('[main_helpers] testdata_aids')
if a is None:
a = adefault
a, _specified_a = ut.get_argval(('--aidcfg', '--acfg', '-a'), type_=str, default=a, return_was_specified=True)
return_ibs = False
if ibs is None:
return_ibs = True
if defaultdb is None:
defaultdb = 'testdb1'
ibs = ibeis.opendb(defaultdb=defaultdb)
named_defaults_dict = ut.dict_take(annotation_configs.__dict__,
annotation_configs.TEST_NAMES)
named_qcfg_defaults = dict(zip(annotation_configs.TEST_NAMES,
ut.get_list_column(named_defaults_dict, 'qcfg')))
# Allow command line override
aids, _specified_aids = ut.get_argval(('--aid', '--aids'), type_=list,
default=default_aids,
return_was_specified=True)
aidcfg = None
have_aids = aids is not None
need_expand = (not have_aids) or (_specified_a and not _specified_aids)
#(not aid) or (sa and (not said))
if need_expand:
#base_cfg = annotation_configs.single_default
aidcfg_combo_list = cfghelpers.parse_cfgstr_list2(
[a], named_qcfg_defaults, 'acfg', annotation_configs.ALIAS_KEYS,
expand_nested=False, is_nestedcfgtype=False)
aidcfg_combo = aidcfg_combo_list[0]
if len(aidcfg_combo_list) != 1:
raise AssertionError('Error: combinations not handled for single cfg setting')
if len(aidcfg_combo) != 1:
raise AssertionError('Error: combinations not handled for single cfg setting')
aidcfg = aidcfg_combo[0]
aids = filter_annots.expand_single_acfg(ibs, aidcfg, verbose=verbose)
if return_ibs:
return ibs, aids
if return_acfg:
return aids, aidcfg
else:
return aids
def get_node_viz_attrs(model, evidence, soft_evidence, factor_list,
ttype_colors, **kwargs):
import plottool as pt
var2_post = {f.variables[0]: f for f in factor_list}
pos_dict = get_bayesnet_layout(model)
#pos_dict = nx.pygraphviz_layout(netx_graph)
#pos_dict = nx.pydot_layout(netx_graph, prog='dot')
#pos_dict = nx.graphviz_layout(netx_graph)
netx_nodes = model.nodes(data=True)
node_key_list = ut.get_list_column(netx_nodes, 0)
pos_list = ut.dict_take(pos_dict, node_key_list)
prior_text = None
post_text = None
evidence_tas = []
post_tas = []
prior_tas = []
node_color = []
has_infered = evidence or var2_post
if has_infered:
ignore_prior_with_ttype = ['score', 'match']
show_prior = False
else:
ignore_prior_with_ttype = []
#show_prior = True
show_prior = False
dpy = 5
dbx, dby = (20, 20)
takw1 = {
'bbox_align': (.5, 0),
'pos_offset': [0, dpy],
'bbox_offset': [dbx, dby]
}
takw2 = {
'bbox_align': (.5, 1),
'pos_offset': [0, -dpy],
'bbox_offset': [-dbx, -dby]
}
def get_name_color(phi):
order = phi.values.argsort()[::-1]
if len(order) < 2:
dist_next = phi.values[order[0]]
else:
dist_next = phi.values[order[0]] - phi.values[order[1]]
dist_total = (phi.values[order[0]])
confidence = (dist_total * dist_next)**(2.5 / 4)
#print('confidence = %r' % (confidence,))
color = ttype_colors['name'][order[0]]
color = pt.color_funcs.desaturate_rgb(color, 1 - confidence)
color = np.array(color)
return color
for node, pos in zip(netx_nodes, pos_list):
variable = node[0]
cpd = model.var2_cpd[variable]
prior_marg = (cpd if cpd.evidence is None else cpd.marginalize(
cpd.evidence, inplace=False))
show_evidence = variable in evidence
show_prior = cpd.ttype not in ignore_prior_with_ttype
show_post = variable in var2_post
show_prior |= cpd.ttype not in ignore_prior_with_ttype
show_prior &= kwargs.get('show_prior', True)
post_marg = None
if show_post:
post_marg = var2_post[variable]
if variable in evidence:
if cpd.ttype == 'score':
color = ttype_colors['score'][evidence[variable]]
color = np.array(color)
node_color.append(color)
elif cpd.ttype == 'name':
color = ttype_colors['name'][evidence[variable]]
color = np.array(color)
node_color.append(color)
else:
color = pt.FALSE_RED
node_color.append(color)
#elif variable in soft_evidence:
# color = pt.LIGHT_PINK
# show_prior = True
# color = get_name_color(prior_marg)
# node_color.append(color)
else:
if cpd.ttype == 'name' and post_marg is not None:
color = get_name_color(post_marg)
node_color.append(color)
elif cpd.ttype == 'match' and post_marg is not None:
# color = cmap(post_marg.values[1])
# color = pt.lighten_rgb(color, .4)
# color = np.array(color)
color = pt.NEUTRAL
color = pt.LIGHT_PINK
node_color.append(color)
else:
#color = pt.WHITE
color = pt.NEUTRAL
node_color.append(color)
if show_prior:
if variable in soft_evidence:
prior_color = pt.LIGHT_PINK
else:
prior_color = None
prior_text = make_factor_text(prior_marg, 'prior')
prior_tas.append(
dict(text=prior_text, pos=pos, color=prior_color, **takw2))
if show_evidence:
_takw1 = takw1
if cpd.ttype == 'score':
_takw1 = takw2
evidence_text = cpd.variable_statenames[evidence[variable]]
if isinstance(evidence_text, int):
evidence_text = '%d/%d' % (evidence_text + 1,
cpd.variable_card)
evidence_tas.append(
dict(text=evidence_text, pos=pos, color=color, **_takw1))
if show_post:
_takw1 = takw1
if cpd.ttype == 'match':
_takw1 = takw2
post_text = make_factor_text(post_marg, 'post')
post_tas.append(dict(text=post_text, pos=pos, color=None,
**_takw1))
def trnps_(dict_list):
""" tranpose dict list """
list_dict = ut.ddict(list)
for dict_ in dict_list:
for key, val in dict_.items():
list_dict[key + '_list'].append(val)
return list_dict
takw1_ = trnps_(post_tas + evidence_tas)
takw2_ = trnps_(prior_tas)
takws = [takw1_, takw2_]
return node_color, pos_list, pos_dict, takws
#ut.spawn_delayed_ipython_paste()
ut.embed(remove_pyqt_hook=False)
IPYTHON_COMMANDS
testcases[case].append(testtup)
for qaid in six.iterkeys(qaid2_qres_vsmany):
qres_vsmany = qaid2_qres_vsmany[qaid]
qres_vsone = qaid2_qres_vsone[qaid]
nscoretup_vsone = qres_vsone.get_nscoretup()
nscoretup_vsmany = qres_vsmany.get_nscoretup()
metatup = incinfo['metatup']
ibs_gt, aid1_to_aid2 = metatup
aid2_to_aid1 = ut.invert_dict(aid1_to_aid2)
top_aids_vsone = ut.get_list_column(nscoretup_vsone.sorted_aids, 0)
top_aids_vsmany = ut.get_list_column(nscoretup_vsmany.sorted_aids, 0)
# tranform to groundtruth database coordinates
all_daids_t = ut.dict_take_list(aid2_to_aid1, daids)
top_aids_vsone_t = ut.dict_take_list(aid2_to_aid1, top_aids_vsone)
top_aids_vsmany_t = ut.dict_take_list(aid2_to_aid1, top_aids_vsmany)
qaid_t = aid2_to_aid1[qaid]
aids_tup = (
all_daids_t,
top_aids_vsone_t,
top_aids_vsmany_t,
(qaid_t, ),
)
nids_tup = ibs_gt.unflat_map(ibs_gt.get_annot_nids, aids_tup)
(
def query_vsone_pairs(ibs,
vsone_query_pairs,
use_cache=False,
save_qcache=False):
"""
does vsone queries to rerank the top few vsmany querys
Returns:
tuple: qaid2_qres_vsone, qreq_vsone_
CommandLine:
python -m ibeis.algo.hots.special_query --test-query_vsone_pairs
Example:
>>> # SLOW_DOCTEST
>>> from ibeis.algo.hots.special_query import * # NOQA
>>> ibs, valid_aids = testdata_special_query()
>>> qaids = valid_aids[0:1]
>>> daids = valid_aids[1:]
>>> qaid = qaids[0]
>>> filtkey = hstypes.FiltKeys.DISTINCTIVENESS
>>> use_cache = False
>>> save_qcache = False
>>> # execute function
>>> qaid2_qres_vsmany, qreq_vsmany_ = query_vsmany_initial(ibs, qaids, daids)
>>> vsone_query_pairs = build_vsone_shortlist(ibs, qaid2_qres_vsmany)
>>> qaid2_qres_vsone, qreq_vsone_ = query_vsone_pairs(ibs, vsone_query_pairs)
>>> qres_vsone = qaid2_qres_vsone[qaid]
>>> top_namescore_aids = qres_vsone.get_top_aids().tolist()
>>> result = str(top_namescore_aids)
>>> top_namescore_names = ibs.get_annot_names(top_namescore_aids)
>>> assert top_namescore_names[0] == 'easy', 'top_namescore_names[0]=%r' % (top_namescore_names[0],)
"""
#vsone_cfgdict = dict(codename='vsone_unnorm')
#codename = 'vsone_unnorm_dist_ratio_extern_distinctiveness',
codename = 'vsone_unnorm_dist_ratio'
vsone_cfgdict = dict(
index_method='single',
codename=codename,
)
#------------------------
qaid2_qres_vsone = {}
for qaid, top_aids in vsone_query_pairs:
# Perform a query request for each
cm_list_vsone_, __qreq_vsone_ = ibs.query_chips(
[qaid],
top_aids,
cfgdict=vsone_cfgdict,
return_request=True,
use_cache=use_cache,
save_qcache=save_qcache)
qaid2_qres_vsone_ = {cm.qaid: cm for cm in cm_list_vsone_}
qaid2_qres_vsone.update(qaid2_qres_vsone_)
#------------------------
# Create pseudo query request because there is no good way to
# represent the vsone reranking as a single query request and
# we need one for the score normalizer
#pseudo_codename_ = codename.replace('unnorm', 'norm') + '_extern_distinctiveness'
pseudo_codename_ = codename.replace('unnorm',
'norm') # + '_extern_distinctiveness'
pseudo_vsone_cfgdict = dict(codename=pseudo_codename_)
pseudo_qaids = ut.get_list_column(vsone_query_pairs, 0)
pseudo_daids = ut.unique_ordered(
ut.flatten(ut.get_list_column(vsone_query_pairs, 1)))
# FIXME: making the pseudo qreq_ takes a nontrivial amount of time for what
# should be a trivial task.
pseudo_qreq_vsone_ = ibs.new_query_request(pseudo_qaids,
pseudo_daids,
cfgdict=pseudo_vsone_cfgdict,
verbose=ut.VERBOSE)
#pseudo_qreq_vsone_.load_distinctiveness_normalizer()
qreq_vsone_ = pseudo_qreq_vsone_
# Hack in a special config name
qreq_vsone_.qparams.query_cfgstr = '_special' + qreq_vsone_.qparams.query_cfgstr
return qaid2_qres_vsone, qreq_vsone_
def show_model(model, evidence={}, soft_evidence={}, **kwargs):
"""
References:
http://stackoverflow.com/questions/22207802/pygraphviz-networkx-set-node-level-or-layer
Ignore:
pkg-config --libs-only-L libcgraph
sudo apt-get install libgraphviz-dev -y
sudo apt-get install libgraphviz4 -y
# sudo apt-get install pkg-config
sudo apt-get install libgraphviz-dev
# pip install git+git://github.com/pygraphviz/pygraphviz.git
pip install pygraphviz
python -c "import pygraphviz; print(pygraphviz.__file__)"
sudo pip3 install pygraphviz --install-option="--include-path=/usr/include/graphviz" --install-option="--library-path=/usr/lib/graphviz/"
python3 -c "import pygraphviz; print(pygraphviz.__file__)"
CommandLine:
python -m ibeis.algo.hots.bayes --exec-show_model --show
Example:
>>> # DISABLE_DOCTEST
>>> from ibeis.algo.hots.bayes import * # NOQA
>>> model = '?'
>>> evidence = {}
>>> soft_evidence = {}
>>> result = show_model(model, evidence, soft_evidence)
>>> print(result)
>>> ut.quit_if_noshow()
>>> import plottool as pt
>>> ut.show_if_requested()
"""
if ut.get_argval('--hackmarkov') or ut.get_argval('--hackjunc'):
draw_tree_model(model, **kwargs)
return
import plottool as pt
import networkx as netx
fnum = pt.ensure_fnum(None)
netx_graph = (model)
#netx_graph.graph.setdefault('graph', {})['size'] = '"10,5"'
#netx_graph.graph.setdefault('graph', {})['rankdir'] = 'LR'
pos_dict = get_hacked_pos(netx_graph)
#pos_dict = netx.pygraphviz_layout(netx_graph)
#pos = netx.pydot_layout(netx_graph, prog='dot')
#pos_dict = netx.graphviz_layout(netx_graph)
textprops = {
'family': 'monospace',
'horizontalalignment': 'left',
#'horizontalalignment': 'center',
#'size': 12,
'size': 8,
}
netx_nodes = model.nodes(data=True)
node_key_list = ut.get_list_column(netx_nodes, 0)
pos_list = ut.dict_take(pos_dict, node_key_list)
var2_post = {f.variables[0]: f for f in kwargs.get('factor_list', [])}
prior_text = None
post_text = None
evidence_tas = []
post_tas = []
prior_tas = []
node_color = []
has_infered = evidence or var2_post
if has_infered:
ignore_prior_with_ttype = ['score', 'match']
show_prior = False
else:
ignore_prior_with_ttype = []
#show_prior = True
show_prior = False
dpy = 5
dbx, dby = (20, 20)
takw1 = {'bbox_align': (.5, 0), 'pos_offset': [0, dpy], 'bbox_offset': [dbx, dby]}
takw2 = {'bbox_align': (.5, 1), 'pos_offset': [0, -dpy], 'bbox_offset': [-dbx, -dby]}
name_colors = pt.distinct_colors(max(model.num_names, 10))
name_colors = name_colors[:model.num_names]
#cmap_ = 'hot' #mx = 0.65 #mn = 0.15
cmap_, mn, mx = 'plasma', 0.15, 1.0
_cmap = pt.plt.get_cmap(cmap_)
def cmap(x):
return _cmap((x * mx) + mn)
for node, pos in zip(netx_nodes, pos_list):
variable = node[0]
cpd = model.var2_cpd[variable]
prior_marg = (cpd if cpd.evidence is None else
cpd.marginalize(cpd.evidence, inplace=False))
show_evidence = variable in evidence
show_prior = cpd.ttype not in ignore_prior_with_ttype
show_post = variable in var2_post
show_prior |= cpd.ttype not in ignore_prior_with_ttype
post_marg = None
if show_post:
post_marg = var2_post[variable]
def get_name_color(phi):
order = phi.values.argsort()[::-1]
if len(order) < 2:
dist_next = phi.values[order[0]]
else:
dist_next = phi.values[order[0]] - phi.values[order[1]]
dist_total = (phi.values[order[0]])
confidence = (dist_total * dist_next) ** (2.5 / 4)
#print('confidence = %r' % (confidence,))
color = name_colors[order[0]]
color = pt.color_funcs.desaturate_rgb(color, 1 - confidence)
color = np.array(color)
return color
if variable in evidence:
if cpd.ttype == 'score':
cmap_index = evidence[variable] / (cpd.variable_card - 1)
color = cmap(cmap_index)
color = pt.lighten_rgb(color, .4)
color = np.array(color)
node_color.append(color)
elif cpd.ttype == 'name':
color = name_colors[evidence[variable]]
color = np.array(color)
node_color.append(color)
else:
color = pt.FALSE_RED
node_color.append(color)
#elif variable in soft_evidence:
# color = pt.LIGHT_PINK
# show_prior = True
# color = get_name_color(prior_marg)
# node_color.append(color)
else:
if cpd.ttype == 'name' and post_marg is not None:
color = get_name_color(post_marg)
node_color.append(color)
elif cpd.ttype == 'match' and post_marg is not None:
color = cmap(post_marg.values[1])
color = pt.lighten_rgb(color, .4)
color = np.array(color)
node_color.append(color)
else:
#color = pt.WHITE
color = pt.NEUTRAL
node_color.append(color)
if show_prior:
if variable in soft_evidence:
prior_color = pt.LIGHT_PINK
else:
prior_color = None
prior_text = pgm_ext.make_factor_text(prior_marg, 'prior')
prior_tas.append(dict(text=prior_text, pos=pos, color=prior_color, **takw2))
if show_evidence:
_takw1 = takw1
if cpd.ttype == 'score':
_takw1 = takw2
evidence_text = cpd.variable_statenames[evidence[variable]]
if isinstance(evidence_text, int):
evidence_text = '%d/%d' % (evidence_text + 1, cpd.variable_card)
evidence_tas.append(dict(text=evidence_text, pos=pos, color=color, **_takw1))
if show_post:
_takw1 = takw1
if cpd.ttype == 'match':
_takw1 = takw2
post_text = pgm_ext.make_factor_text(post_marg, 'post')
post_tas.append(dict(text=post_text, pos=pos, color=None, **_takw1))
def trnps_(dict_list):
""" tranpose dict list """
list_dict = ut.ddict(list)
for dict_ in dict_list:
for key, val in dict_.items():
list_dict[key + '_list'].append(val)
return list_dict
takw1_ = trnps_(post_tas + evidence_tas)
takw2_ = trnps_(prior_tas)
# Draw graph
if has_infered:
pnum1 = (3, 1, (slice(0, 2), 0))
else:
pnum1 = None
fig = pt.figure(fnum=fnum, pnum=pnum1, doclf=True) # NOQA
ax = pt.gca()
#print('node_color = %s' % (ut.repr3(node_color),))
drawkw = dict(pos=pos_dict, ax=ax, with_labels=True, node_size=1500,
node_color=node_color)
netx.draw(netx_graph, **drawkw)
hacks = []
if len(post_tas + evidence_tas):
hacks.append(pt.draw_text_annotations(textprops=textprops, **takw1_))
if prior_tas:
hacks.append(pt.draw_text_annotations(textprops=textprops, **takw2_))
xmin, ymin = np.array(pos_list).min(axis=0)
xmax, ymax = np.array(pos_list).max(axis=0)
num_annots = len(model.ttype2_cpds['name'])
if num_annots > 4:
ax.set_xlim((xmin - 40, xmax + 40))
ax.set_ylim((ymin - 50, ymax + 50))
fig.set_size_inches(30, 7)
else:
ax.set_xlim((xmin - 42, xmax + 42))
ax.set_ylim((ymin - 50, ymax + 50))
fig.set_size_inches(23, 7)
fig = pt.gcf()
title = 'num_names=%r, num_annots=%r' % (model.num_names, num_annots,)
map_assign = kwargs.get('map_assign', None)
top_assignments = kwargs.get('top_assignments', None)
if top_assignments is not None:
map_assign, map_prob = top_assignments[0]
if map_assign is not None:
def word_insert(text):
return '' if len(text) == 0 else text + ' '
title += '\n%sMAP: ' % (word_insert(kwargs.get('method', '')))
title += map_assign + ' @' + '%.2f%%' % (100 * map_prob,)
if kwargs.get('show_title', True):
pt.set_figtitle(title, size=14)
for hack in hacks:
hack()
# Hack in colorbars
if has_infered:
pt.colorbar(np.linspace(0, 1, len(name_colors)), name_colors, lbl='name',
ticklabels=model.ttype2_template['name'].basis, ticklocation='left')
basis = model.ttype2_template['score'].basis
scalars = np.linspace(0, 1, len(basis))
scalars = np.linspace(0, 1, 100)
colors = pt.scores_to_color(scalars, cmap_=cmap_, reverse_cmap=False,
cmap_range=(mn, mx))
colors = [pt.lighten_rgb(c, .4) for c in colors]
if ut.list_type(basis) is int:
pt.colorbar(scalars, colors, lbl='score', ticklabels=np.array(basis) + 1)
else:
pt.colorbar(scalars, colors, lbl='score', ticklabels=basis)
#print('basis = %r' % (basis,))
# Draw probability hist
if has_infered and top_assignments is not None:
bin_labels = ut.get_list_column(top_assignments, 0)
bin_vals = ut.get_list_column(top_assignments, 1)
# bin_labels = ['\n'.join(ut.textwrap.wrap(_lbl, width=30)) for _lbl in bin_labels]
pt.draw_histogram(bin_labels, bin_vals, fnum=fnum, pnum=(3, 8, (2, slice(4, None))),
transpose=True,
use_darkbackground=False,
#xtick_rotation=-10,
ylabel='Prob', xlabel='assignment')
pt.set_title('Assignment probabilities')
def get_toy_data_1vM(num_annots, num_names=None, **kwargs):
r"""
Args:
num_annots (int):
num_names (int): (default = None)
Kwargs:
initial_aids, initial_nids, nid_sequence, seed
Returns:
tuple: (pair_list, feat_list)
CommandLine:
python -m ibeis.algo.hots.demobayes --exec-get_toy_data_1vM --show
Example:
>>> # DISABLE_DOCTEST
>>> from ibeis.algo.hots.demobayes import * # NOQA
>>> num_annots = 1000
>>> num_names = 40
>>> get_toy_data_1vM(num_annots, num_names)
>>> ut.quit_if_noshow()
>>> import plottool as pt
>>> ut.show_if_requested()
"""
import vtool as vt
tup_ = get_toy_annots(num_annots, num_names, **kwargs)
aids, nids, aids1, nids1, all_aids, all_nids = tup_
rng = vt.ensure_rng(None)
# Test a simple SVM classifier
nid2_nexemp = ut.dict_hist(nids1)
aid2_nid = dict(zip(aids, nids))
ut.fix_embed_globals()
#def add_to_globals(globals_, subdict):
# globals_.update(subdict)
unique_nids = list(nid2_nexemp.keys())
def annot_to_class_feats2(aid, aid2_nid, top=None):
pair_list = []
score_list = []
nexemplar_list = []
for nid in unique_nids:
label = (aid2_nid[aid] == nid)
num_exemplars = nid2_nexemp.get(nid, 0)
if num_exemplars == 0:
continue
params = toy_params[label]
mu, sigma = ut.dict_take(params, ['mu', 'sigma'])
score_ = rng.normal(mu, sigma, size=num_exemplars).max()
score = np.clip(score_, 0, np.inf)
pair_list.append((aid, nid))
score_list.append(score)
nexemplar_list.append(num_exemplars)
rank_list = ut.argsort(score_list, reverse=True)
feat_list = np.array([score_list, rank_list, nexemplar_list]).T
sortx = np.argsort(rank_list)
feat_list = feat_list.take(sortx, axis=0)
pair_list = np.array(pair_list).take(sortx, axis=0)
if top is not None:
feat_list = feat_list[:top]
pair_list = pair_list[0:top]
return pair_list, feat_list
toclass_features = [
annot_to_class_feats2(aid, aid2_nid, top=5) for aid in aids
]
aidnid_pairs = np.vstack(ut.get_list_column(toclass_features, 0))
feat_list = np.vstack(ut.get_list_column(toclass_features, 1))
score_list = feat_list.T[0:1].T
lbl_list = [aid2_nid[aid] == nid for aid, nid in aidnid_pairs]
from sklearn import svm
#clf1 = svm.LinearSVC()
print('Learning classifiers')
clf3 = svm.SVC(probability=True)
clf3.fit(feat_list, lbl_list)
#prob_true, prob_false = clf3.predict_proba(feat_list).T
clf1 = svm.LinearSVC()
clf1.fit(score_list, lbl_list)
# Score new annots against the training database
tup_ = get_toy_annots(num_annots * 2,
num_names,
initial_aids=all_aids,
initial_nids=all_nids)
aids, nids, aids1, nids1, all_aids, all_nids = tup_
aid2_nid = dict(zip(aids, nids))
toclass_features = [annot_to_class_feats2(aid, aid2_nid) for aid in aids]
aidnid_pairs = np.vstack(ut.get_list_column(toclass_features, 0))
feat_list = np.vstack(ut.get_list_column(toclass_features, 1))
lbl_list = np.array([aid2_nid[aid] == nid for aid, nid in aidnid_pairs])
print('Running tests')
score_list = feat_list.T[0:1].T
tp_feat_list = feat_list[lbl_list]
tn_feat_list = feat_list[~lbl_list]
tp_lbls = lbl_list[lbl_list]
tn_lbls = lbl_list[~lbl_list]
print('num tp: %d' % len(tp_lbls))
print('num fp: %d' % len(tn_lbls))
tp_score_list = score_list[lbl_list]
tn_score_list = score_list[~lbl_list]
print('tp_feat' +
ut.repr3(ut.get_stats(tp_feat_list, axis=0), precision=2))
print('tp_feat' +
ut.repr3(ut.get_stats(tn_feat_list, axis=0), precision=2))
print('tp_score' + ut.repr2(ut.get_stats(tp_score_list), precision=2))
print('tp_score' + ut.repr2(ut.get_stats(tn_score_list), precision=2))
tp_pred3 = clf3.predict(tp_feat_list)
tn_pred3 = clf3.predict(tn_feat_list)
print((tp_pred3.sum(), tp_pred3.shape))
print((tn_pred3.sum(), tn_pred3.shape))
tp_score3 = clf3.score(tp_feat_list, tp_lbls)
tn_score3 = clf3.score(tn_feat_list, tn_lbls)
tp_pred1 = clf1.predict(tp_score_list)
tn_pred1 = clf1.predict(tn_score_list)
print((tp_pred1.sum(), tp_pred1.shape))
print((tn_pred1.sum(), tn_pred1.shape))
tp_score1 = clf1.score(tp_score_list, tp_lbls)
tn_score1 = clf1.score(tn_score_list, tn_lbls)
print('tp score with rank = %r' % (tp_score3, ))
print('tn score with rank = %r' % (tn_score3, ))
print('tp score without rank = %r' % (tp_score1, ))
print('tn score without rank = %r' % (tn_score1, ))
toy_data = {}
return toy_data
def load_named_config(cfgname, dpath, use_config_cache=False,
verbose=ut.VERBOSE and ut.NOT_QUIET):
""" hack 12-30-2014
Args:
cfgname (str):
dpath (str):
use_config_cache (bool):
Returns:
Config: cfg
CommandLine:
python -m ibeis.algo.Config --test-load_named_config
Example:
>>> # DISABLE_DOCTEST
>>> from ibeis.algo.Config import * # NOQA
>>> from ibeis.algo.Config import _default_config # NOQA
>>> import ibeis
>>> ibs = ibeis.opendb('PZ_Master0')
>>> #ibs.cfg.save()
>>> # build test data
>>> cfgname = 'zebra_plains'
>>> dpath = ibs.get_dbdir()
>>> use_config_cache = True
>>> # execute function
>>> cfg = load_named_config(cfgname, dpath, use_config_cache)
>>> #
>>> keys1 = ut.get_list_column(cfg.parse_items(), 0)
>>> keys2 = ut.get_list_column(ibs.cfg.parse_items(), 0)
>>> symdiff = set(keys1) ^ set(keys2)
>>> # verify results
>>> result = str(cfg)
>>> print(result)
"""
if cfgname is None:
# TODO: find last cfgname
cfgname = 'cfg'
fpath = join(dpath, cfgname) + '.cPkl'
if verbose:
print('[Config] loading named config fpath=%r' % (fpath,))
# Always a fresh object
cfg = GenericConfig(cfgname, fpath=fpath)
try:
# Use pref cache
if not use_config_cache:
raise Exception('force config cache miss')
# Get current "schema"
tmp = _default_config(cfg, cfgname, new=True)
current_itemset = tmp.parse_items()
current_keyset = list(ut.get_list_column(current_itemset, 0))
# load saved preferences
cfg.load()
# Check if loaded schema has changed
loaded_keyset = list(ut.get_list_column(cfg.parse_items(), 0))
missing_keys = set(current_keyset) - set(loaded_keyset)
if len(missing_keys) != 0:
# Bring over new values into old structure
tmp.update(**dict(cfg.parse_items()))
cfg = tmp
#missing_vals = ut.dict_take(dict(current_itemset), missing_keys)
#def find_cfgkey_parent(tmp, key):
# subconfig_list = []
# for attr in dir(tmp):
# if attr == key:
# return tmp
# child = getattr(tmp, attr)
# if isinstance(child, ConfigBase):
# subconfig_list.append(child)
# for subconfig in subconfig_list:
# found = find_cfgkey_parent(subconfig, key)
# if found is not None:
# return found
#missing_parents = [find_cfgkey_parent(tmp, key) for key in missing_keys]
#for parent, key, val in zip(missing_parents, missing_keys, missing_vals):
# setattr(parent, key, val)
# # TODO: Finishme update the out of data preferences
# pass
if verbose:
print('[Config] successfully loaded config cfgname=%r' % (cfgname,))
except Exception as ex:
if ut.VERBOSE:
ut.printex(ex, iswarning=True)
# Totally new completely default preferences
cfg = _default_config(cfg, cfgname)
# Hack in cfgname
if verbose:
print('[Config] hack in z_cfgname=%r' % (cfgname,))
cfg.z_cfgname = cfgname
return cfg
def check_results(ibs_gt, ibs2, aid1_to_aid2, aids_list1_, incinfo):
"""
reports how well the incremental query ran when the oracle was calling the
shots.
"""
print('--------- CHECKING RESULTS ------------')
testcases = incinfo.get('testcases')
if testcases is not None:
count_dict = ut.count_dict_vals(testcases)
print('+--')
#print(ut.dict_str(testcases))
print('---')
print(ut.dict_str(count_dict))
print('L__')
# TODO: dont include initially added aids in the result reporting
aid_list1 = aids_list1_ # ibs_gt.get_valid_aids()
#aid_list1 = ibs_gt.get_aids_with_groundtruth()
aid_list2 = ibs2.get_valid_aids()
nid_list1 = ibs_gt.get_annot_nids(aid_list1)
nid_list2 = ibs2.get_annot_nids(aid_list2)
# Group annotations from test and gt database by their respective names
grouped_dict1 = ut.group_items(aid_list1, nid_list1)
grouped_dict2 = ut.group_items(aid_list2, nid_list2)
grouped_aids1 = list(six.itervalues(grouped_dict1))
grouped_aids2 = list(map(tuple, six.itervalues(grouped_dict2)))
#group_nids1 = list(six.iterkeys(grouped_dict1))
#group_nids2 = list(six.iterkeys(grouped_dict2))
# Transform annotation ids from database1 space to database2 space
grouped_aids1_t = [tuple(ut.dict_take_list(aid1_to_aid2, aids1)) for aids1 in grouped_aids1]
set_grouped_aids1_t = set(grouped_aids1_t)
set_grouped_aids2 = set(grouped_aids2)
# Find names we got right. (correct groupings of annotations)
# these are the annotation groups that are intersecting between
# the test database and groundtruth database
perfect_groups = set_grouped_aids2.intersection(set_grouped_aids1_t)
# Find names we got wrong. (incorrect groupings of annotations)
# The test database sets that were not perfect
nonperfect_groups = set_grouped_aids2.difference(perfect_groups)
# What we should have got
# The ground truth database sets that were not fully identified
missed_groups = set_grouped_aids1_t.difference(perfect_groups)
# Mark non perfect groups by their error type
false_negative_groups = [] # failed to link enough
false_positive_groups = [] # linked too much
for nonperfect_group in nonperfect_groups:
if ut.is_subset_of_any(nonperfect_group, missed_groups):
false_negative_groups.append(nonperfect_group)
else:
false_positive_groups.append(nonperfect_group)
# Get some more info on the nonperfect groups
# find which groups should have been linked
aid2_to_aid1 = ut.invert_dict(aid1_to_aid2)
false_negative_groups_t = [tuple(ut.dict_take_list(aid2_to_aid1, aids2)) for aids2 in false_negative_groups]
false_negative_group_nids_t = ibs_gt.unflat_map(ibs_gt.get_annot_nids, false_negative_groups_t)
assert all(map(ut.allsame, false_negative_group_nids_t)), 'inconsistent nids'
false_negative_group_nid_t = ut.get_list_column(false_negative_group_nids_t, 0)
# These are the links that should have been made
missed_links = ut.group_items(false_negative_groups, false_negative_group_nid_t)
print(ut.dict_str(missed_links))
print('# Name with failed links (FN) = %r' % len(false_negative_groups))
print('... should have reduced to %d names.' % (len(missed_links)))
print('# Name with wrong links (FP) = %r' % len(false_positive_groups))
print('# Name correct names (TP) = %r' % len(perfect_groups))
def get_annotcfg_list(ibs, acfg_name_list, filter_dups=True,
qaid_override=None, daid_override=None,
initial_aids=None, use_cache=None, verbose=None):
r"""
For now can only specify one acfg name list
TODO: move to filter_annots
Args:
annot_cfg_name_list (list):
CommandLine:
python -m ibeis.expt.experiment_helpers --exec-get_annotcfg_list:0
python -m ibeis.expt.experiment_helpers --exec-get_annotcfg_list:1
python -m ibeis.expt.experiment_helpers --exec-get_annotcfg_list:2
ibeis -e print_acfg --ainfo
ibeis -e print_acfg --db NNP_Master3 -a viewpoint_compare --nocache-aid --verbtd
ibeis -e print_acfg --db PZ_ViewPoints -a viewpoint_compare --nocache-aid --verbtd
ibeis -e print_acfg --db PZ_MTEST -a unctrl ctrl::unctrl --ainfo --nocache-aid
ibeis -e print_acfg --db testdb1 -a default --ainfo --nocache-aid
ibeis -e print_acfg --db Oxford -a default:qhas_any=query --ainfo --nocache-aid
ibeis -e print_acfg --db Oxford -a default:qhas_any=query,dhas_any=distractor --ainfo --nocache-aid
Example0:
>>> # DISABLE_DOCTEST
>>> from ibeis.expt.experiment_helpers import * # NOQA
>>> import ibeis
>>> from ibeis.expt import annotation_configs
>>> ibs = ibeis.opendb(defaultdb='PZ_MTEST')
>>> filter_dups = not ut.get_argflag('--nofilter-dups')
>>> acfg_name_list = testdata_acfg_names()
>>> _tup = get_annotcfg_list(ibs, acfg_name_list, filter_dups)
>>> acfg_list, expanded_aids_list = _tup
>>> print('\n PRINTING TEST RESULTS')
>>> result = ut.list_str(acfg_list, nl=3)
>>> print('\n')
>>> printkw = dict(combined=True, per_name_vpedge=None,
>>> per_qual=False, per_vp=False)
>>> annotation_configs.print_acfg_list(
>>> acfg_list, expanded_aids_list, ibs, **printkw)
"""
if ut.VERBOSE:
print('[harn.help] building acfg_list using %r' % (acfg_name_list,))
from ibeis.expt import annotation_configs
acfg_combo_list = parse_acfg_combo_list(acfg_name_list)
#acfg_slice = ut.get_argval('--acfg_slice', type_=slice, default=None)
# HACK: Sliceing happens before expansion (dependenceis get)
combo_slice = ut.get_argval('--combo_slice', type_='fuzzy_subset', default=slice(None))
acfg_combo_list = [ut.take(acfg_combo_, combo_slice)
for acfg_combo_ in acfg_combo_list]
if ut.get_argflag('--consistent'):
# Expand everything as one consistent annot list
acfg_combo_list = [ut.flatten(acfg_combo_list)]
# + --- Do Parsing ---
expanded_aids_combo_list = [
filter_annots.expand_acfgs_consistently(ibs, acfg_combo_,
initial_aids=initial_aids,
use_cache=use_cache,
verbose=verbose)
for acfg_combo_ in acfg_combo_list
]
expanded_aids_combo_flag_list = ut.flatten(expanded_aids_combo_list)
acfg_list = ut.get_list_column(expanded_aids_combo_flag_list, 0)
expanded_aids_list = ut.get_list_column(expanded_aids_combo_flag_list, 1)
# L___
# Slicing happens after expansion (but the labels get screwed up)
acfg_slice = ut.get_argval('--acfg_slice', type_='fuzzy_subset', default=None)
if acfg_slice is not None:
acfg_list = ut.take(acfg_list, acfg_slice)
expanded_aids_list = ut.take(expanded_aids_list, acfg_slice)
# + --- Hack: Override qaids ---
_qaids = ut.get_argval(('--qaid', '--qaid-override'), type_=list, default=qaid_override)
if _qaids is not None:
expanded_aids_list = [(_qaids, daids) for qaids, daids in expanded_aids_list]
# more hack for daids
_daids = ut.get_argval('--daids-override', type_=list, default=daid_override)
if _daids is not None:
expanded_aids_list = [(qaids, _daids) for qaids, daids in expanded_aids_list]
# L___
if filter_dups:
expanded_aids_list, acfg_list = filter_duplicate_acfgs(
expanded_aids_list, acfg_list, acfg_name_list)
if ut.get_argflag(('--acfginfo', '--ainfo', '--aidcfginfo', '--print-acfg', '--printacfg')):
import sys
ut.colorprint('[experiment_helpers] Requested AcfgInfo ... ', 'red')
print('combo_slice = %r' % (combo_slice,))
print('acfg_slice = %r' % (acfg_slice,))
annotation_configs.print_acfg_list(acfg_list, expanded_aids_list, ibs)
ut.colorprint('[experiment_helpers] exiting due to AcfgInfo info request', 'red')
sys.exit(1)
return acfg_list, expanded_aids_list
def _update_rows(model, rebuild_structure=True):
"""
Uses the current ider and col_sort_index to create
row_indices
"""
if VERBOSE:
print('[APIItemModel] +-----------')
print('[APIItemModel] _update_rows')
# this is not slow
#with ut.Timer('update_rows'):
#printDBG('UPDATE ROWS!')
#print('UPDATE ROWS!')
#print('num_rows=%r' % len(model.col_level_list))
#print('UPDATE model(%s) rows' % model.name)
#print('[api_model] UPDATE ROWS: %r' % (model.name,))
#print(ut.get_caller_name(range(4, 12)))
if len(model.col_level_list) == 0:
return
#old_root = model.root_node # NOQA
if rebuild_structure:
#with ut.Timer('[%s] _update_rows: %r' %
# ('cyth' if _atn.CYTHONIZED else 'pyth',
# model.name,), newline=False):
model.root_node = _atn.build_internal_structure(model)
#print('-----')
#def lazy_update_rows():
# with ut.Timer('lazy updater: %r' % (model.name,)):
# printDBG('[model] calling lazy updater: %r' % (model.name,))
# REMOVING LAZY FUNCTION BECAUSE IT MIGHT HAVE CAUSED PROBLEMS
#with ut.Timer('[%s] _update_rows2: %r' %
# ('cyth' if _atn.CYTHONIZED else 'pyth',
# model.name,), newline=False):
if VERBOSE:
print('[APIItemModel] lazy_update_rows')
model.level_index_list = []
sort_index = 0 if model.col_sort_index is None else model.col_sort_index
#print('[item_model] sort_index=%r' % (sort_index,))
children = model.root_node.get_children() # THIS IS THE LINE THAT TAKES FOREVER
id_list = [child.get_id() for child in children]
#print('ids_ generated')
nodes = []
if len(id_list) != 0:
if VERBOSE:
print('[APIItemModel] lazy_update_rows len(id_list) = %r' % (len(id_list)))
# start sort
if model.col_sort_index is not None:
type_ = model.col_type_list[sort_index]
getter = model.col_getter_list[sort_index]
values = getter(id_list)
if type_ == 'PIXMAP':
# TODO: find a better sorting metric for pixmaps
values = ut.get_list_column(values, 0)
#print('values got')
else:
type_ = int
values = id_list
reverse = model.col_sort_reverse
#ut.embed()
# <NUMPY MULTIARRAY SORT>
#with ut.embed_on_exception_context:
if type_ is float:
values = np.array(ut.replace_nones(values, np.nan))
#values = np.array(values)
values[np.isnan(values)] = -np.inf # Force nan to be the smallest number
import vtool as vt
sortx = vt.argsort_records([values, id_list], reverse=reverse)
#sorting_records = np.rec.fromarrays([values, id_list])
#sort_stride = (-reverse * 2) + 1
#sortx = sorting_records.argsort()[::sort_stride]
# </NUMPY MULTIARRAY SORT>
nodes = ut.take(children, sortx)
#sorted_pairs = sorted(zip(values, id_list, children), reverse=reverse)
#nodes = [child for (value, id_, child) in sorted_pairs]
level = model.col_level_list[sort_index]
#print("row_indices sorted")
if level == 0:
model.root_node.set_children(nodes)
# end sort
if ut.USE_ASSERT:
assert nodes is not None, 'no indices'
model.level_index_list = nodes
#if VERBOSE:
# print('[APIItemModel] lazy_update_rows emmiting _rows_updated')
# EMIT THE NUMERR OF ROWS AND THE NAME OF FOR THE VIEW TO DISPLAY
model._rows_updated.emit(model.name, len(model.level_index_list))
# lazy method didn't work. Eagerly evaluate
#lazy_update_rows()
# HACK TO MAKE SURE TREE NODES DONT DELETE THEMSELVES
#if VERBOSE:
# print('[APIItemModel] build_scope_hack_list')
# SCOPE HACK SEEMS TO HAVE NOT HALPED
#model.scope_hack_list = []
#_atn.build_scope_hack_list(model.root_node, model.scope_hack_list)
#model.lazy_updater = lazy_update_rows
#print("Rows updated")
if VERBOSE:
print('[APIItemModel] finished _update_rows')
print('[APIItemModel] L__________')
def try_query(model, infr, evidence, interest_ttypes=[], verbose=True):
r"""
CommandLine:
python -m wbia.algo.hots.bayes --exec-try_query --show
Example:
>>> # DISABLE_DOCTEST
>>> from wbia.algo.hots.bayes import * # NOQA
>>> verbose = True
>>> other_evidence = {}
>>> name_evidence = [1, None, 0, None]
>>> score_evidence = ['high', 'low', 'low']
>>> query_vars = None
>>> model = make_name_model(num_annots=4, num_names=4, verbose=True, mode=1)
>>> model, evidence, soft_evidence = update_model_evidence(model, name_evidence, score_evidence, other_evidence)
>>> interest_ttypes = ['name']
>>> infr = pgmpy.inference.BeliefPropagation(model)
>>> evidence = infr._ensure_internal_evidence(evidence, model)
>>> query_results = try_query(model, infr, evidence, interest_ttypes, verbose)
>>> result = ('query_results = %s' % (str(query_results),))
>>> ut.quit_if_noshow()
>>> show_model(model, show_prior=True, **query_results)
>>> ut.show_if_requested()
Ignore:
query_vars = ut.setdiff_ordered(model.nodes(), list(evidence.keys()))
probs = infr.query(query_vars, evidence)
map_assignment = infr.map_query(query_vars, evidence)
"""
infr = pgmpy.inference.VariableElimination(model)
# infr = pgmpy.inference.BeliefPropagation(model)
if True:
return bruteforce(model, query_vars=None, evidence=evidence)
else:
import vtool as vt
query_vars = ut.setdiff_ordered(model.nodes(), list(evidence.keys()))
# hack
query_vars = ut.setdiff_ordered(
query_vars, ut.list_getattr(model.ttype2_cpds['score'],
'variable'))
if verbose:
evidence_str = ', '.join(model.pretty_evidence(evidence))
logger.info('P(' + ', '.join(query_vars) + ' | ' + evidence_str +
') = ')
# Compute MAP joints
# There is a bug here.
# map_assign = infr.map_query(query_vars, evidence)
# (probably an invalid thing to do)
# joint_factor = pgmpy.factors.factor_product(*factor_list)
# Brute force MAP
name_vars = ut.list_getattr(model.ttype2_cpds['name'], 'variable')
query_name_vars = ut.setdiff_ordered(name_vars, list(evidence.keys()))
# TODO: incorporate case where Na is assigned to Fred
# evidence_h = ut.delete_keys(evidence.copy(), ['Na'])
joint = model.joint_distribution()
joint.evidence_based_reduction(query_name_vars, evidence, inplace=True)
# Find static row labels in the evidence
given_name_vars = [var for var in name_vars if var in evidence]
given_name_idx = ut.dict_take(evidence, given_name_vars)
given_name_val = [
joint.statename_dict[var][idx]
for var, idx in zip(given_name_vars, given_name_idx)
]
new_vals = joint.values.ravel()
# Add static evidence variables to the relabeled name states
new_vars = given_name_vars + joint.variables
new_rows = [tuple(given_name_val) + row for row in joint._row_labels()]
# Relabel rows based on the knowledge that
# everything is the same, only the names have changed.
temp_basis = [i for i in range(model.num_names)]
def relabel_names(names, temp_basis=temp_basis):
names = list(map(six.text_type, names))
mapping = {}
for n in names:
if n not in mapping:
mapping[n] = len(mapping)
new_names = tuple([temp_basis[mapping[n]] for n in names])
return new_names
relabeled_rows = list(map(relabel_names, new_rows))
# Combine probability of rows with the same (new) label
data_ids = np.array(vt.other.compute_unique_data_ids_(relabeled_rows))
unique_ids, groupxs = vt.group_indices(data_ids)
reduced_row_lbls = ut.take(relabeled_rows,
ut.get_list_column(groupxs, 0))
reduced_row_lbls = list(map(list, reduced_row_lbls))
reduced_values = np.array(
[g.sum() for g in vt.apply_grouping(new_vals, groupxs)])
# Relabel the rows one more time to agree with initial constraints
used_ = []
replaced = []
for colx, (var, val) in enumerate(zip(given_name_vars,
given_name_val)):
# All columns must be the same for this labeling
alias = reduced_row_lbls[0][colx]
reduced_row_lbls = ut.list_replace(reduced_row_lbls, alias, val)
replaced.append(alias)
used_.append(val)
basis = model.ttype2_cpds['name'][0]._template_.basis
find_remain_ = ut.setdiff_ordered(temp_basis, replaced)
repl_remain_ = ut.setdiff_ordered(basis, used_)
for find, repl in zip(find_remain_, repl_remain_):
reduced_row_lbls = ut.list_replace(reduced_row_lbls, find, repl)
# Now find the most likely state
sortx = reduced_values.argsort()[::-1]
sort_reduced_row_lbls = ut.take(reduced_row_lbls, sortx.tolist())
sort_reduced_values = reduced_values[sortx]
# Remove evidence based labels
new_vars_ = new_vars[len(given_name_vars):]
sort_reduced_row_lbls_ = ut.get_list_column(
sort_reduced_row_lbls, slice(len(given_name_vars), None))
sort_reduced_row_lbls_[0]
# hack into a new joint factor
var_states = ut.lmap(ut.unique_ordered, zip(*sort_reduced_row_lbls_))
statename_dict = dict(zip(new_vars, var_states))
cardinality = ut.lmap(len, var_states)
val_lookup = dict(
zip(ut.lmap(tuple, sort_reduced_row_lbls_), sort_reduced_values))
values = np.zeros(np.prod(cardinality))
for idx, state in enumerate(ut.iprod(*var_states)):
if state in val_lookup:
values[idx] = val_lookup[state]
joint2 = pgmpy.factors.Factor(new_vars_,
cardinality,
values,
statename_dict=statename_dict)
logger.info(joint2)
max_marginals = {}
for i, var in enumerate(query_name_vars):
one_out = query_name_vars[:i] + query_name_vars[i + 1:]
max_marginals[var] = joint2.marginalize(one_out, inplace=False)
# max_marginals[var] = joint2.maximize(one_out, inplace=False)
logger.info(joint2.marginalize(['Nb', 'Nc'], inplace=False))
factor_list = max_marginals.values()
# Better map assignment based on knowledge of labels
map_assign = dict(zip(new_vars_, sort_reduced_row_lbls_[0]))
sort_reduced_rowstr_lbls = [
ut.repr2(dict(zip(new_vars, lbls)),
explicit=True,
nobraces=True,
strvals=True) for lbls in sort_reduced_row_lbls_
]
top_assignments = list(
zip(sort_reduced_rowstr_lbls[:3], sort_reduced_values))
if len(sort_reduced_values) > 3:
top_assignments += [('other', 1 - sum(sort_reduced_values[:3]))]
# import utool
# utool.embed()
# Compute all marginals
# probs = infr.query(query_vars, evidence)
# probs = infr.query(query_vars, evidence)
# factor_list = probs.values()
## Marginalize over non-query, non-evidence
# irrelevant_vars = ut.setdiff_ordered(joint.variables, list(evidence.keys()) + query_vars)
# joint.marginalize(irrelevant_vars)
# joint.normalize()
# new_rows = joint._row_labels()
# new_vals = joint.values.ravel()
# map_vals = new_rows[new_vals.argmax()]
# map_assign = dict(zip(joint.variables, map_vals))
# Compute Marginalized MAP joints
# marginalized_joints = {}
# for ttype in interest_ttypes:
# other_vars = [v for v in joint_factor.scope()
# if model.var2_cpd[v].ttype != ttype]
# marginal = joint_factor.marginalize(other_vars, inplace=False)
# marginalized_joints[ttype] = marginal
query_results = {
'factor_list': factor_list,
'top_assignments': top_assignments,
'map_assign': map_assign,
'marginalized_joints': None,
}
return query_results
def parse_acfg_combo_list(acfg_name_list):
r"""
Args:
acfg_name_list (list):
Returns:
list: acfg_combo_list
CommandLine:
python -m ibeis.expt.experiment_helpers --exec-parse_acfg_combo_list
python -m ibeis.expt.experiment_helpers --exec-parse_acfg_combo_list:1
Example:
>>> # DISABLE_DOCTEST
>>> from ibeis.expt.experiment_helpers import * # NOQA
>>> import ibeis
>>> from ibeis.expt import annotation_configs
>>> acfg_name_list = testdata_acfg_names(['default', 'uncontrolled'])
>>> acfg_combo_list = parse_acfg_combo_list(acfg_name_list)
>>> acfg_list = ut.flatten(acfg_combo_list)
>>> printkw = dict()
>>> annotation_configs.print_acfg_list(acfg_list, **printkw)
Example:
>>> # DISABLE_DOCTEST
>>> from ibeis.expt.experiment_helpers import * # NOQA
>>> import ibeis
>>> from ibeis.expt import annotation_configs
>>> # double colon :: means expand consistently and force const size
>>> acfg_name_list = testdata_acfg_names(['unctrl', 'ctrl::unctrl'])
>>> acfg_name_list = testdata_acfg_names(['unctrl', 'varysize', 'ctrl::unctrl'])
>>> acfg_name_list = testdata_acfg_names(['unctrl', 'varysize', 'ctrl::varysize', 'ctrl::unctrl'])
>>> acfg_combo_list = parse_acfg_combo_list(acfg_name_list)
>>> acfg_list = ut.flatten(acfg_combo_list)
>>> printkw = dict()
>>> annotation_configs.print_acfg_list(acfg_list, **printkw)
"""
from ibeis.expt import annotation_configs
named_defaults_dict = ut.dict_take(annotation_configs.__dict__,
annotation_configs.TEST_NAMES)
named_qcfg_defaults = dict(zip(annotation_configs.TEST_NAMES,
ut.get_list_column(named_defaults_dict, 'qcfg')))
named_dcfg_defaults = dict(zip(annotation_configs.TEST_NAMES,
ut.get_list_column(named_defaults_dict, 'dcfg')))
alias_keys = annotation_configs.ALIAS_KEYS
# need to have the cfgstr_lists be the same for query and database so they
# can be combined properly for now
# Apply this flag to any case joined with ::
special_join_dict = {'force_const_size': True}
# Parse Query Annot Config
nested_qcfg_combo_list = cfghelpers.parse_cfgstr_list2(
cfgstr_list=acfg_name_list,
named_defaults_dict=named_qcfg_defaults,
cfgtype='qcfg',
alias_keys=alias_keys,
expand_nested=False,
special_join_dict=special_join_dict,
is_nestedcfgtype=True)
#print('acfg_name_list = %r' % (acfg_name_list,))
#print(len(acfg_name_list))
#print(ut.depth_profile(nested_qcfg_combo_list))
# Parse Data Annot Config
nested_dcfg_combo_list = cfghelpers.parse_cfgstr_list2(
cfgstr_list=acfg_name_list,
named_defaults_dict=named_dcfg_defaults,
cfgtype='dcfg',
alias_keys=alias_keys,
expand_nested=False,
special_join_dict=special_join_dict,
is_nestedcfgtype=True)
#print(ut.depth_profile(nested_dcfg_combo_list))
acfg_combo_list = []
#print('--')
for nested_qcfg_combo, nested_dcfg_combo in zip(nested_qcfg_combo_list, nested_dcfg_combo_list):
#print('\n\n++++')
#print(len(nested_dcfg_combo))
#print(len(nested_qcfg_combo))
acfg_combo = []
# Only the inner nested combos are combinatorial
for qcfg_combo, dcfg_combo in zip(nested_qcfg_combo, nested_dcfg_combo):
#print('---++++')
#print('---- ' + str(len(qcfg_combo)))
#print('---- ' + str(len(dcfg_combo)))
_combo = [
dict([('qcfg', qcfg), ('dcfg', dcfg)])
for qcfg, dcfg in list(itertools.product(qcfg_combo, dcfg_combo))
]
#print('---- len(_combo) = %r' % (len(_combo),))
acfg_combo.extend(_combo)
acfg_combo_list.append(acfg_combo)
#print('LLL--')
#print(ut.depth_profile(acfg_combo_list))
return acfg_combo_list
def get_extramargin_detectchip_info(ibs, aid_list, config2_=None, species=None, FACTOR=4):
r"""
Computes a detection chip with a bit of spatial context so the detection algorithm doesn't clip boundaries
CommandLine:
python -m ibeis.algo.preproc.preproc_probchip --test-get_extramargin_detectchip_info --show
python -m ibeis.algo.preproc.preproc_probchip --test-get_extramargin_detectchip_info --show --qaid 27
python -m ibeis.algo.preproc.preproc_probchip --test-get_extramargin_detectchip_info --show --qaid 2
Example:
>>> # ENABLE_DOCTEST
>>> from ibeis.algo.preproc.preproc_probchip import * # NOQA
>>> import ibeis
>>> from ibeis.init import main_helpers
>>> ibs = ibeis.opendb('PZ_MTEST')
>>> aid_list = main_helpers.get_test_qaids(ibs)
>>> arg_list, newsize_list, halfoffset_cs_list = get_extramargin_detectchip_info(ibs, aid_list)
>>> ut.quit_if_noshow()
>>> testshow_extramargin_info(ibs, aid_list, arg_list, newsize_list, halfoffset_cs_list)
"""
from vtool import chip as ctool
target_width = 128 * FACTOR
gfpath_list = ibs.get_annot_image_paths(aid_list)
bbox_list = ibs.get_annot_bboxes(aid_list)
theta_list = ibs.get_annot_thetas(aid_list)
bbox_size_list = ut.get_list_column(bbox_list, [2, 3])
newsize_list = list(map(
lambda size: ctool.get_scaled_size_with_width(target_width, *size),
bbox_size_list))
invalid_aids = [aid for aid, (w, h) in zip(aid_list, bbox_size_list) if w == 0 or h == 0]
if len(invalid_aids) > 0:
msg = ("REMOVE INVALID (BAD WIDTH AND/OR HEIGHT) AIDS TO COMPUTE AND WRITE CHIPS")
msg += ("INVALID AIDS: %r" % (invalid_aids, ))
print(msg)
raise Exception(msg)
# There are two spaces we are working in here
# probchipspace _pcs (the space of the margined chip computed for probchip) and
# imagespace _gs (the space using in bbox specification)
# Compute the offset we would like in chip space for margin expansion
halfoffset_cs_list = [
# TODO: Find correct offsets
(16 * FACTOR, 16 * FACTOR) # (w / 16, h / 16)
for (w, h) in newsize_list
]
# Compute expanded newsize list to include the extra margin offset
expanded_newsize_list = [
(w_pcs + (2 * xo_pcs), h_pcs + (2 * yo_pcs))
for (w_pcs, h_pcs), (xo_pcs, yo_pcs) in zip(newsize_list, halfoffset_cs_list)
]
# Get the conversion from chip to image space
to_imgspace_scale_factors = [
(w_gs / w_pcs, h_gs / h_pcs)
for ((w_pcs, h_pcs), (w_gs, h_gs)) in zip(newsize_list, bbox_size_list)
]
# Convert the chip offsets to image space
halfoffset_gs_list = [
((sx * xo), (sy * yo))
for (sx, sy), (xo, yo) in zip(to_imgspace_scale_factors, halfoffset_cs_list)
]
# Find the size of the expanded margin bbox in image space
expanded_bbox_gs_list = [
(x_gs - xo_gs, y_gs - yo_gs, w_gs + (2 * xo_gs), h_gs + (2 * yo_gs))
for (x_gs, y_gs, w_gs, h_gs), (xo_gs, yo_gs) in zip(bbox_list, halfoffset_gs_list)
]
# TODO: make this work
probchip_fpath_list = get_annot_probchip_fpath_list(ibs, aid_list,
config2_=config2_,
species=species)
#probchip_extramargin_fpath_list = [ut.augpath(fpath, '_extramargin') for
#fpath in probchip_fpath_list]
extramargin_fpath_list = [ut.augpath(fpath, '_extramargin').replace('probchip', 'detectchip')
for fpath in probchip_fpath_list]
# # filter by species and add a suffix for the probchip_input
# # also compute a probchip fpath with an expanded suffix for the detector
#probchip_fpath_list = get_annot_probchip_fpath_list(ibs, aids, config2_=None, species=species)
# Then crop the output and write that as the real probchip
filtlist_iter = ([] for _ in range(len(aid_list)))
arg_iter = zip(extramargin_fpath_list, gfpath_list,
expanded_bbox_gs_list, theta_list, expanded_newsize_list,
filtlist_iter)
arg_list = list(arg_iter)
return arg_list, newsize_list, halfoffset_cs_list
def check_results(ibs_gt, ibs2, aid1_to_aid2, aids_list1_, incinfo):
"""
reports how well the incremental query ran when the oracle was calling the
shots.
"""
print('--------- CHECKING RESULTS ------------')
testcases = incinfo.get('testcases')
if testcases is not None:
count_dict = ut.count_dict_vals(testcases)
print('+--')
#print(ut.dict_str(testcases))
print('---')
print(ut.dict_str(count_dict))
print('L__')
# TODO: dont include initially added aids in the result reporting
aid_list1 = aids_list1_ # ibs_gt.get_valid_aids()
#aid_list1 = ibs_gt.get_aids_with_groundtruth()
aid_list2 = ibs2.get_valid_aids()
nid_list1 = ibs_gt.get_annot_nids(aid_list1)
nid_list2 = ibs2.get_annot_nids(aid_list2)
# Group annotations from test and gt database by their respective names
grouped_dict1 = ut.group_items(aid_list1, nid_list1)
grouped_dict2 = ut.group_items(aid_list2, nid_list2)
grouped_aids1 = list(six.itervalues(grouped_dict1))
grouped_aids2 = list(map(tuple, six.itervalues(grouped_dict2)))
#group_nids1 = list(six.iterkeys(grouped_dict1))
#group_nids2 = list(six.iterkeys(grouped_dict2))
# Transform annotation ids from database1 space to database2 space
grouped_aids1_t = [
tuple(ut.dict_take_list(aid1_to_aid2, aids1))
for aids1 in grouped_aids1
]
set_grouped_aids1_t = set(grouped_aids1_t)
set_grouped_aids2 = set(grouped_aids2)
# Find names we got right. (correct groupings of annotations)
# these are the annotation groups that are intersecting between
# the test database and groundtruth database
perfect_groups = set_grouped_aids2.intersection(set_grouped_aids1_t)
# Find names we got wrong. (incorrect groupings of annotations)
# The test database sets that were not perfect
nonperfect_groups = set_grouped_aids2.difference(perfect_groups)
# What we should have got
# The ground truth database sets that were not fully identified
missed_groups = set_grouped_aids1_t.difference(perfect_groups)
# Mark non perfect groups by their error type
false_negative_groups = [] # failed to link enough
false_positive_groups = [] # linked too much
for nonperfect_group in nonperfect_groups:
if ut.is_subset_of_any(nonperfect_group, missed_groups):
false_negative_groups.append(nonperfect_group)
else:
false_positive_groups.append(nonperfect_group)
# Get some more info on the nonperfect groups
# find which groups should have been linked
aid2_to_aid1 = ut.invert_dict(aid1_to_aid2)
false_negative_groups_t = [
tuple(ut.dict_take_list(aid2_to_aid1, aids2))
for aids2 in false_negative_groups
]
false_negative_group_nids_t = ibs_gt.unflat_map(ibs_gt.get_annot_nids,
false_negative_groups_t)
assert all(map(ut.allsame,
false_negative_group_nids_t)), 'inconsistent nids'
false_negative_group_nid_t = ut.get_list_column(
false_negative_group_nids_t, 0)
# These are the links that should have been made
missed_links = ut.group_items(false_negative_groups,
false_negative_group_nid_t)
print(ut.dict_str(missed_links))
print('# Name with failed links (FN) = %r' % len(false_negative_groups))
print('... should have reduced to %d names.' % (len(missed_links)))
print('# Name with wrong links (FP) = %r' % len(false_positive_groups))
print('# Name correct names (TP) = %r' % len(perfect_groups))
def get_toy_data_1vM(num_annots, num_names=None, **kwargs):
r"""
Args:
num_annots (int):
num_names (int): (default = None)
Kwargs:
initial_aids, initial_nids, nid_sequence, seed
Returns:
tuple: (pair_list, feat_list)
CommandLine:
python -m ibeis.algo.hots.demobayes --exec-get_toy_data_1vM --show
Example:
>>> # DISABLE_DOCTEST
>>> from ibeis.algo.hots.demobayes import * # NOQA
>>> num_annots = 1000
>>> num_names = 40
>>> get_toy_data_1vM(num_annots, num_names)
>>> ut.quit_if_noshow()
>>> import plottool as pt
>>> ut.show_if_requested()
"""
import vtool as vt
tup_ = get_toy_annots(num_annots, num_names, **kwargs)
aids, nids, aids1, nids1, all_aids, all_nids = tup_
rng = vt.ensure_rng(None)
# Test a simple SVM classifier
nid2_nexemp = ut.dict_hist(nids1)
aid2_nid = dict(zip(aids, nids))
ut.fix_embed_globals()
#def add_to_globals(globals_, subdict):
# globals_.update(subdict)
unique_nids = list(nid2_nexemp.keys())
def annot_to_class_feats2(aid, aid2_nid, top=None):
pair_list = []
score_list = []
nexemplar_list = []
for nid in unique_nids:
label = (aid2_nid[aid] == nid)
num_exemplars = nid2_nexemp.get(nid, 0)
if num_exemplars == 0:
continue
params = toy_params[label]
mu, sigma = ut.dict_take(params, ['mu', 'sigma'])
score_ = rng.normal(mu, sigma, size=num_exemplars).max()
score = np.clip(score_, 0, np.inf)
pair_list.append((aid, nid))
score_list.append(score)
nexemplar_list.append(num_exemplars)
rank_list = ut.argsort(score_list, reverse=True)
feat_list = np.array([score_list, rank_list, nexemplar_list]).T
sortx = np.argsort(rank_list)
feat_list = feat_list.take(sortx, axis=0)
pair_list = np.array(pair_list).take(sortx, axis=0)
if top is not None:
feat_list = feat_list[:top]
pair_list = pair_list[0:top]
return pair_list, feat_list
toclass_features = [annot_to_class_feats2(aid, aid2_nid, top=5) for aid in aids]
aidnid_pairs = np.vstack(ut.get_list_column(toclass_features, 0))
feat_list = np.vstack(ut.get_list_column(toclass_features, 1))
score_list = feat_list.T[0:1].T
lbl_list = [aid2_nid[aid] == nid for aid, nid in aidnid_pairs]
from sklearn import svm
#clf1 = svm.LinearSVC()
print('Learning classifiers')
clf3 = svm.SVC()
clf3.fit(feat_list, lbl_list)
clf1 = svm.LinearSVC()
clf1.fit(score_list, lbl_list)
# Score new annots against the training database
tup_ = get_toy_annots(num_annots * 2, num_names, initial_aids=all_aids, initial_nids=all_nids)
aids, nids, aids1, nids1, all_aids, all_nids = tup_
aid2_nid = dict(zip(aids, nids))
toclass_features = [annot_to_class_feats2(aid, aid2_nid) for aid in aids]
aidnid_pairs = np.vstack(ut.get_list_column(toclass_features, 0))
feat_list = np.vstack(ut.get_list_column(toclass_features, 1))
lbl_list = np.array([aid2_nid[aid] == nid for aid, nid in aidnid_pairs])
print('Running tests')
score_list = feat_list.T[0:1].T
tp_feat_list = feat_list[lbl_list]
tn_feat_list = feat_list[~lbl_list]
tp_lbls = lbl_list[lbl_list]
tn_lbls = lbl_list[~lbl_list]
print('num tp: %d' % len(tp_lbls))
print('num fp: %d' % len(tn_lbls))
tp_score_list = score_list[lbl_list]
tn_score_list = score_list[~lbl_list]
print('tp_feat' + ut.repr3(ut.get_stats(tp_feat_list, axis=0), precision=2))
print('tp_feat' + ut.repr3(ut.get_stats(tn_feat_list, axis=0), precision=2))
print('tp_score' + ut.repr2(ut.get_stats(tp_score_list), precision=2))
print('tp_score' + ut.repr2(ut.get_stats(tn_score_list), precision=2))
tp_pred3 = clf3.predict(tp_feat_list)
tn_pred3 = clf3.predict(tn_feat_list)
print((tp_pred3.sum(), tp_pred3.shape))
print((tn_pred3.sum(), tn_pred3.shape))
tp_score3 = clf3.score(tp_feat_list, tp_lbls)
tn_score3 = clf3.score(tn_feat_list, tn_lbls)
tp_pred1 = clf1.predict(tp_score_list)
tn_pred1 = clf1.predict(tn_score_list)
print((tp_pred1.sum(), tp_pred1.shape))
print((tn_pred1.sum(), tn_pred1.shape))
tp_score1 = clf1.score(tp_score_list, tp_lbls)
tn_score1 = clf1.score(tn_score_list, tn_lbls)
print('tp score with rank = %r' % (tp_score3,))
print('tn score with rank = %r' % (tn_score3,))
print('tp score without rank = %r' % (tp_score1,))
print('tn score without rank = %r' % (tn_score1,))
toy_data = {}
return toy_data
def show_model(model, evidence={}, soft_evidence={}, **kwargs):
"""
References:
http://stackoverflow.com/questions/22207802/pygraphviz-networkx-set-node-level-or-layer
Ignore:
pkg-config --libs-only-L libcgraph
sudo apt-get install libgraphviz-dev -y
sudo apt-get install libgraphviz4 -y
# sudo apt-get install pkg-config
sudo apt-get install libgraphviz-dev
# pip install git+git://github.com/pygraphviz/pygraphviz.git
pip install pygraphviz
python -c "import pygraphviz; print(pygraphviz.__file__)"
sudo pip3 install pygraphviz --install-option="--include-path=/usr/include/graphviz" --install-option="--library-path=/usr/lib/graphviz/"
python3 -c "import pygraphviz; print(pygraphviz.__file__)"
"""
if ut.get_argval('--hackmarkov') or ut.get_argval('--hackjunc'):
draw_tree_model(model, **kwargs)
return
import wbia.plottool as pt
import networkx as netx
import matplotlib as mpl
fnum = pt.ensure_fnum(None)
fig = pt.figure(fnum=fnum, pnum=(3, 1, (slice(0, 2), 0)),
doclf=True) # NOQA
# fig = pt.figure(fnum=fnum, pnum=(3, 2, (1, slice(1, 2))), doclf=True) # NOQA
ax = pt.gca()
var2_post = {f.variables[0]: f for f in kwargs.get('factor_list', [])}
netx_graph = model
# netx_graph.graph.setdefault('graph', {})['size'] = '"10,5"'
# netx_graph.graph.setdefault('graph', {})['rankdir'] = 'LR'
pos = get_hacked_pos(netx_graph)
# netx.nx_agraph.pygraphviz_layout(netx_graph)
# pos = netx.nx_agraph.pydot_layout(netx_graph, prog='dot')
# pos = netx.nx_agraph.graphviz_layout(netx_graph)
drawkw = dict(pos=pos, ax=ax, with_labels=True, node_size=1500)
if evidence is not None:
node_colors = [
# (pt.TRUE_BLUE
(pt.WHITE if node not in soft_evidence else pt.LIGHT_PINK)
if node not in evidence else pt.FALSE_RED
for node in netx_graph.nodes()
]
for node in netx_graph.nodes():
cpd = model.var2_cpd[node]
if cpd.ttype == 'score':
pass
drawkw['node_color'] = node_colors
netx.draw(netx_graph, **drawkw)
show_probs = True
if show_probs:
textprops = {
'family': 'monospace',
'horizontalalignment': 'left',
#'horizontalalignment': 'center',
#'size': 12,
'size': 8,
}
textkw = dict(
xycoords='data',
boxcoords='offset points',
pad=0.25,
framewidth=True,
arrowprops=dict(arrowstyle='->'),
# bboxprops=dict(fc=node_attr['fillcolor']),
)
netx_nodes = model.nodes(data=True)
node_key_list = ut.get_list_column(netx_nodes, 0)
pos_list = ut.dict_take(pos, node_key_list)
artist_list = []
offset_box_list = []
for pos_, node in zip(pos_list, netx_nodes):
x, y = pos_
variable = node[0]
cpd = model.var2_cpd[variable]
prior_marg = (cpd if cpd.evidence is None else cpd.marginalize(
cpd.evidence, inplace=False))
prior_text = None
text = None
if variable in evidence:
text = cpd.variable_statenames[evidence[variable]]
elif variable in var2_post:
post_marg = var2_post[variable]
text = pgm_ext.make_factor_text(post_marg, 'post')
prior_text = pgm_ext.make_factor_text(prior_marg, 'prior')
else:
if len(evidence) == 0 and len(soft_evidence) == 0:
prior_text = pgm_ext.make_factor_text(prior_marg, 'prior')
show_post = kwargs.get('show_post', False)
show_prior = kwargs.get('show_prior', False)
show_prior = True
show_post = True
show_ev = evidence is not None and variable in evidence
if (show_post or show_ev) and text is not None:
offset_box = mpl.offsetbox.TextArea(text, textprops)
artist = mpl.offsetbox.AnnotationBbox(
# offset_box, (x + 5, y), xybox=(20., 5.),
offset_box,
(x, y + 5),
xybox=(4.0, 20.0),
# box_alignment=(0, 0),
box_alignment=(0.5, 0),
**textkw)
offset_box_list.append(offset_box)
artist_list.append(artist)
if show_prior and prior_text is not None:
offset_box2 = mpl.offsetbox.TextArea(prior_text, textprops)
artist2 = mpl.offsetbox.AnnotationBbox(
# offset_box2, (x - 5, y), xybox=(-20., -15.),
# offset_box2, (x, y - 5), xybox=(-15., -20.),
offset_box2,
(x, y - 5),
xybox=(-4, -20.0),
# box_alignment=(1, 1),
box_alignment=(0.5, 1),
**textkw)
offset_box_list.append(offset_box2)
artist_list.append(artist2)
for artist in artist_list:
ax.add_artist(artist)
xmin, ymin = np.array(pos_list).min(axis=0)
xmax, ymax = np.array(pos_list).max(axis=0)
num_annots = len(model.ttype2_cpds['name'])
if num_annots > 4:
ax.set_xlim((xmin - 40, xmax + 40))
ax.set_ylim((ymin - 50, ymax + 50))
fig.set_size_inches(30, 7)
else:
ax.set_xlim((xmin - 42, xmax + 42))
ax.set_ylim((ymin - 50, ymax + 50))
fig.set_size_inches(23, 7)
fig = pt.gcf()
title = 'num_names=%r, num_annots=%r' % (model.num_names, num_annots)
map_assign = kwargs.get('map_assign', None)
# max_marginal_list = []
# for name, marginal in marginalized_joints.items():
# states = list(ut.iprod(*marginal.statenames))
# vals = marginal.values.ravel()
# x = vals.argmax()
# max_marginal_list += ['P(' + ', '.join(states[x]) + ') = ' + str(vals[x])]
# title += str(marginal)
top_assignments = kwargs.get('top_assignments', None)
if top_assignments is not None:
map_assign, map_prob = top_assignments[0]
if map_assign is not None:
# title += '\nMAP=' + ut.repr2(map_assign, strvals=True)
title += '\nMAP: ' + map_assign + ' @' + '%.2f%%' % (
100 * map_prob, )
if kwargs.get('show_title', True):
pt.set_figtitle(title, size=14)
# pt.set_xlabel()
def hack_fix_centeralign():
if textprops['horizontalalignment'] == 'center':
logger.info('Fixing centeralign')
fig = pt.gcf()
fig.canvas.draw()
# Superhack for centered text. Fix bug in
# /usr/local/lib/python2.7/dist-packages/matplotlib/offsetbox.py
# /usr/local/lib/python2.7/dist-packages/matplotlib/text.py
for offset_box in offset_box_list:
offset_box.set_offset
z = offset_box._text.get_window_extent()
(z.x1 - z.x0) / 2
offset_box._text
T = offset_box._text.get_transform()
A = mpl.transforms.Affine2D()
A.clear()
A.translate((z.x1 - z.x0) / 2, 0)
offset_box._text.set_transform(T + A)
hack_fix_centeralign()
top_assignments = kwargs.get('top_assignments', None)
if top_assignments is not None:
bin_labels = ut.get_list_column(top_assignments, 0)
bin_vals = ut.get_list_column(top_assignments, 1)
# bin_labels = ['\n'.join(ut.textwrap.wrap(_lbl, width=30)) for _lbl in bin_labels]
pt.draw_histogram(
bin_labels,
bin_vals,
fnum=fnum,
pnum=(3, 8, (2, slice(4, None))),
transpose=True,
use_darkbackground=False,
# xtick_rotation=-10,
ylabel='Prob',
xlabel='assignment',
)
pt.set_title('Assignment probabilities')
def get_node_viz_attrs(model, evidence, soft_evidence, factor_list,
ttype_colors, **kwargs):
import plottool as pt
var2_post = {f.variables[0]: f for f in factor_list}
pos_dict = get_bayesnet_layout(model)
#pos_dict = netx.pygraphviz_layout(netx_graph)
#pos_dict = netx.pydot_layout(netx_graph, prog='dot')
#pos_dict = netx.graphviz_layout(netx_graph)
netx_nodes = model.nodes(data=True)
node_key_list = ut.get_list_column(netx_nodes, 0)
pos_list = ut.dict_take(pos_dict, node_key_list)
prior_text = None
post_text = None
evidence_tas = []
post_tas = []
prior_tas = []
node_color = []
has_infered = evidence or var2_post
if has_infered:
ignore_prior_with_ttype = ['score', 'match']
show_prior = False
else:
ignore_prior_with_ttype = []
#show_prior = True
show_prior = False
dpy = 5
dbx, dby = (20, 20)
takw1 = {'bbox_align': (.5, 0), 'pos_offset': [0, dpy],
'bbox_offset': [dbx, dby]}
takw2 = {'bbox_align': (.5, 1), 'pos_offset': [0, -dpy],
'bbox_offset': [-dbx, -dby]}
def get_name_color(phi):
order = phi.values.argsort()[::-1]
if len(order) < 2:
dist_next = phi.values[order[0]]
else:
dist_next = phi.values[order[0]] - phi.values[order[1]]
dist_total = (phi.values[order[0]])
confidence = (dist_total * dist_next) ** (2.5 / 4)
#print('confidence = %r' % (confidence,))
color = ttype_colors['name'][order[0]]
color = pt.color_funcs.desaturate_rgb(color, 1 - confidence)
color = np.array(color)
return color
for node, pos in zip(netx_nodes, pos_list):
variable = node[0]
cpd = model.var2_cpd[variable]
prior_marg = (cpd if cpd.evidence is None else
cpd.marginalize(cpd.evidence, inplace=False))
show_evidence = variable in evidence
show_prior = cpd.ttype not in ignore_prior_with_ttype
show_post = variable in var2_post
show_prior |= cpd.ttype not in ignore_prior_with_ttype
show_prior &= kwargs.get('show_prior', True)
post_marg = None
if show_post:
post_marg = var2_post[variable]
if variable in evidence:
if cpd.ttype == 'score':
color = ttype_colors['score'][evidence[variable] ]
color = np.array(color)
node_color.append(color)
elif cpd.ttype == 'name':
color = ttype_colors['name'][evidence[variable]]
color = np.array(color)
node_color.append(color)
else:
color = pt.FALSE_RED
node_color.append(color)
#elif variable in soft_evidence:
# color = pt.LIGHT_PINK
# show_prior = True
# color = get_name_color(prior_marg)
# node_color.append(color)
else:
if cpd.ttype == 'name' and post_marg is not None:
color = get_name_color(post_marg)
node_color.append(color)
elif cpd.ttype == 'match' and post_marg is not None:
# color = cmap(post_marg.values[1])
# color = pt.lighten_rgb(color, .4)
# color = np.array(color)
color = pt.NEUTRAL
color = pt.LIGHT_PINK
node_color.append(color)
else:
#color = pt.WHITE
color = pt.NEUTRAL
node_color.append(color)
if show_prior:
if variable in soft_evidence:
prior_color = pt.LIGHT_PINK
else:
prior_color = None
prior_text = make_factor_text(prior_marg, 'prior')
prior_tas.append(dict(text=prior_text, pos=pos, color=prior_color, **takw2))
if show_evidence:
_takw1 = takw1
if cpd.ttype == 'score':
_takw1 = takw2
evidence_text = cpd.variable_statenames[evidence[variable]]
if isinstance(evidence_text, int):
evidence_text = '%d/%d' % (evidence_text + 1, cpd.variable_card)
evidence_tas.append(dict(text=evidence_text, pos=pos, color=color, **_takw1))
if show_post:
_takw1 = takw1
if cpd.ttype == 'match':
_takw1 = takw2
post_text = make_factor_text(post_marg, 'post')
post_tas.append(dict(text=post_text, pos=pos, color=None, **_takw1))
def trnps_(dict_list):
""" tranpose dict list """
list_dict = ut.ddict(list)
for dict_ in dict_list:
for key, val in dict_.items():
list_dict[key + '_list'].append(val)
return list_dict
takw1_ = trnps_(post_tas + evidence_tas)
takw2_ = trnps_(prior_tas)
takws = [takw1_, takw2_]
return node_color, pos_list, pos_dict, takws
def __init__(qparams, query_cfg=None, cfgdict=None):
"""
Rename to pipeline params
Structure to store static query pipeline parameters
parses nested config structure into this flat one
Args:
query_cfg (QueryConfig): query_config
cfgdict (dict or None): dictionary to update query_cfg with
CommandLine:
python -m ibeis.algo.hots.query_params --test-__init__
Example:
>>> # ENABLE_DOCTEST
>>> from ibeis.algo.hots.query_params import * # NOQA
>>> import ibeis
>>> ibs = ibeis.opendb('testdb1')
>>> query_cfg = ibs.cfg.query_cfg
>>> #query_cfg.pipeline_root = 'asmk'
>>> cfgdict = {'pipeline_root': 'asmk', 'sv_on': False, 'fg_on': True}
>>> qparams = QueryParams(query_cfg, cfgdict)
>>> assert qparams.pipeline_root == 'smk'
>>> assert qparams.fg_on is True
>>> result = qparams.query_cfgstr
>>> print(')_\n'.join(result.split(')_')))
Example:
>>> # ENABLE_DOCTEST
>>> from ibeis.algo.hots.query_params import * # NOQA
>>> import ibeis
>>> ibs = ibeis.opendb('testdb1')
>>> query_cfg = ibs.cfg.query_cfg
>>> #query_cfg.pipeline_root = 'asmk'
>>> cfgdict = dict(rotation_invariance=True)
>>> qparams = QueryParams(query_cfg, cfgdict)
>>> ut.assert_eq(qparams.hesaff_params['rotation_invariance'], True)
_smk_SMK(agg=True,t=0.0,a=3.0,idf)_
VocabAssign(nAssign=10,a=1.2,s=None,eqw=T)_
VocabTrain(nWords=8000,init=akmeans++,nIters=128,taids=all)_
SV(OFF)_
FEATWEIGHT(ON,uselabel,rf)_
FEAT(hesaff+sift_)_
CHIP(sz450)
"""
# if given custom settings update the config and ensure feasibilty
if query_cfg is None:
query_cfg = Config.QueryConfig()
if cfgdict is not None:
query_cfg = query_cfg.deepcopy()
query_cfg.update_query_cfg(**cfgdict)
# Get flat item list
param_list = Config.parse_config_items(query_cfg)
# Assert that there are no config conflicts
duplicate_keys = ut.find_duplicate_items(
ut.get_list_column(param_list, 0))
assert len(duplicate_keys
) == 0, 'Configs have duplicate names: %r' % duplicate_keys
# Set nexted config attributes as flat qparam properties
for key, val in param_list:
setattr(qparams, key, val)
# Add params not implicitly represented in Config object
pipeline_root = query_cfg.pipeline_root
qparams.chip_cfg_dict = query_cfg._featweight_cfg._feat_cfg._chip_cfg.to_dict(
)
qparams.flann_params = query_cfg.flann_cfg.get_flann_params()
qparams.hesaff_params = query_cfg._featweight_cfg._feat_cfg.get_hesaff_params(
)
qparams.pipeline_root = pipeline_root
qparams.vsmany = pipeline_root == 'vsmany'
qparams.vsone = pipeline_root == 'vsone'
# Add custom strings to the mix as well
# TODO; Find better way to specify config strings
# FIXME: probchip is not in here
qparams.probchip_cfgstr = query_cfg._featweight_cfg.get_cfgstr(
use_feat=False, use_chip=False)
qparams.featweight_cfgstr = query_cfg._featweight_cfg.get_cfgstr()
qparams.chip_cfgstr = query_cfg._featweight_cfg._feat_cfg._chip_cfg.get_cfgstr(
)
qparams.feat_cfgstr = query_cfg._featweight_cfg._feat_cfg.get_cfgstr()
qparams.nn_cfgstr = query_cfg.nn_cfg.get_cfgstr()
qparams.nnweight_cfgstr = query_cfg.nnweight_cfg.get_cfgstr()
qparams.sv_cfgstr = query_cfg.sv_cfg.get_cfgstr()
qparams.flann_cfgstr = query_cfg.flann_cfg.get_cfgstr()
qparams.query_cfgstr = query_cfg.get_cfgstr()
qparams.vocabtrain_cfgstr = query_cfg.smk_cfg.vocabtrain_cfg.get_cfgstr(
)
qparams.rrvsone_cfgstr = query_cfg.rrvsone_cfg.get_cfgstr()
def make_aidpair_tag_context_options(ibs, aid1, aid2):
from wbia import tag_funcs
annotmatch_rowid = ibs.get_annotmatch_rowid_from_undirected_superkey(
[aid1], [aid2])[0]
if annotmatch_rowid is None:
tags = []
else:
tags = ibs.get_annotmatch_case_tags([annotmatch_rowid])[0]
tags = [_.lower() for _ in tags]
standard, other = tag_funcs.get_cate_categories()
case_list = standard + other
# used_chars = gt.find_used_chars(ut.get_list_column(options, 0))
used_chars = []
case_hotlink_list = gt.make_word_hotlinks(case_list, used_chars)
pair_tag_options = []
if True or ut.VERBOSE:
logger.info('[inspect_gui] aid1, aid2 = %r, %r' % (
aid1,
aid2,
))
logger.info('[inspect_gui] annotmatch_rowid = %r' %
(annotmatch_rowid, ))
logger.info('[inspect_gui] tags = %r' % (tags, ))
if ut.VERBOSE:
logger.info('[inspect_gui] Making case hotlist: ' +
ut.repr2(case_hotlink_list))
def _wrap_set_annotmatch_prop(prop, toggle_val):
if ut.VERBOSE:
logger.info('[SETTING] Clicked set prop=%r to val=%r' % (
prop,
toggle_val,
))
am_rowid = ibs.add_annotmatch_undirected([aid1], [aid2])[0]
if ut.VERBOSE:
logger.info('[SETTING] aid1, aid2 = %r, %r' % (
aid1,
aid2,
))
logger.info('[SETTING] annotmatch_rowid = %r' % (am_rowid, ))
ibs.set_annotmatch_prop(prop, [am_rowid], [toggle_val])
if ut.VERBOSE:
logger.info('[SETTING] done')
if True:
# hack for reporting
if annotmatch_rowid is None:
tags = []
else:
tags = ibs.get_annotmatch_case_tags([annotmatch_rowid])[0]
tags = [_.lower() for _ in tags]
logger.info('[inspect_gui] aid1, aid2 = %r, %r' % (
aid1,
aid2,
))
logger.info('[inspect_gui] annotmatch_rowid = %r' %
(annotmatch_rowid, ))
logger.info('[inspect_gui] tags = %r' % (tags, ))
for case, case_hotlink in zip(case_list, case_hotlink_list):
toggle_val = case.lower() not in tags
fmtstr = 'Flag %s case' if toggle_val else 'Unflag %s case'
pair_tag_options += [
# (fmtstr % (case_hotlink,), lambda:
# ibs.set_annotmatch_prop(case, _get_annotmatch_rowid(),
# [toggle_val])),
# (fmtstr % (case_hotlink,), partial(ibs.set_annotmatch_prop,
# case, [annotmatch_rowid], [toggle_val])),
(
fmtstr % (case_hotlink, ),
partial(_wrap_set_annotmatch_prop, case, toggle_val),
),
]
if ut.VERBOSE:
logger.info('Partial tag funcs:' + ut.repr2([
ut.func_str(func, func.args, func.keywords)
for func in ut.get_list_column(pair_tag_options, 1)
]))
return pair_tag_options
def make_netx_graph_from_aid_groups(ibs,
aids_list,
only_reviewed_matches=True,
invis_edges=None,
ensure_edges=None,
temp_nids=None,
allow_directed=False):
r"""
Args:
ibs (ibeis.IBEISController): image analysis api
aids_list (list):
Example:
>>> # DISABLE_DOCTEST
>>> from ibeis.viz.viz_graph import * # NOQA
>>> import ibeis
>>> ibs = ibeis.opendb(defaultdb='testdb1')
>>> aids_list = [[1, 2, 3, 4], [5, 6, 7]]
>>> invis_edges = [(1, 5)]
>>> only_reviewed_matches = True
>>> graph = make_netx_graph_from_aid_groups(ibs, aids_list,
>>> only_reviewed_matches,
>>> invis_edges)
>>> list(nx.connected_components(graph.to_undirected()))
"""
#aids_list, nid_list = ibs.group_annots_by_name(aid_list)
unique_aids = list(ut.flatten(aids_list))
# grouped version
unflat_edges = (list(itertools.product(aids, aids)) for aids in aids_list)
aid_pairs = [tup for tup in ut.iflatten(unflat_edges) if tup[0] != tup[1]]
aids1 = ut.get_list_column(aid_pairs, 0)
aids2 = ut.get_list_column(aid_pairs, 1)
if only_reviewed_matches:
annotmatch_rowids = ibs.get_annotmatch_rowid_from_superkey(
aids1, aids2)
annotmatch_rowids = ut.filter_Nones(annotmatch_rowids)
aids1 = ibs.get_annotmatch_aid1(annotmatch_rowids)
aids2 = ibs.get_annotmatch_aid2(annotmatch_rowids)
graph = make_netx_graph_from_aidpairs(ibs,
aids1,
aids2,
unique_aids=unique_aids)
if ensure_edges is not None:
if ensure_edges == 'all':
ensure_edges = list(ut.upper_diag_self_prodx(list(graph.nodes())))
ensure_edges_ = []
for edge in ensure_edges:
edge = tuple(edge)
redge = tuple(edge[::-1]) # HACK
if graph.has_edge(*edge):
ensure_edges_.append(edge)
pass
#nx.set_edge_attributes(graph, 'weight', {edge: .001})
elif (not allow_directed) and graph.has_edge(*redge):
ensure_edges_.append(redge)
#nx.set_edge_attributes(graph, 'weight', {redge: .001})
pass
else:
ensure_edges_.append(edge)
#graph.add_edge(*edge, weight=.001)
graph.add_edge(*edge)
if temp_nids is None:
unique_nids = ibs.get_annot_nids(list(graph.nodes()))
else:
# HACK
unique_nids = [1] * len(list(graph.nodes()))
#unique_nids = temp_nids
nx.set_node_attributes(graph, 'nid', dict(zip(graph.nodes(), unique_nids)))
import plottool as pt
ensure_names_are_connected(graph, aids_list)
# Color edges by nid
color_by_nids(graph, unique_nids=unique_nids)
if invis_edges:
for edge in invis_edges:
if graph.has_edge(*edge):
nx.set_edge_attributes(graph, 'style', {edge: 'invis'})
nx.set_edge_attributes(graph, 'invisible', {edge: True})
else:
graph.add_edge(*edge, style='invis', invisible=True)
# Hack color images orange
if ensure_edges:
nx.set_edge_attributes(
graph, 'color', {tuple(edge): pt.ORANGE
for edge in ensure_edges_})
return graph
def dev_train_distinctiveness(species=None):
r"""
Args:
ibs (IBEISController): wbia controller object
species (None):
CommandLine:
python -m wbia.algo.hots.distinctiveness_normalizer --test-dev_train_distinctiveness
alias dev_train_distinctiveness='python -m wbia.algo.hots.distinctiveness_normalizer --test-dev_train_distinctiveness'
# Publishing (uses cached normalizers if available)
dev_train_distinctiveness --species GZ --publish
dev_train_distinctiveness --species PZ --publish
dev_train_distinctiveness --species PZ --retrain
Example:
>>> # DISABLE_DOCTEST
>>> from wbia.algo.hots.distinctiveness_normalizer import * # NOQA
>>> import wbia
>>> species = ut.get_argval('--species', str, 'zebra_grevys')
>>> dev_train_distinctiveness(species)
"""
import wbia
# if 'species' not in vars() or species is None:
# species = 'zebra_grevys'
if species == 'zebra_grevys':
dbname = 'GZ_ALL'
elif species == 'zebra_plains':
dbname = 'PZ_Master0'
ibs = wbia.opendb(dbname)
global_distinctdir = ibs.get_global_distinctiveness_modeldir()
cachedir = global_distinctdir
dstcnvs_normer = DistinctivnessNormalizer(species, cachedir=cachedir)
try:
if ut.get_argflag('--retrain'):
raise IOError('force cache miss')
with ut.Timer('loading distinctiveness'):
dstcnvs_normer.load(cachedir)
# Cache hit
logger.info('distinctivness model cache hit')
except IOError:
logger.info('distinctivness model cache miss')
with ut.Timer('training distinctiveness'):
# Need to train
# Add one example from each name
# TODO: add one exemplar per viewpoint for each name
# max_vecs = 1E6
# max_annots = 975
max_annots = 975
# ibs.fix_and_clean_database()
nid_list = ibs.get_valid_nids()
aids_list = ibs.get_name_aids(nid_list)
# remove junk
aids_list = ibs.unflat_map(ibs.filter_junk_annotations, aids_list)
# remove empty
aids_list = [aids for aids in aids_list if len(aids) > 0]
num_annots_list = list(map(len, aids_list))
aids_list = ut.sortedby(aids_list, num_annots_list, reverse=True)
# take only one annot per name
aid_list = ut.get_list_column(aids_list, 0)
# Keep only a certain number of annots for distinctiveness mapping
aid_list_ = ut.listclip(aid_list, max_annots)
logger.info('total num named annots = %r' % (sum(num_annots_list)))
logger.info(
'training distinctiveness using %d/%d singleton annots' %
(len(aid_list_), len(aid_list)))
# vec
# FIXME: qreq_ params for config rowid
vecs_list = ibs.get_annot_vecs(aid_list_)
num_vecs = sum(list(map(len, vecs_list)))
logger.info('num_vecs = %r' % (num_vecs, ))
vecs = np.vstack(vecs_list)
logger.info('vecs size = %r' % (ut.get_object_size_str(vecs), ))
dstcnvs_normer.init_support(vecs)
dstcnvs_normer.save(global_distinctdir)
if ut.get_argflag('--publish'):
dstcnvs_normer.publish()
def dev_train_distinctiveness(species=None):
r"""
Args:
ibs (IBEISController): ibeis controller object
species (None):
CommandLine:
python -m ibeis.algo.hots.distinctiveness_normalizer --test-dev_train_distinctiveness
alias dev_train_distinctiveness='python -m ibeis.algo.hots.distinctiveness_normalizer --test-dev_train_distinctiveness'
# Publishing (uses cached normalizers if available)
dev_train_distinctiveness --species GZ --publish
dev_train_distinctiveness --species PZ --publish
dev_train_distinctiveness --species PZ --retrain
Example:
>>> # DISABLE_DOCTEST
>>> from ibeis.algo.hots.distinctiveness_normalizer import * # NOQA
>>> import ibeis
>>> species = ut.get_argval('--species', str, 'zebra_grevys')
>>> dev_train_distinctiveness(species)
"""
import ibeis
#if 'species' not in vars() or species is None:
# species = 'zebra_grevys'
if species == 'zebra_grevys':
dbname = 'GZ_ALL'
elif species == 'zebra_plains':
dbname = 'PZ_Master0'
ibs = ibeis.opendb(dbname)
global_distinctdir = ibs.get_global_distinctiveness_modeldir()
cachedir = global_distinctdir
dstcnvs_normer = DistinctivnessNormalizer(species, cachedir=cachedir)
try:
if ut.get_argflag('--retrain'):
raise IOError('force cache miss')
with ut.Timer('loading distinctiveness'):
dstcnvs_normer.load(cachedir)
# Cache hit
print('distinctivness model cache hit')
except IOError:
print('distinctivness model cache miss')
with ut.Timer('training distinctiveness'):
# Need to train
# Add one example from each name
# TODO: add one exemplar per viewpoint for each name
#max_vecs = 1E6
#max_annots = 975
max_annots = 975
#ibs.fix_and_clean_database()
nid_list = ibs.get_valid_nids()
aids_list = ibs.get_name_aids(nid_list)
# remove junk
aids_list = ibs.unflat_map(ibs.filter_junk_annotations, aids_list)
# remove empty
aids_list = [aids for aids in aids_list if len(aids) > 0]
num_annots_list = list(map(len, aids_list))
aids_list = ut.sortedby(aids_list, num_annots_list, reverse=True)
# take only one annot per name
aid_list = ut.get_list_column(aids_list, 0)
# Keep only a certain number of annots for distinctiveness mapping
aid_list_ = ut.listclip(aid_list, max_annots)
print('total num named annots = %r' % (sum(num_annots_list)))
print('training distinctiveness using %d/%d singleton annots' %
(len(aid_list_), len(aid_list)))
# vec
# FIXME: qreq_ params for config rowid
vecs_list = ibs.get_annot_vecs(aid_list_)
num_vecs = sum(list(map(len, vecs_list)))
print('num_vecs = %r' % (num_vecs,))
vecs = np.vstack(vecs_list)
print('vecs size = %r' % (ut.get_object_size_str(vecs),))
dstcnvs_normer.init_support(vecs)
dstcnvs_normer.save(global_distinctdir)
if ut.get_argflag('--publish'):
dstcnvs_normer.publish()
def collapse_labels(model, evidence, reduced_variables, reduced_row_idxs,
reduced_values):
import vtool as vt
#assert np.all(reduced_joint.values.ravel() == reduced_joint.values.flatten())
reduced_ttypes = [model.var2_cpd[var].ttype for var in reduced_variables]
evidence_vars = list(evidence.keys())
evidence_state_idxs = ut.dict_take(evidence, evidence_vars)
evidence_ttypes = [model.var2_cpd[var].ttype for var in evidence_vars]
ttype2_ev_indices = dict(zip(*ut.group_indices(evidence_ttypes)))
ttype2_re_indices = dict(zip(*ut.group_indices(reduced_ttypes)))
# ttype2_ev_indices = ut.group_items(range(len(evidence_vars)), evidence_ttypes)
# ttype2_re_indices = ut.group_items(range(len(reduced_variables)), reduced_ttypes)
# Allow specific types of labels to change
# everything is the same, only the names have changed.
# TODO: allow for multiple different label_ttypes
# for label_ttype in label_ttypes
if 'name' not in model.ttype2_template:
return reduced_row_idxs, reduced_values
label_ttypes = ['name']
for label_ttype in label_ttypes:
ev_colxs = ttype2_ev_indices[label_ttype]
re_colxs = ttype2_re_indices[label_ttype]
ev_state_idxs = ut.take(evidence_state_idxs, ev_colxs)
ev_state_idxs_tile = np.tile(ev_state_idxs, (len(reduced_values), 1)).astype(np.int)
num_ev_ = len(ev_colxs)
aug_colxs = list(range(num_ev_)) + (np.array(re_colxs) + num_ev_).tolist()
aug_state_idxs = np.hstack([ev_state_idxs_tile, reduced_row_idxs])
# Relabel rows based on the knowledge that
# everything is the same, only the names have changed.
num_cols = len(aug_state_idxs.T)
mask = vt.index_to_boolmask(aug_colxs, num_cols)
other_colxs, = np.where(~mask)
relbl_states = aug_state_idxs.compress(mask, axis=1)
other_states = aug_state_idxs.compress(~mask, axis=1)
tmp_relbl_states = np.array(list(map(make_temp_state, relbl_states)))
max_tmp_state = -1
min_tmp_state = tmp_relbl_states.min()
# rebuild original state structure with temp state idxs
tmp_state_cols = [None] * num_cols
for count, colx in enumerate(aug_colxs):
tmp_state_cols[colx] = tmp_relbl_states[:, count:count + 1]
for count, colx in enumerate(other_colxs):
tmp_state_cols[colx] = other_states[:, count:count + 1]
tmp_state_idxs = np.hstack(tmp_state_cols)
data_ids = np.array(
vt.compute_unique_data_ids_(list(map(tuple, tmp_state_idxs))))
unique_ids, groupxs = vt.group_indices(data_ids)
print('Collapsed %r states into %r states' % (
len(data_ids), len(unique_ids),))
# Sum the values in the cpd to marginalize the duplicate probs
new_values = np.array([
g.sum() for g in vt.apply_grouping(reduced_values, groupxs)
])
# Take only the unique rows under this induced labeling
unique_tmp_groupxs = np.array(ut.get_list_column(groupxs, 0))
new_aug_state_idxs = tmp_state_idxs.take(unique_tmp_groupxs, axis=0)
tmp_idx_set = set((-np.arange(-max_tmp_state,
(-min_tmp_state) + 1)).tolist())
true_idx_set = set(range(len(model.ttype2_template[label_ttype].basis)))
# Relabel the rows one more time to agree with initial constraints
for colx, true_idx in enumerate(ev_state_idxs):
tmp_idx = np.unique(new_aug_state_idxs.T[colx])
assert len(tmp_idx) == 1
tmp_idx_set -= {tmp_idx[0]}
true_idx_set -= {true_idx}
new_aug_state_idxs[new_aug_state_idxs == tmp_idx] = true_idx
# Relabel the remaining idxs
remain_tmp_idxs = sorted(list(tmp_idx_set))[::-1]
remain_true_idxs = sorted(list(true_idx_set))
for tmp_idx, true_idx in zip(remain_tmp_idxs, remain_true_idxs):
new_aug_state_idxs[new_aug_state_idxs == tmp_idx] = true_idx
# Remove evidence based augmented labels
new_state_idxs = new_aug_state_idxs.T[num_ev_:].T
return new_state_idxs, new_values
