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