def test_vsone_verified(ibs):
"""
hack in vsone-reranking
Example:
>>> # DISABLE_DOCTEST
>>> from ibeis.all_imports import * # NOQA
>>> #reload_all()
>>> from ibeis.algo.hots.automated_matcher import * # NOQA
>>> import ibeis
>>> ibs = ibeis.opendb('PZ_MTEST')
>>> test_vsone_verified(ibs)
"""
import plottool as pt
#qaids = ibs.get_easy_annot_rowids()
nids = ibs.get_valid_nids(filter_empty=True)
grouped_aids_ = ibs.get_name_aids(nids)
grouped_aids = list(filter(lambda x: len(x) > 1, grouped_aids_))
items_list = grouped_aids
sample_aids = ut.flatten(ut.sample_lists(items_list, num=2, seed=0))
qaid2_qres, qreq_ = query_vsone_verified(ibs, sample_aids, sample_aids)
for cm in ut.InteractiveIter(list(six.itervalues(qaid2_qres))):
pt.close_all_figures()
fig = cm.ishow_top(ibs)
fig.show()
def fix_splits_interaction(ibs):
"""
python -m wbia fix_splits_interaction --show
Example:
>>> # DISABLE_DOCTEST GGR
>>> from wbia.other.dbinfo import * # NOQA
>>> import wbia
>>> dbdir = '/media/danger/GGR/GGR-IBEIS'
>>> dbdir = dbdir if ut.checkpath(dbdir) else ut.truepath('~/lev/media/danger/GGR/GGR-IBEIS')
>>> ibs = wbia.opendb(dbdir=dbdir, allow_newdir=False)
>>> import wbia.guitool as gt
>>> gt.ensure_qtapp()
>>> win = fix_splits_interaction(ibs)
>>> ut.quit_if_noshow()
>>> import wbia.plottool as pt
>>> gt.qtapp_loop(qwin=win)
"""
split_props = {'splitcase', 'photobomb'}
all_annot_groups = ibs._annot_groups(
ibs.group_annots_by_name(ibs.get_valid_aids())[0])
all_has_split = [
len(split_props.intersection(ut.flatten(tags))) > 0
for tags in all_annot_groups.match_tags
]
tosplit_annots = ut.compress(all_annot_groups.annots_list, all_has_split)
tosplit_annots = ut.take(tosplit_annots,
ut.argsort(ut.lmap(len, tosplit_annots)))[::-1]
if ut.get_argflag('--reverse'):
tosplit_annots = tosplit_annots[::-1]
logger.info('len(tosplit_annots) = %r' % (len(tosplit_annots), ))
aids_list = [a.aids for a in tosplit_annots]
from wbia.algo.graph import graph_iden
from wbia.viz import viz_graph2
import wbia.guitool as gt
import wbia.plottool as pt
pt.qt4ensure()
gt.ensure_qtapp()
for aids in ut.InteractiveIter(aids_list):
infr = graph_iden.AnnotInference(ibs, aids)
infr.initialize_graph()
win = viz_graph2.AnnotGraphWidget(infr=infr,
use_image=False,
init_mode='rereview')
win.populate_edge_model()
win.show()
return win
def show_low_support_classes(dset):
"""
dset = merged
coarse = merged
"""
# aid = list(dset.anns.values())[0]['id']
# dset.show_annotation(aid)
dset._remove_keypoint_annotations()
gids = sorted([gid for gid, aids in dset.gid_to_aids.items() if aids])
catfreq = dset.category_annotation_frequency()
inspect_cids = []
for name, freq in catfreq.items():
if freq > 0 and freq < 50:
cid = dset.name_to_cat[name]['id']
inspect_cids.append(cid)
inspect_gids = list(
set(ub.flatten(ub.take(dset.cid_to_gids, inspect_cids))))
# inspect_gids = [gid for gid in inspect_gids if 'habcam' not in dset.imgs[gid]['file_name']]
import utool as ut
if ut.inIPython():
import IPython
IPython.get_ipython().magic('pylab qt5 --no-import-all')
print('inspect_gids = {!r}'.format(inspect_gids))
from matplotlib import pyplot as plt
for gid in ut.InteractiveIter(inspect_gids):
img = dset.imgs[gid]
print('img = {}'.format(ub.repr2(img)))
aids = dset.gid_to_aids[gid]
primary_aid = None
anns = list(ub.take(dset.anns, aids))
for ann in anns:
ann = ann.copy()
ann['category'] = dset.cats[ann['category_id']]['name']
print('ann = {}'.format(ub.repr2(ann)))
if primary_aid is None:
if ann['category_id'] in inspect_cids:
primary_aid = ann['id']
try:
fig = plt.figure(1)
fig.clf()
dset.show_annotation(primary_aid, gid=gid)
fig.canvas.draw()
except Exception:
print('cannot draw')
def test_visualize_vocab_interact():
"""
python -m ibeis.new_annots --exec-test_visualize_vocab_interact --show
Example:
>>> from ibeis.new_annots import * # NOQA
>>> test_visualize_vocab_interact()
>>> ut.show_if_requested()
"""
import plottool as pt
pt.qt4ensure()
ibs, aid_list, vocab = testdata_vocab()
#aid_list = aid_list[0:1]
fstack = StackedFeatures(ibs, aid_list)
nAssign = 2
invassign = fstack.inverted_assignment(vocab, nAssign)
sortx = ut.argsort(invassign.num_list)[::-1]
wx_list = ut.take(invassign.wx_list, sortx)
wx = wx_list[0]
fnum = 1
for wx in ut.InteractiveIter(wx_list):
visualize_vocab_word(ibs, invassign, wx, fnum)
def test_sharpness():
import ibeis
defaltdb = 'seaturtles'
a = ['default']
ibs = ibeis.opendb(defaultdb=defaltdb)
ibs, qaids, daids = ibeis.testdata_expanded_aids(ibs=ibs, a=a)
from vtool import quality_classifier
contrast_list = [
quality_classifier.compute_average_contrast(chip)
for chip in ibs.get_annot_chips(qaids)
]
sortx = ut.argsort(contrast_list)[::-1]
sharpest_qaids = ut.take(qaids, sortx)
aid = sharpest_qaids[0]
ut.ensure_pylab_qt4()
from ibeis import viz
import plottool as pt
for aid in ut.InteractiveIter(sharpest_qaids):
viz.show_chip(ibs, aid, annot=False, nokpts=True)
pt.update()
def smk_plots_main():
"""
smk
python smk_plots.py --db PZ_MTEST --notoolbar
CommandLine:
python -m ibeis.algo.hots.smk.smk_plots --test-smk_plots_main
python -m ibeis.algo.hots.smk.smk_plots --test-smk_plots_main --db PZ_MTEST --notoolbar
Example:
>>> # DISABLE_DOCTEST
>>> from ibeis.algo.hots.smk.smk_plots import * # NOQA
>>> smk_plots_main()
"""
from ibeis.algo.hots.smk import smk_plots
import utool as ut
#from plottool import draw_func2 as df2
kwargs = {
#'db': 'GZ_ALL',
#'db': 'PZ_MTEST',
'db': ut.get_argval('--db', str, default='testdb1'),
'nWords': ut.get_argval('--nWords', int, default=8000),
'delete_rawvecs': False,
}
(ibs, annots_df, daids, qaids, invindex,
qreq_) = smk_debug.testdata_internals_full(**kwargs)
kwargs = {}
aid = 3
#try:
# testdata = ('metrics',)
# metrics = ut.load_testdata(*testdata)
#except Exception as ex:
metrics = smk_plots.compute_word_metrics(invindex)
#ut.save_testdata(*testdata)
valid_aids = ibs.get_valid_aids()
# HACK
if ibs.get_dbname().startswith('GZ_'):
ibs.cfg.detect_cfg.species_text = 'zebra_grevys'
else:
ibs.cfg.detect_cfg.species_text = 'zebra_plains'
# Define the plots you want
startx = ut.get_argval(('--startx', '--x'),
int,
default=min(18,
len(valid_aids) - 1))
for aid in ut.InteractiveIter(valid_aids, startx=startx):
#df2.rrr()
#smk_plots.rrr()
print('[smk_plot] visualizing annotation aid=%r' % (aid, ))
kwargs = smk_plots.main_options()
qres_list = []
qfx2_closest_k_list = []
K_list = kwargs.pop('K_list')
for K in K_list:
qres, qfx2_closest_k = smk_plots.get_qres_and_closest_valid_k(ibs,
aid,
K=K)
qres_list.append(qres)
qfx2_closest_k_list.append(qfx2_closest_k)
smk_plots.viz_annot_with_metrics(
ibs,
invindex,
aid,
metrics,
qfx2_closest_k_list=qfx2_closest_k_list,
qres_list=qres_list,
**kwargs)
smk_plots.present()
def split_analysis(ibs):
"""
CommandLine:
python -m ibeis.other.dbinfo split_analysis --show
python -m ibeis split_analysis --show
python -m ibeis split_analysis --show --good
Ignore:
# mount
sshfs -o idmap=user lev:/ ~/lev
# unmount
fusermount -u ~/lev
Example:
>>> # DISABLE_DOCTEST GGR
>>> from ibeis.other.dbinfo import * # NOQA
>>> import ibeis
>>> dbdir = '/media/danger/GGR/GGR-IBEIS'
>>> dbdir = dbdir if ut.checkpath(dbdir) else ut.truepath('~/lev/media/danger/GGR/GGR-IBEIS')
>>> ibs = ibeis.opendb(dbdir=dbdir, allow_newdir=False)
>>> import guitool_ibeis as gt
>>> gt.ensure_qtapp()
>>> win = split_analysis(ibs)
>>> ut.quit_if_noshow()
>>> import plottool_ibeis as pt
>>> gt.qtapp_loop(qwin=win)
>>> #ut.show_if_requested()
"""
#nid_list = ibs.get_valid_nids(filter_empty=True)
import datetime
day1 = datetime.date(2016, 1, 30)
day2 = datetime.date(2016, 1, 31)
filter_kw = {
'multiple': None,
#'view': ['right'],
#'minqual': 'good',
'is_known': True,
'min_pername': 1,
}
aids1 = ibs.filter_annots_general(filter_kw=ut.dict_union(
filter_kw, {
'min_unixtime': ut.datetime_to_posixtime(ut.date_to_datetime(day1, 0.0)),
'max_unixtime': ut.datetime_to_posixtime(ut.date_to_datetime(day1, 1.0)),
})
)
aids2 = ibs.filter_annots_general(filter_kw=ut.dict_union(
filter_kw, {
'min_unixtime': ut.datetime_to_posixtime(ut.date_to_datetime(day2, 0.0)),
'max_unixtime': ut.datetime_to_posixtime(ut.date_to_datetime(day2, 1.0)),
})
)
all_aids = aids1 + aids2
all_annots = ibs.annots(all_aids)
print('%d annots on day 1' % (len(aids1)) )
print('%d annots on day 2' % (len(aids2)) )
print('%d annots overall' % (len(all_annots)) )
print('%d names overall' % (len(ut.unique(all_annots.nids))) )
nid_list, annots_list = all_annots.group(all_annots.nids)
REVIEWED_EDGES = True
if REVIEWED_EDGES:
aids_list = [annots.aids for annots in annots_list]
#aid_pairs = [annots.get_am_aidpairs() for annots in annots_list] # Slower
aid_pairs = ibs.get_unflat_am_aidpairs(aids_list) # Faster
else:
# ALL EDGES
aid_pairs = [annots.get_aidpairs() for annots in annots_list]
speeds_list = ibs.unflat_map(ibs.get_annotpair_speeds, aid_pairs)
import vtool_ibeis as vt
max_speeds = np.array([vt.safe_max(s, nans=False) for s in speeds_list])
nan_idx = np.where(np.isnan(max_speeds))[0]
inf_idx = np.where(np.isinf(max_speeds))[0]
bad_idx = sorted(ut.unique(ut.flatten([inf_idx, nan_idx])))
ok_idx = ut.index_complement(bad_idx, len(max_speeds))
print('#nan_idx = %r' % (len(nan_idx),))
print('#inf_idx = %r' % (len(inf_idx),))
print('#ok_idx = %r' % (len(ok_idx),))
ok_speeds = max_speeds[ok_idx]
ok_nids = ut.take(nid_list, ok_idx)
ok_annots = ut.take(annots_list, ok_idx)
sortx = np.argsort(ok_speeds)[::-1]
sorted_speeds = np.array(ut.take(ok_speeds, sortx))
sorted_annots = np.array(ut.take(ok_annots, sortx))
sorted_nids = np.array(ut.take(ok_nids, sortx)) # NOQA
sorted_speeds = np.clip(sorted_speeds, 0, 100)
#idx = vt.find_elbow_point(sorted_speeds)
#EXCESSIVE_SPEED = sorted_speeds[idx]
# http://www.infoplease.com/ipa/A0004737.html
# http://www.speedofanimals.com/animals/zebra
#ZEBRA_SPEED_MAX = 64 # km/h
#ZEBRA_SPEED_RUN = 50 # km/h
ZEBRA_SPEED_SLOW_RUN = 20 # km/h
#ZEBRA_SPEED_FAST_WALK = 10 # km/h
#ZEBRA_SPEED_WALK = 7 # km/h
MAX_SPEED = ZEBRA_SPEED_SLOW_RUN
#MAX_SPEED = ZEBRA_SPEED_WALK
#MAX_SPEED = EXCESSIVE_SPEED
flags = sorted_speeds > MAX_SPEED
flagged_ok_annots = ut.compress(sorted_annots, flags)
inf_annots = ut.take(annots_list, inf_idx)
flagged_annots = inf_annots + flagged_ok_annots
print('MAX_SPEED = %r km/h' % (MAX_SPEED,))
print('%d annots with infinite speed' % (len(inf_annots),))
print('%d annots with large speed' % (len(flagged_ok_annots),))
print('Marking all pairs of annots above the threshold as non-matching')
from ibeis.algo.graph import graph_iden
import networkx as nx
progkw = dict(freq=1, bs=True, est_window=len(flagged_annots))
bad_edges_list = []
good_edges_list = []
for annots in ut.ProgIter(flagged_annots, lbl='flag speeding names', **progkw):
edge_to_speeds = annots.get_speeds()
bad_edges = [edge for edge, speed in edge_to_speeds.items() if speed > MAX_SPEED]
good_edges = [edge for edge, speed in edge_to_speeds.items() if speed <= MAX_SPEED]
bad_edges_list.append(bad_edges)
good_edges_list.append(good_edges)
all_bad_edges = ut.flatten(bad_edges_list)
good_edges_list = ut.flatten(good_edges_list)
print('num_bad_edges = %r' % (len(ut.flatten(bad_edges_list)),))
print('num_bad_edges = %r' % (len(ut.flatten(good_edges_list)),))
if 1:
from ibeis.viz import viz_graph2
import guitool_ibeis as gt
gt.ensure_qtapp()
if ut.get_argflag('--good'):
print('Looking at GOOD (no speed problems) edges')
aid_pairs = good_edges_list
else:
print('Looking at BAD (speed problems) edges')
aid_pairs = all_bad_edges
aids = sorted(list(set(ut.flatten(aid_pairs))))
infr = graph_iden.AnnotInference(ibs, aids, verbose=False)
infr.initialize_graph()
# Use random scores to randomize sort order
rng = np.random.RandomState(0)
scores = (-rng.rand(len(aid_pairs)) * 10).tolist()
infr.graph.add_edges_from(aid_pairs)
if True:
edge_sample_size = 250
pop_nids = ut.unique(ibs.get_annot_nids(ut.unique(ut.flatten(aid_pairs))))
sorted_pairs = ut.sortedby(aid_pairs, scores)[::-1][0:edge_sample_size]
sorted_nids = ibs.get_annot_nids(ut.take_column(sorted_pairs, 0))
sample_size = len(ut.unique(sorted_nids))
am_rowids = ibs.get_annotmatch_rowid_from_undirected_superkey(*zip(*sorted_pairs))
flags = ut.not_list(ut.flag_None_items(am_rowids))
#am_rowids = ut.compress(am_rowids, flags)
positive_tags = ['SplitCase', 'Photobomb']
flags_list = [ut.replace_nones(ibs.get_annotmatch_prop(tag, am_rowids), 0)
for tag in positive_tags]
print('edge_case_hist: ' + ut.repr3(
['%s %s' % (txt, sum(flags_)) for flags_, txt in zip(flags_list, positive_tags)]))
is_positive = ut.or_lists(*flags_list)
num_positive = sum(ut.lmap(any, ut.group_items(is_positive, sorted_nids).values()))
pop = len(pop_nids)
print('A positive is any edge flagged as a %s' % (ut.conj_phrase(positive_tags, 'or'),))
print('--- Sampling wrt edges ---')
print('edge_sample_size = %r' % (edge_sample_size,))
print('edge_population_size = %r' % (len(aid_pairs),))
print('num_positive_edges = %r' % (sum(is_positive)))
print('--- Sampling wrt names ---')
print('name_population_size = %r' % (pop,))
vt.calc_error_bars_from_sample(sample_size, num_positive, pop, conf_level=.95)
nx.set_edge_attributes(infr.graph, name='score', values=dict(zip(aid_pairs, scores)))
win = viz_graph2.AnnotGraphWidget(infr=infr, use_image=False,
init_mode=None)
win.populate_edge_model()
win.show()
return win
# Make review interface for only bad edges
infr_list = []
iter_ = list(zip(flagged_annots, bad_edges_list))
for annots, bad_edges in ut.ProgIter(iter_, lbl='creating inference', **progkw):
aids = annots.aids
nids = [1] * len(aids)
infr = graph_iden.AnnotInference(ibs, aids, nids, verbose=False)
infr.initialize_graph()
infr.reset_feedback()
infr_list.append(infr)
# Check which ones are user defined as incorrect
#num_positive = 0
#for infr in infr_list:
# flag = np.any(infr.get_feedback_probs()[0] == 0)
# num_positive += flag
#print('num_positive = %r' % (num_positive,))
#pop = len(infr_list)
#print('pop = %r' % (pop,))
iter_ = list(zip(infr_list, bad_edges_list))
for infr, bad_edges in ut.ProgIter(iter_, lbl='adding speed edges', **progkw):
flipped_edges = []
for aid1, aid2 in bad_edges:
if infr.graph.has_edge(aid1, aid2):
flipped_edges.append((aid1, aid2))
infr.add_feedback((aid1, aid2), NEGTV)
nx.set_edge_attributes(infr.graph, name='_speed_split', values='orig')
nx.set_edge_attributes(infr.graph, name='_speed_split', values={edge: 'new' for edge in bad_edges})
nx.set_edge_attributes(infr.graph, name='_speed_split', values={edge: 'flip' for edge in flipped_edges})
#for infr in ut.ProgIter(infr_list, lbl='flagging speeding edges', **progkw):
# annots = ibs.annots(infr.aids)
# edge_to_speeds = annots.get_speeds()
# bad_edges = [edge for edge, speed in edge_to_speeds.items() if speed > MAX_SPEED]
def inference_stats(infr_list_):
relabel_stats = []
for infr in infr_list_:
num_ccs, num_inconsistent = infr.relabel_using_reviews()
state_hist = ut.dict_hist(nx.get_edge_attributes(infr.graph, 'decision').values())
if POSTV not in state_hist:
state_hist[POSTV] = 0
hist = ut.dict_hist(nx.get_edge_attributes(infr.graph, '_speed_split').values())
subgraphs = infr.positive_connected_compoments()
subgraph_sizes = [len(g) for g in subgraphs]
info = ut.odict([
('num_nonmatch_edges', state_hist[NEGTV]),
('num_match_edges', state_hist[POSTV]),
('frac_nonmatch_edges', state_hist[NEGTV] / (state_hist[POSTV] + state_hist[NEGTV])),
('num_inconsistent', num_inconsistent),
('num_ccs', num_ccs),
('edges_flipped', hist.get('flip', 0)),
('edges_unchanged', hist.get('orig', 0)),
('bad_unreviewed_edges', hist.get('new', 0)),
('orig_size', len(infr.graph)),
('new_sizes', subgraph_sizes),
])
relabel_stats.append(info)
return relabel_stats
relabel_stats = inference_stats(infr_list)
print('\nAll Split Info:')
lines = []
for key in relabel_stats[0].keys():
data = ut.take_column(relabel_stats, key)
if key == 'new_sizes':
data = ut.flatten(data)
lines.append('stats(%s) = %s' % (key, ut.repr2(ut.get_stats(data, use_median=True), precision=2)))
print('\n'.join(ut.align_lines(lines, '=')))
num_incon_list = np.array(ut.take_column(relabel_stats, 'num_inconsistent'))
can_split_flags = num_incon_list == 0
print('Can trivially split %d / %d' % (sum(can_split_flags), len(can_split_flags)))
splittable_infrs = ut.compress(infr_list, can_split_flags)
relabel_stats = inference_stats(splittable_infrs)
print('\nTrival Split Info:')
lines = []
for key in relabel_stats[0].keys():
if key in ['num_inconsistent']:
continue
data = ut.take_column(relabel_stats, key)
if key == 'new_sizes':
data = ut.flatten(data)
lines.append('stats(%s) = %s' % (
key, ut.repr2(ut.get_stats(data, use_median=True), precision=2)))
print('\n'.join(ut.align_lines(lines, '=')))
num_match_edges = np.array(ut.take_column(relabel_stats, 'num_match_edges'))
num_nonmatch_edges = np.array(ut.take_column(relabel_stats, 'num_nonmatch_edges'))
flags1 = np.logical_and(num_match_edges > num_nonmatch_edges, num_nonmatch_edges < 3)
reasonable_infr = ut.compress(splittable_infrs, flags1)
new_sizes_list = ut.take_column(relabel_stats, 'new_sizes')
flags2 = [len(sizes) == 2 and sum(sizes) > 4 and (min(sizes) / max(sizes)) > .3
for sizes in new_sizes_list]
reasonable_infr = ut.compress(splittable_infrs, flags2)
print('#reasonable_infr = %r' % (len(reasonable_infr),))
for infr in ut.InteractiveIter(reasonable_infr):
annots = ibs.annots(infr.aids)
edge_to_speeds = annots.get_speeds()
print('max_speed = %r' % (max(edge_to_speeds.values())),)
infr.initialize_visual_node_attrs()
infr.show_graph(use_image=True, only_reviewed=True)
rest = ~np.logical_or(flags1, flags2)
nonreasonable_infr = ut.compress(splittable_infrs, rest)
rng = np.random.RandomState(0)
random_idx = ut.random_indexes(len(nonreasonable_infr) - 1, 15, rng=rng)
random_infr = ut.take(nonreasonable_infr, random_idx)
for infr in ut.InteractiveIter(random_infr):
annots = ibs.annots(infr.aids)
edge_to_speeds = annots.get_speeds()
print('max_speed = %r' % (max(edge_to_speeds.values())),)
infr.initialize_visual_node_attrs()
infr.show_graph(use_image=True, only_reviewed=True)
#import scipy.stats as st
#conf_interval = .95
#st.norm.cdf(conf_interval)
# view-source:http://www.surveysystem.com/sscalc.htm
#zval = 1.96 # 95 percent confidence
#zValC = 3.8416 #
#zValC = 6.6564
#import statsmodels.stats.api as sms
#es = sms.proportion_effectsize(0.5, 0.75)
#sms.NormalIndPower().solve_power(es, power=0.9, alpha=0.05, ratio=1)
pop = 279
num_positive = 3
sample_size = 15
conf_level = .95
#conf_level = .99
vt.calc_error_bars_from_sample(sample_size, num_positive, pop, conf_level)
print('---')
vt.calc_error_bars_from_sample(sample_size + 38, num_positive, pop, conf_level)
print('---')
vt.calc_error_bars_from_sample(sample_size + 38 / 3, num_positive, pop, conf_level)
print('---')
vt.calc_error_bars_from_sample(15 + 38, num_positive=3, pop=675, conf_level=.95)
vt.calc_error_bars_from_sample(15, num_positive=3, pop=675, conf_level=.95)
pop = 279
#err_frac = .05 # 5%
err_frac = .10 # 10%
conf_level = .95
vt.calc_sample_from_error_bars(err_frac, pop, conf_level)
pop = 675
vt.calc_sample_from_error_bars(err_frac, pop, conf_level)
vt.calc_sample_from_error_bars(.05, pop, conf_level=.95, prior=.1)
vt.calc_sample_from_error_bars(.05, pop, conf_level=.68, prior=.2)
vt.calc_sample_from_error_bars(.10, pop, conf_level=.68)
vt.calc_error_bars_from_sample(100, num_positive=5, pop=675, conf_level=.95)
vt.calc_error_bars_from_sample(100, num_positive=5, pop=675, conf_level=.68)
def predict():
"""
Currently hacked in due to limited harness support.
srun -c 4 -p priority --gres=gpu:1 \
python ~/code/baseline-viame-2018/yolo_viame.py predict \
--gpu=0
"""
# HACK: Load the training dataset to extract the categories
# INSTEAD: Should read the categories from a deployed model
coco_dsets = load_coco_datasets()
categories = coco_dsets['train'].dataset['categories']
# Create a dataset to iterate through the images to predict on
test_gpaths = glob.glob(ub.truepath('~/data/noaa/test_data/*/*.png'))
predict_coco_dataset = {
'licenses': [],
'info': [],
'categories':
categories,
'images': [{
'id': idx,
'file_name': fpath,
} for idx, fpath in enumerate(test_gpaths)],
'annotations': [],
}
predict_coco_dset = coco_api.CocoDataset(predict_coco_dataset,
tag='predict')
predict_dset = YoloCocoDataset(predict_coco_dset, train=False)
# HACK: Define the path to the model weights
# INSTEAD: best weights should be packaged in a model deployment
load_path = ub.truepath(
'~/work/viame/yolo/fit/nice/baseline1/best_snapshot.pt')
# load_path = ub.truepath(
# '~/work/viame/yolo/fit/nice/baseline1/torch_snapshots/_epoch_00000080.pt')
# HACK: Define the model topology (because we know what we trained with)
# INSTEAD: model deployment should store and abstract away the topology
model = light_yolo.Yolo(
**{
'num_classes':
predict_dset.num_classes,
'anchors':
np.asarray([(1.08, 1.19), (3.42,
4.41), (6.63,
11.38), (9.42,
5.11), (16.62, 10.52)],
dtype=np.float),
'conf_thresh':
0.001,
'nms_thresh':
0.5,
})
# Boilerplate code that could be abstracted away in a prediction harness
xpu = nh.XPU.cast('gpu')
print('xpu = {!r}'.format(xpu))
model = xpu.mount(model)
snapshot_state = xpu.load(load_path)
model.load_state_dict(snapshot_state['model_state_dict'])
batch_size = 16
workers = 4
predict_loader = predict_dset.make_loader(batch_size=batch_size,
num_workers=workers,
shuffle=False,
pin_memory=False)
letterbox = predict_dset.letterbox
# HACK: Main prediction loop
# INSTEAD: Use a prediction harness to abstract these in a similar way to
# the fit harness.
predictions = []
with nh.util.grad_context(False):
_iter = ub.ProgIter(predict_loader, desc='predicting')
for bx, raw_batch in enumerate(_iter):
batch_inputs, batch_labels = raw_batch
inputs = xpu.variable(batch_inputs)
labels = {k: xpu.variable(d) for k, d in batch_labels.items()}
outputs = model(inputs)
# Transform yolo outputs into the coco format
postout = model.module.postprocess(outputs)
indices = labels['indices']
orig_sizes = labels['orig_sizes']
inp_size = np.array(inputs.shape[-2:][::-1])
bsize = len(inputs)
for ix in range(bsize):
postitem = postout[ix].data.cpu().numpy()
orig_size = orig_sizes[ix].data.cpu().numpy()
gx = int(indices[ix].data.cpu().numpy())
gid = predict_dset.dset.dataset['images'][gx]['id']
# Unpack postprocessed predictions
sboxes = postitem.reshape(-1, 6)
pred_cxywh = sboxes[:, 0:4]
pred_scores = sboxes[:, 4]
pred_cxs = sboxes[:, 5].astype(np.int)
sortx = pred_scores.argsort()
pred_scores = pred_scores.take(sortx)
pred_cxs = pred_cxs.take(sortx)
pred_cxywh = pred_cxywh.take(sortx, axis=0)
norm_boxes = nh.util.Boxes(pred_cxywh, 'cxywh')
boxes = norm_boxes.scale(inp_size)
pred_box = letterbox._boxes_letterbox_invert(
boxes, orig_size, inp_size)
pred_box = pred_box.clip(0, 0, orig_size[0], orig_size[1])
pred_xywh = pred_box.toformat('xywh').data
# print(ub.repr2(pred_cxywh.tolist(), precision=2))
# print(ub.repr2(pred_xywh.tolist(), precision=2))
for xywh, cx, score in zip(pred_xywh, pred_cxs, pred_scores):
if score > 0.1:
cid = predict_dset.dset.dataset['categories'][cx]['id']
pred = {
'id': len(predictions) + 1,
'image_id': gid,
'category_id': cid,
'bbox': list(xywh),
'score': score,
}
predictions.append(pred)
# if bx > 1:
# break
predict_coco_dset.dataset['annotations'] = predictions
predict_coco_dset._build_index()
with open('./viame_pred_dump.mscoco.json') as file:
predict_coco_dset.dump(file)
if False:
import utool as ut
from matplotlib import pyplot as plt
gids = set([a['image_id'] for a in predict_coco_dset.anns.values()])
for gid in ut.InteractiveIter(list(gids)):
try:
fig = plt.figure(1)
fig.clf()
predict_coco_dset.show_annotation(gid=gid)
fig.canvas.draw()
except Exception:
print('cannot draw')
z = inputs[0].cpu().numpy().transpose(1, 2, 0)
nh.util.imshow(z, fnum=2, colorspace='rgb')
def ggr_random_name_splits():
"""
CommandLine:
python -m wbia.viz.viz_graph2 ggr_random_name_splits --show
Ignore:
sshfs -o idmap=user lev:/ ~/lev
Example:
>>> # DISABLE_DOCTEST
>>> from wbia.viz.viz_graph2 import * # NOQA
>>> ggr_random_name_splits()
"""
import wbia.guitool as gt
gt.ensure_qtapp()
# nid_list = ibs.get_valid_nids(filter_empty=True)
import wbia
dbdir = '/media/danger/GGR/GGR-IBEIS'
dbdir = (dbdir if ut.checkpath(dbdir) else
ut.truepath('~/lev/media/danger/GGR/GGR-IBEIS'))
ibs = wbia.opendb(dbdir=dbdir, allow_newdir=False)
import datetime
day1 = datetime.date(2016, 1, 30)
day2 = datetime.date(2016, 1, 31)
orig_filter_kw = {
'multiple': None,
# 'view': ['right'],
# 'minqual': 'good',
'is_known': True,
'min_pername': 2,
}
orig_aids = ibs.filter_annots_general(filter_kw=ut.dict_union(
orig_filter_kw,
{
'min_unixtime':
ut.datetime_to_posixtime(ut.date_to_datetime(day1, 0.0)),
'max_unixtime':
ut.datetime_to_posixtime(ut.date_to_datetime(day2, 1.0)),
},
))
orig_all_annots = ibs.annots(orig_aids)
orig_unique_nids, orig_grouped_annots_ = orig_all_annots.group(
orig_all_annots.nids)
# Ensure we get everything
orig_grouped_annots = [
ibs.annots(aids_) for aids_ in ibs.get_name_aids(orig_unique_nids)
]
# pip install quantumrandom
if False:
import quantumrandom
data = quantumrandom.uint16()
seed = data.sum()
print('seed = %r' % (seed, ))
# import Crypto.Random
# from Crypto import Random
# quantumrandom.get_data()
# StrongRandom = Crypto.Random.random.StrongRandom
# aes.reseed(3340258)
# chars = [str(chr(x)) for x in data.view(np.uint8)]
# aes_seed = str('').join(chars)
# aes = Crypto.Random.Fortuna.FortunaGenerator.AESGenerator()
# aes.reseed(aes_seed)
# aes.pseudo_random_data(10)
orig_rand_idxs = ut.random_indexes(len(orig_grouped_annots), seed=3340258)
orig_sample_size = 75
random_annot_groups = ut.take(orig_grouped_annots, orig_rand_idxs)
orig_annot_sample = random_annot_groups[:orig_sample_size]
# OOOPS MADE ERROR REDO ----
filter_kw = {
'multiple': None,
'view': ['right'],
'minqual': 'good',
'is_known': True,
'min_pername': 2,
}
filter_kw_ = ut.dict_union(
filter_kw,
{
'min_unixtime':
ut.datetime_to_posixtime(ut.date_to_datetime(day1, 0.0)),
'max_unixtime':
ut.datetime_to_posixtime(ut.date_to_datetime(day2, 1.0)),
},
)
refiltered_sample = [
ibs.filter_annots_general(annot.aids, filter_kw=filter_kw_)
for annot in orig_annot_sample
]
is_ok = np.array(ut.lmap(len, refiltered_sample)) >= 2
ok_part_orig_sample = ut.compress(orig_annot_sample, is_ok)
ok_part_orig_nids = [x.nids[0] for x in ok_part_orig_sample]
# Now compute real sample
aids = ibs.filter_annots_general(filter_kw=filter_kw_)
all_annots = ibs.annots(aids)
unique_nids, grouped_annots_ = all_annots.group(all_annots.nids)
grouped_annots = grouped_annots_
# Ensure we get everything
# grouped_annots = [ibs.annots(aids_) for aids_ in ibs.get_name_aids(unique_nids)]
pop = len(grouped_annots)
pername_list = ut.lmap(len, grouped_annots)
groups = wbia.annots.AnnotGroups(grouped_annots, ibs)
match_tags = [ut.unique(ut.flatten(t)) for t in groups.match_tags]
tag_case_hist = ut.dict_hist(ut.flatten(match_tags))
print('name_pop = %r' % (pop, ))
print('Annots per Multiton Name' +
ut.repr3(ut.get_stats(pername_list, use_median=True)))
print('Name Tag Hist ' + ut.repr3(tag_case_hist))
print('Percent Photobomb: %.2f%%' %
(tag_case_hist['photobomb'] / pop * 100))
print('Percent Split: %.2f%%' % (tag_case_hist['splitcase'] / pop * 100))
# Remove the ok part from this sample
remain_unique_nids = ut.setdiff(unique_nids, ok_part_orig_nids)
remain_grouped_annots = [
ibs.annots(aids_) for aids_ in ibs.get_name_aids(remain_unique_nids)
]
sample_size = 75
import vtool as vt
vt.calc_sample_from_error_bars(0.05, pop, conf_level=0.95, prior=0.05)
remain_rand_idxs = ut.random_indexes(len(remain_grouped_annots),
seed=3340258)
remain_sample_size = sample_size - len(ok_part_orig_nids)
remain_random_annot_groups = ut.take(remain_grouped_annots,
remain_rand_idxs)
remain_annot_sample = remain_random_annot_groups[:remain_sample_size]
annot_sample_nofilter = ok_part_orig_sample + remain_annot_sample
# Filter out all bad parts
annot_sample_filter = [
ibs.annots(ibs.filter_annots_general(annot.aids, filter_kw=filter_kw_))
for annot in annot_sample_nofilter
]
annot_sample = annot_sample_filter
win = None
from wbia.viz import viz_graph2
for annots in ut.InteractiveIter(annot_sample):
if win is not None:
win.close()
win = viz_graph2.make_qt_graph_interface(ibs,
aids=annots.aids,
init_mode='rereview')
print(win)
sample_groups = wbia.annots.AnnotGroups(annot_sample, ibs)
flat_tags = [ut.unique(ut.flatten(t)) for t in sample_groups.match_tags]
print('Using Split and Photobomb')
is_positive = ['photobomb' in t or 'splitcase' in t for t in flat_tags]
num_positive = sum(is_positive)
vt.calc_error_bars_from_sample(sample_size,
num_positive,
pop,
conf_level=0.95)
print('Only Photobomb')
is_positive = ['photobomb' in t for t in flat_tags]
num_positive = sum(is_positive)
vt.calc_error_bars_from_sample(sample_size,
num_positive,
pop,
conf_level=0.95)
print('Only SplitCase')
is_positive = ['splitcase' in t for t in flat_tags]
num_positive = sum(is_positive)
vt.calc_error_bars_from_sample(sample_size,
num_positive,
pop,
conf_level=0.95)
def get_injured_sharks():
"""
>>> from wbia.scripts.getshark import * # NOQA
"""
import requests
url = 'http://www.whaleshark.org/getKeywordImages.jsp'
resp = requests.get(url)
assert resp.status_code == 200
keywords = resp.json()['keywords']
key_list = ut.take_column(keywords, 'indexName')
key_to_nice = {k['indexName']: k['readableName'] for k in keywords}
injury_patterns = [
'injury',
'net',
'hook',
'trunc',
'damage',
'scar',
'nicks',
'bite',
]
injury_keys = [
key for key in key_list if any([pat in key for pat in injury_patterns])
]
noninjury_keys = ut.setdiff(key_list, injury_keys)
injury_nice = ut.lmap(lambda k: key_to_nice[k], injury_keys) # NOQA
noninjury_nice = ut.lmap(lambda k: key_to_nice[k], noninjury_keys) # NOQA
key_list = injury_keys
keyed_images = {}
for key in ut.ProgIter(key_list, lbl='reading index', bs=True):
key_url = url + '?indexName={indexName}'.format(indexName=key)
key_resp = requests.get(key_url)
assert key_resp.status_code == 200
key_imgs = key_resp.json()['images']
keyed_images[key] = key_imgs
key_hist = {key: len(imgs) for key, imgs in keyed_images.items()}
key_hist = ut.sort_dict(key_hist, 'vals')
logger.info(ut.repr3(key_hist))
nice_key_hist = ut.map_dict_keys(lambda k: key_to_nice[k], key_hist)
nice_key_hist = ut.sort_dict(nice_key_hist, 'vals')
logger.info(ut.repr3(nice_key_hist))
key_to_urls = {
key: ut.take_column(vals, 'url')
for key, vals in keyed_images.items()
}
overlaps = {}
import itertools
overlap_img_list = []
for k1, k2 in itertools.combinations(key_to_urls.keys(), 2):
overlap_imgs = ut.isect(key_to_urls[k1], key_to_urls[k2])
num_overlap = len(overlap_imgs)
overlaps[(k1, k2)] = num_overlap
overlaps[(k1, k1)] = len(key_to_urls[k1])
if num_overlap > 0:
# logger.info('[%s][%s], overlap=%r' % (k1, k2, num_overlap))
overlap_img_list.extend(overlap_imgs)
all_img_urls = list(set(ut.flatten(key_to_urls.values())))
num_all = len(all_img_urls) # NOQA
logger.info('num_all = %r' % (num_all, ))
# Determine super-categories
categories = ['nicks', 'scar', 'trunc']
# Force these keys into these categories
key_to_cat = {'scarbite': 'other_injury'}
cat_to_keys = ut.ddict(list)
for key in key_to_urls.keys():
flag = 1
if key in key_to_cat:
cat = key_to_cat[key]
cat_to_keys[cat].append(key)
continue
for cat in categories:
if cat in key:
cat_to_keys[cat].append(key)
flag = 0
if flag:
cat = 'other_injury'
cat_to_keys[cat].append(key)
cat_urls = ut.ddict(list)
for cat, keys in cat_to_keys.items():
for key in keys:
cat_urls[cat].extend(key_to_urls[key])
cat_hist = {}
for cat in list(cat_urls.keys()):
cat_urls[cat] = list(set(cat_urls[cat]))
cat_hist[cat] = len(cat_urls[cat])
logger.info(ut.repr3(cat_to_keys))
logger.info(ut.repr3(cat_hist))
key_to_cat = dict([(val, key) for key, vals in cat_to_keys.items()
for val in vals])
# ingestset = {
# '__class__': 'ImageSet',
# 'images': ut.ddict(dict)
# }
# for key, key_imgs in keyed_images.items():
# for imgdict in key_imgs:
# url = imgdict['url']
# encid = imgdict['correspondingEncounterNumber']
# # Make structure
# encdict = encounters[encid]
# encdict['__class__'] = 'Encounter'
# imgdict = ut.delete_keys(imgdict.copy(), ['correspondingEncounterNumber'])
# imgdict['__class__'] = 'Image'
# cat = key_to_cat[key]
# annotdict = {'relative_bbox': [.01, .01, .98, .98], 'tags': [cat, key]}
# annotdict['__class__'] = 'Annotation'
# # Ensure structures exist
# encdict['images'] = encdict.get('images', [])
# imgdict['annots'] = imgdict.get('annots', [])
# # Add an image to this encounter
# encdict['images'].append(imgdict)
# # Add an annotation to this image
# imgdict['annots'].append(annotdict)
# # http://springbreak.wildbook.org/rest/org.ecocean.Encounter/1111
# get_enc_url = 'http://www.whaleshark.org/rest/org.ecocean.Encounter/%s' % (encid,)
# resp = requests.get(get_enc_url)
# logger.info(ut.repr3(encdict))
# logger.info(ut.repr3(encounters))
# Download the files to the local disk
# fpath_list =
all_urls = ut.unique(
ut.take_column(
ut.flatten(
ut.dict_subset(keyed_images,
ut.flatten(cat_to_keys.values())).values()),
'url',
))
dldir = ut.truepath('~/tmpsharks')
from os.path import commonprefix, basename # NOQA
prefix = commonprefix(all_urls)
suffix_list = [url_[len(prefix):] for url_ in all_urls]
fname_list = [suffix.replace('/', '--') for suffix in suffix_list]
fpath_list = []
for url, fname in ut.ProgIter(zip(all_urls, fname_list),
lbl='downloading imgs',
freq=1):
fpath = ut.grab_file_url(url,
download_dir=dldir,
fname=fname,
verbose=False)
fpath_list.append(fpath)
# Make sure we keep orig info
# url_to_keys = ut.ddict(list)
url_to_info = ut.ddict(dict)
for key, imgdict_list in keyed_images.items():
for imgdict in imgdict_list:
url = imgdict['url']
info = url_to_info[url]
for k, v in imgdict.items():
info[k] = info.get(k, [])
info[k].append(v)
info['keys'] = info.get('keys', [])
info['keys'].append(key)
# url_to_keys[url].append(key)
info_list = ut.take(url_to_info, all_urls)
for info in info_list:
if len(set(info['correspondingEncounterNumber'])) > 1:
assert False, 'url with two different encounter nums'
# Combine duplicate tags
hashid_list = [
ut.get_file_uuid(fpath_, stride=8)
for fpath_ in ut.ProgIter(fpath_list, bs=True)
]
groupxs = ut.group_indices(hashid_list)[1]
# Group properties by duplicate images
# groupxs = [g for g in groupxs if len(g) > 1]
fpath_list_ = ut.take_column(ut.apply_grouping(fpath_list, groupxs), 0)
url_list_ = ut.take_column(ut.apply_grouping(all_urls, groupxs), 0)
info_list_ = [
ut.map_dict_vals(ut.flatten, ut.dict_accum(*info_))
for info_ in ut.apply_grouping(info_list, groupxs)
]
encid_list_ = [
ut.unique(info_['correspondingEncounterNumber'])[0]
for info_ in info_list_
]
keys_list_ = [ut.unique(info_['keys']) for info_ in info_list_]
cats_list_ = [ut.unique(ut.take(key_to_cat, keys)) for keys in keys_list_]
clist = ut.ColumnLists({
'gpath': fpath_list_,
'url': url_list_,
'encid': encid_list_,
'key': keys_list_,
'cat': cats_list_,
})
# for info_ in ut.apply_grouping(info_list, groupxs):
# info = ut.dict_accum(*info_)
# info = ut.map_dict_vals(ut.flatten, info)
# x = ut.unique(ut.flatten(ut.dict_accum(*info_)['correspondingEncounterNumber']))
# if len(x) > 1:
# info = info.copy()
# del info['keys']
# logger.info(ut.repr3(info))
flags = ut.lmap(ut.fpath_has_imgext, clist['gpath'])
clist = clist.compress(flags)
import wbia
ibs = wbia.opendb('WS_Injury', allow_newdir=True)
gid_list = ibs.add_images(clist['gpath'])
clist['gid'] = gid_list
failed_flags = ut.flag_None_items(clist['gid'])
logger.info('# failed %s' % (sum(failed_flags), ))
passed_flags = ut.not_list(failed_flags)
clist = clist.compress(passed_flags)
ut.assert_all_not_None(clist['gid'])
# ibs.get_image_uris_original(clist['gid'])
ibs.set_image_uris_original(clist['gid'], clist['url'], overwrite=True)
# ut.zipflat(clist['cat'], clist['key'])
if False:
# Can run detection instead
clist['tags'] = ut.zipflat(clist['cat'])
aid_list = ibs.use_images_as_annotations(clist['gid'],
adjust_percent=0.01,
tags_list=clist['tags'])
aid_list
import wbia.plottool as pt
from wbia import core_annots
pt.qt4ensure()
# annots = ibs.annots()
# aids = [1, 2]
# ibs.depc_annot.get('hog', aids , 'hog')
# ibs.depc_annot.get('chip', aids, 'img')
for aid in ut.InteractiveIter(ibs.get_valid_aids()):
hogs = ibs.depc_annot.d.get_hog_hog([aid])
chips = ibs.depc_annot.d.get_chips_img([aid])
chip = chips[0]
hogimg = core_annots.make_hog_block_image(hogs[0])
pt.clf()
pt.imshow(hogimg, pnum=(1, 2, 1))
pt.imshow(chip, pnum=(1, 2, 2))
fig = pt.gcf()
fig.show()
fig.canvas.draw()
# logger.info(len(groupxs))
# if False:
# groupxs = ut.find_duplicate_items(ut.lmap(basename, suffix_list)).values()
# logger.info(ut.repr3(ut.apply_grouping(all_urls, groupxs)))
# # FIX
# for fpath, fname in zip(fpath_list, fname_list):
# if ut.checkpath(fpath):
# ut.move(fpath, join(dirname(fpath), fname))
# logger.info('fpath = %r' % (fpath,))
# import wbia
# from wbia.dbio import ingest_dataset
# dbdir = wbia.sysres.lookup_dbdir('WS_ALL')
# self = ingest_dataset.Ingestable2(dbdir)
if False:
# Show overlap matrix
import wbia.plottool as pt
import pandas as pd
import numpy as np
dict_ = overlaps
s = pd.Series(dict_, index=pd.MultiIndex.from_tuples(overlaps))
df = s.unstack()
lhs, rhs = df.align(df.T)
df = lhs.add(rhs, fill_value=0).fillna(0)
label_texts = df.columns.values
def label_ticks(label_texts):
import wbia.plottool as pt
truncated_labels = [repr(lbl[0:100]) for lbl in label_texts]
ax = pt.gca()
ax.set_xticks(list(range(len(label_texts))))
ax.set_xticklabels(truncated_labels)
[lbl.set_rotation(-55) for lbl in ax.get_xticklabels()]
[
lbl.set_horizontalalignment('left')
for lbl in ax.get_xticklabels()
]
# xgrid, ygrid = np.meshgrid(range(len(label_texts)), range(len(label_texts)))
# pt.plot_surface3d(xgrid, ygrid, disjoint_mat)
ax.set_yticks(list(range(len(label_texts))))
ax.set_yticklabels(truncated_labels)
[
lbl.set_horizontalalignment('right')
for lbl in ax.get_yticklabels()
]
[
lbl.set_verticalalignment('center')
for lbl in ax.get_yticklabels()
]
# [lbl.set_rotation(20) for lbl in ax.get_yticklabels()]
# df = df.sort(axis=0)
# df = df.sort(axis=1)
sortx = np.argsort(df.sum(axis=1).values)[::-1]
df = df.take(sortx, axis=0)
df = df.take(sortx, axis=1)
fig = pt.figure(fnum=1)
fig.clf()
mat = df.values.astype(np.int32)
mat[np.diag_indices(len(mat))] = 0
vmax = mat[(1 - np.eye(len(mat))).astype(np.bool)].max()
import matplotlib.colors
norm = matplotlib.colors.Normalize(vmin=0, vmax=vmax, clip=True)
pt.plt.imshow(mat, cmap='hot', norm=norm, interpolation='none')
pt.plt.colorbar()
pt.plt.grid('off')
label_ticks(label_texts)
fig.tight_layout()
# overlap_df = pd.DataFrame.from_dict(overlap_img_list)
class TmpImage(ut.NiceRepr):
pass
from skimage.feature import hog
from skimage import data, color, exposure
import wbia.plottool as pt
image2 = color.rgb2gray(data.astronaut()) # NOQA
fpath = './GOPR1120.JPG'
import vtool as vt
for fpath in [fpath]:
"""
http://scikit-image.org/docs/dev/auto_examples/plot_hog.html
"""
image = vt.imread(fpath, grayscale=True)
image = pt.color_funcs.to_base01(image)
fig = pt.figure(fnum=2)
fd, hog_image = hog(
image,
orientations=8,
pixels_per_cell=(16, 16),
cells_per_block=(1, 1),
visualise=True,
)
fig, (ax1, ax2) = pt.plt.subplots(1,
2,
figsize=(8, 4),
sharex=True,
sharey=True)
ax1.axis('off')
ax1.imshow(image, cmap=pt.plt.cm.gray)
ax1.set_title('Input image')
ax1.set_adjustable('box-forced')
# Rescale histogram for better display
hog_image_rescaled = exposure.rescale_intensity(hog_image,
in_range=(0, 0.02))
ax2.axis('off')
ax2.imshow(hog_image_rescaled, cmap=pt.plt.cm.gray)
ax2.set_title('Histogram of Oriented Gradients')
ax1.set_adjustable('box-forced')
pt.plt.show()
def show_keypoint_annots():
merged = read_fine_merged()
def images_with_keypoints():
keypoint_gids = set()
for aid, ann in merged.anns.items():
if ann['roi_shape'] == 'keypoints':
keypoint_gids.add(ann['image_id'])
relevant = ub.dict_subset(merged.gid_to_aids, keypoint_gids)
relevant = {
gid:
[a for a in aids if merged.anns[a]['roi_shape'] == 'keypoints']
for gid, aids in relevant.items()
}
gid_list = ub.argsort(ub.map_vals(len, relevant))[::-1]
return gid_list
def sort_gids_by_nannots(gids):
return ub.argsort(
ub.map_vals(len,
ub.dict_subset(merged.gid_to_aids, gids,
default=[])))[::-1]
def images_with_keypoints_and_boxes():
keypoint_gids = set()
for aid, ann in merged.anns.items():
if ann['roi_shape'] == 'keypoints':
keypoint_gids.add(ann['image_id'])
gid_list = []
for gid in keypoint_gids:
aids = merged.gid_to_aids[gid]
types = set()
for ann in ub.take(merged.anns, aids):
types.add(ann['roi_shape'])
if len(types) > 1:
gid_list.append(gid)
gid_list = sort_gids_by_nannots(gid_list)
return gid_list
def image_from_each_dataset():
groups = ub.ddict(list)
for gid, img in merged.imgs.items():
groups[os.path.dirname(img['file_name'])].append(gid)
gid_groups = []
for gids in groups.values():
gids = sort_gids_by_nannots(gids)
gid_groups.append(gids)
# round robin sample
datas = [gid for x in zip(*gid_groups) for gid in x]
return datas
# gid_list = images_with_keypoints()
gid_list = images_with_keypoints_and_boxes()
gid_list = image_from_each_dataset()
# gid = gid_list[2]
# import matplotlib.pyplot as plt
# plt.gcf().clf()
# merged.show_annotation(gid=gid)
import utool as ut
if ut.inIPython():
import IPython
IPython.get_ipython().magic('pylab qt5 --no-import-all')
from matplotlib import pyplot as plt
for gid in ut.InteractiveIter(gid_list):
try:
fig = plt.figure(1)
fig.clf()
merged.show_annotation(gid=gid)
name = os.path.basename(
os.path.dirname(merged.imgs[gid]['file_name']))
ax = plt.gca()
plt.gca().set_title(name)
ax.set_xticks([])
ax.set_yticks([])
plt.gca().grid('off')
fig.canvas.draw()
except Exception:
print('cannot draw')
def test_featweight_worker():
"""
test function
python -m ibeis.algo.preproc.preproc_featweight --test-gen_featweight_worker --show --cnn
"""
import ibeis
qreq_ = ibeis.main_helpers.testdata_qreq_(defaultdb='PZ_MTEST', p=['default:fw_detector=cnn'], qaid_override=[1])
ibs = qreq_.ibs
config2_ = qreq_.qparams
lazy = True
aid_list = qreq_.get_external_qaids()
#aid_list = ibs.get_valid_aids()[0:30]
kpts_list = ibs.get_annot_kpts(aid_list)
chipsize_list = ibs.get_annot_chip_sizes(aid_list, config2_=config2_)
probchip_fpath_list = preproc_probchip.compute_and_write_probchip(ibs,
aid_list,
lazy=lazy,
config2_=config2_)
print('probchip_fpath_list = %r' % (probchip_fpath_list,))
probchip_list = [vt.imread(fpath, grayscale=True) if exists(fpath) else None
for fpath in probchip_fpath_list]
_iter = list(zip(aid_list, kpts_list, probchip_list, chipsize_list))
_iter = ut.InteractiveIter(_iter, enabled=ut.get_argflag('--show'))
for aid, kpts, probchip, chipsize in _iter:
#kpts = kpts_list[0]
#aid = aid_list[0]
#probchip = probchip_list[0]
#chipsize = chipsize_list[0]
tup = (aid, kpts, probchip, chipsize)
(aid, weights) = gen_featweight_worker(tup)
if aid == 3 and ibs.get_dbname() == 'testdb1':
# Run Asserts if not interactive
weights_03_test = weights[0:3]
print('weights[0:3] = %r' % (weights_03_test,))
#weights_03_target = [ 0.098, 0.155, 0.422]
#weights_03_target = [ 0.324, 0.407, 0.688]
#weights_thresh = [ 0.09, 0.09, 0.09]
#ut.assert_almost_eq(weights_03_test, weights_03_target, weights_thresh)
ut.assert_inbounds(weights_03_test, 0, 1)
if not ut.show_was_requested():
break
if ut.show_was_requested():
import plottool as pt
#sfx, sfy = (probchip.shape[1] / chipsize[0], probchip.shape[0] / chipsize[1])
#kpts_ = vt.offset_kpts(kpts, (0, 0), (sfx, sfy))
pnum_ = pt.make_pnum_nextgen(1, 3) # *pt.get_square_row_cols(4))
fnum = 1
pt.figure(fnum=fnum, doclf=True)
###
pt.imshow(ibs.get_annot_chips(aid, config2_=config2_), pnum=pnum_(0), fnum=fnum)
if ut.get_argflag('--numlbl'):
pt.gca().set_xlabel('(1)')
###
pt.imshow(probchip, pnum=pnum_(2), fnum=fnum)
if ut.get_argflag('--numlbl'):
pt.gca().set_xlabel('(2)')
#pt.draw_kpts2(kpts_, ell_alpha=.4, color_list=pt.ORANGE)
###
#pt.imshow(probchip, pnum=pnum_(3), fnum=fnum)
#color_list = pt.draw_kpts2(kpts_, weights=weights, ell_alpha=.7, cmap_='jet')
#cb = pt.colorbar(weights, color_list)
#cb.set_label('featweights')
###
pt.imshow(ibs.get_annot_chips(aid, config2_=qreq_.qparams), pnum=pnum_(1), fnum=fnum)
#color_list = pt.draw_kpts2(kpts, weights=weights, ell_alpha=.3, cmap_='jet')
color_list = pt.draw_kpts2(kpts, weights=weights, ell_alpha=.3)
cb = pt.colorbar(weights, color_list)
cb.set_label('featweights')
if ut.get_argflag('--numlbl'):
pt.gca().set_xlabel('(3)')
#pt.draw_kpts2(kpts, ell_alpha=.4)
pt.draw()
pt.show_if_requested()
def postprocess_dev():
"""
References:
http://opencv-python-tutroals.readthedocs.org/en/latest/py_tutorials/py_imgproc/py_morphological_ops/py_morphological_ops.html
CommandLine:
python -m ibeis.algo.preproc.preproc_probchip --test-postprocess_dev
python -m ibeis.algo.preproc.preproc_probchip --test-postprocess_dev --aids=2,3 --show
python -m ibeis.algo.preproc.preproc_probchip --test-postprocess_dev --db Elephants_drop1_ears
CommandLine:
python -m ibeis.algo.preproc.preproc_probchip --test-postprocess_dev
Example:
>>> # DISABLE_DOCTEST
>>> from ibeis.algo.preproc.preproc_probchip import * # NOQA
>>> # build test data
>>> # execute function
>>> result = postprocess_dev()
>>> # verify results
>>> print(result)
"""
from plottool import df2 as df2
import cv2
import numpy as np # NOQA
#fpath = '/media/raid/work/GZ_ALL/_ibsdb/figures/nsum_hard/qaid=420_res_5ujbs8h&%vw1olnx_quuid=31cfdc3e/probchip_aid=478_auuid=5c327c5d-4bcc-22e4-764e-535e5874f1c7_CHIP(sz450)_FEATWEIGHT(ON,uselabel,rf)_CHIP()_zebra_grevys.png.png' # NOQA
import ibeis
ibs = ibeis.opendb(defaultdb='PZ_MTEST')
aid_list = ut.get_argval(('--aids', '--aid'), type_=list, default=None)
if aid_list is None:
aid_list = ibs.get_valid_aids()
else:
ibs.assert_valid_aids(aid_list)
def test_grabcut_on_aid(aid):
chip_fpath = ibs.get_annot_chip_fpath(aid)
probchip_fpath = ibs.get_annot_probchip_fpath(aid)
chip_img = vt.imread(chip_fpath)
probchip_img = vt.imread(probchip_fpath, grayscale=True)
label_values = [cv2.GC_BGD, cv2.GC_PR_BGD, cv2.GC_PR_FGD, cv2.GC_FGD]
def probchip_to_grabcut_labels(probchip_img, w, h):
scaled_probchip = cv2.resize(probchip_img, dsize=(w, h))
mask = ((len(label_values) - 1) * (scaled_probchip / 255)).astype(
np.uint8)
# Except for one center pixel
#mask[mask.shape[0] // 2, mask.shape[1] // 2] = 3
label_mask = mask.copy()
for index, value in enumerate(label_values):
label_mask[mask == index] = value
# No certainty
label_mask[label_mask == cv2.GC_FGD] = cv2.GC_PR_FGD
label_mask[label_mask == cv2.GC_BGD] = cv2.GC_PR_BGD
return label_mask
def grabcut_labels_to_probchip(label_mask):
image_mask = label_mask.copy()
label_colors = np.linspace(0, 255,
len(label_values)).astype(np.uint8)
for value, color in zip(label_values, label_colors):
image_mask[label_mask == value] = (color)
return image_mask
def grabcut_from_probchip(chip_img, label_mask):
rect = (0, 0, w, h)
bgd_model = np.zeros((1, 13 * 5), np.float64)
fgd_model = np.zeros((1, 13 * 5), np.float64)
num_iters = 5
mode = cv2.GC_INIT_WITH_MASK
# label_mask is an outvar
label_mask_ = label_mask.copy()
print(label_values)
print(np.unique(label_mask_))
with ut.Timer('grabcut'):
cv2.grabCut(chip_img,
label_mask_,
rect,
bgd_model,
fgd_model,
num_iters,
mode=mode)
#is_foreground = (label_mask == cv2.GC_FGD) + (label_mask == cv2.GC_PR_FGD)
#is_foreground = (label_mask_ == cv2.GC_FGD) # + (label_mask == cv2.GC_PR_FGD)
return label_mask_
(h, w) = chip_img.shape[0:2]
label_mask = probchip_to_grabcut_labels(probchip_img, w, h)
label_mask_ = grabcut_from_probchip(chip_img, label_mask)
float_mask = grabcut_labels_to_probchip(label_mask_) / 255.0
segmented_chip = chip_img * float_mask[:, :, None]
next_pnum = df2.make_pnum_nextgen(2, 3)
df2.imshow(chip_img, fnum=1, pnum=next_pnum())
df2.imshow(probchip_img, fnum=1, pnum=next_pnum())
df2.imshow(grabcut_labels_to_probchip(label_mask),
fnum=1,
pnum=next_pnum())
df2.imshow(segmented_chip, fnum=1, pnum=next_pnum())
df2.imshow(255 * (float_mask), fnum=1, pnum=next_pnum())
df2.imshow(chip_img * (float_mask > .6)[:, :, None],
fnum=1,
pnum=next_pnum())
df2.present()
aid = aid_list[0]
for aid in ut.InteractiveIter(aid_list):
test_grabcut_on_aid(aid)
#input('press enter to continue')
#kernel = np.ones((5, 5), np.uint8)
#blur = cv2.GaussianBlur(img, (5, 5), 1.6)
#dilation = cv2.dilate(img, kernel, iterations=10)
#df2.imshow(blur, fnum=2)
#df2.imshow(dilation, fnum=3)
#cv2.floodFill(image, mask, seedPoint, newVal)
#closing = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel, iterations=5)
#df2.imshow(closing, fnum=4)
pass
def param_interaction():
r"""
CommandLine:
python -m vtool.test_constrained_matching --test-param_interaction
Notes:
python -m vtool.test_constrained_matching --test-param_interaction
setparam normalizer_mode=nearby
setparam normalizer_mode=far
setparam ratio_thresh=.625
setparam ratio_thresh=.5
setparam ratio_thresh2=.625
normalizer_mode=plus
Example:
>>> # DISABLE_DOCTEST
>>> from vtool.test_constrained_matching import * # NOQA
>>> # build test data
>>> # execute function
>>> testtup = param_interaction()
>>> # verify results
>>> result = str(testtup)
>>> print(result)
"""
import plottool as pt
USE_IBEIS = False and ut.is_developer()
if USE_IBEIS:
from ibeis.algo.hots import devcases
index = 2
fpath1, fpath2, fpath3 = devcases.get_dev_test_fpaths(index)
testtup1 = testdata_matcher(fpath1, fpath2)
testtup2 = testdata_matcher(fpath1, fpath3)
else:
testtup1 = testdata_matcher('easy1.png', 'easy2.png')
testtup2 = testdata_matcher('easy1.png', 'hard3.png')
testtup_list = [testtup1, testtup2]
simp_list = [SimpleMatcher(testtup) for testtup in testtup_list]
varied_dict = dict([
('sver_xy_thresh', .1),
('ratio_thresh', .625),
('search_K', 7),
('ratio_thresh2', .625),
('sver_xy_thresh2', .01),
('normalizer_mode', ['nearby', 'far', 'plus'][1]),
('match_xy_thresh', .1),
])
cfgdict_list = ut.all_dict_combinations(varied_dict)
tried_configs = []
# DEFINE CUSTOM INTRACTIONS
custom_actions, valid_vizmodes, viz_index_, offset_fnum_ = make_custom_interactions(
simp_list)
# /DEFINE CUSTOM INTRACTIONS
for cfgdict in ut.InteractiveIter(
cfgdict_list,
#default_action='reload',
custom_actions=custom_actions,
wraparound=True):
for simp in simp_list:
simp.run_matching(cfgdict=cfgdict)
vizkey = valid_vizmodes[viz_index_[0]].replace('visualize_', '')
print('vizkey = %r' % (vizkey, ))
for fnum_, simp in enumerate(simp_list):
fnum = fnum_ + offset_fnum_[0]
simp.visualize(vizkey, fnum=fnum)
tried_configs.append(cfgdict.copy())
print('Current Config = ')
print(ut.dict_str(cfgdict))
pt.present()
pt.update()
def gen_cvpr_images():
config = {
# Data on hermes
'img_root':
'/data/projects/noaa/training_data/imagery',
'annots':
list(
glob.glob(
'/data/projects/noaa/training_data/annotations/*/*fine*-keypoint*'
)),
'output_dpath':
ub.truepath('~/remote/hermes/work/noaa/cvpr_slides')
}
output_dpath = ub.ensuredir(ub.truepath(config['output_dpath']))
annot_fpaths = config['annots']
img_root = config['img_root']
print('annot_fpaths = {}'.format(ub.repr2(annot_fpaths)))
print('Reading raw mscoco files')
dsets = {}
for fpath in sorted(annot_fpaths):
print('reading fpath = {!r}'.format(fpath))
hack = os.path.basename(fpath).split('-')[0].split('.')[0]
dset = coco_api.CocoDataset(fpath,
tag=hack,
img_root=join(img_root, hack))
# assert not dset.missing_images()
# assert not dset._find_bad_annotations()
print(ub.repr2(dset.basic_stats()))
for img in dset.dataset['images']:
img['orig_dset'] = dset.tag
dset._build_index()
dsets[dset.tag] = dset
# Separate habcam out because it is so much bigger than the other sets
habcam = dsets['habcam_seq0']
# del dsets['habcam_seq0']
def invert_y_coordinate(nwfsc):
import numpy as np
nwfsc._build_index()
for ann in nwfsc.anns.values():
# Invert the Y coordinate for NWFSC
img = nwfsc.imgs[ann['image_id']]
xyv = np.array(ann['keypoints']).reshape(-1, 3)
xyv[:, 1] = img['height'] - xyv[:, 1]
ann['keypoints'] = xyv.ravel().tolist()
nwfsc = dsets['nwfsc_seq0']
invert_y_coordinate(nwfsc)
print('Merging')
merged = coco_api.CocoDataset.union(*dsets.values(), autobuild=False)
merged.img_root = img_root
merged._build_index()
habcam._build_index()
nh.util.autompl()
merged_gid_list = Sampler(merged).variety_selection(num=20)
habcam_gid_list = Sampler(habcam).variety_selection(num=10)
def dump_selection(dset, gid_list):
from matplotlib import pyplot as plt
for gid in ub.ProgIter(gid_list, verbose=3):
fig = plt.figure(6)
fig.clf()
dset.show_annotation(gid=gid)
name = os.path.basename(
os.path.dirname(dset.imgs[gid]['file_name']))
ax = plt.gca()
plt.gca().set_title(name)
ax.set_xticks([])
ax.set_yticks([])
plt.gca().grid('off')
fig.canvas.draw()
dpi = 96
fig.set_dpi(dpi)
fig.set_size_inches(1920 / dpi, 1080 / dpi)
img = nh.util.mplutil.render_figure_to_image(fig, dpi=dpi)
# print('img = {!r}'.format(img.shape))
if dset.tag:
out_fname = dset.tag + '_' + '_'.join(
dset.imgs[gid]['file_name'].split('/')[-2:])
else:
out_fname = '_'.join(
dset.imgs[gid]['file_name'].split('/')[-2:])
fpath = join(output_dpath, out_fname)
print('fpath = {!r}'.format(fpath))
nh.util.imwrite(fpath, img)
# nh.util.imshow(img, fnum=2)
dump_selection(merged, merged_gid_list)
dump_selection(habcam, habcam_gid_list)
mouss0_gid_list = Sampler(dsets['mouss_seq0']).variety_selection(num=5)
dump_selection(dsets['mouss_seq0'], mouss0_gid_list)
nwfsc_seq0_gids = Sampler(dsets['nwfsc_seq0']).variety_selection(num=10)
dump_selection(dsets['nwfsc_seq0'], nwfsc_seq0_gids)
if False:
from matplotlib import pyplot as plt
import utool as ut
for gid in ut.InteractiveIter(gid_list):
try:
fig = plt.figure(5)
fig.clf()
merged.show_annotation(gid=gid)
name = os.path.basename(
os.path.dirname(merged.imgs[gid]['file_name']))
ax = plt.gca()
plt.gca().set_title(name)
ax.set_xticks([])
ax.set_yticks([])
plt.gca().grid('off')
fig.canvas.draw()
except Exception:
print('cannot draw')
