def test_mcc(): import plottool_ibeis as pt import sklearn.metrics num = 100 xdata = np.linspace(0, 1, num * 2) ydata = np.linspace(1, -1, num * 2) pt.plt.plot(xdata, ydata, '--k', label='linear') y_true = [1] * num + [0] * num y_pred = y_true[:] xs = [] for i in range(0, len(y_true)): y_pred[-i] = 1 - y_pred[-i] xs.append(sklearn.metrics.matthews_corrcoef(y_true, y_pred)) pt.plot(xdata, xs, label='change one class at a time') y_true = ut.flatten(zip([1] * num, [0] * num)) y_pred = y_true[:] xs = [] for i in range(0, len(y_true)): y_pred[-i] = 1 - y_pred[-i] xs.append(sklearn.metrics.matthews_corrcoef(y_true, y_pred)) pt.plot(xdata, xs, label='change classes evenly') pt.gca().legend()
def draw_tree_model(model, **kwargs): import plottool_ibeis as pt import networkx as netx if not ut.get_argval('--hackjunc'): fnum = pt.ensure_fnum(None) fig = pt.figure(fnum=fnum, doclf=True) # NOQA ax = pt.gca() #name_nodes = sorted(ut.list_getattr(model.ttype2_cpds[NAME_TTYPE], 'variable')) netx_graph = model.to_markov_model() #pos = netx.pygraphviz_layout(netx_graph) #pos = netx.graphviz_layout(netx_graph) #pos = get_hacked_pos(netx_graph, name_nodes, prog='neato') pos = netx.nx_pydot.pydot_layout(netx_graph) node_color = [pt.WHITE] * len(pos) drawkw = dict(pos=pos, ax=ax, with_labels=True, node_color=node_color, node_size=1100) netx.draw(netx_graph, **drawkw) if kwargs.get('show_title', True): pt.set_figtitle('Markov Model') if not ut.get_argval('--hackmarkov'): fnum = pt.ensure_fnum(None) fig = pt.figure(fnum=fnum, doclf=True) # NOQA ax = pt.gca() netx_graph = model.to_junction_tree() # prettify nodes def fixtupkeys(dict_): return { ', '.join(k) if isinstance(k, tuple) else k: fixtupkeys(v) for k, v in dict_.items() } # FIXME n = fixtupkeys(netx_graph.node) e = fixtupkeys(netx_graph.edge) a = fixtupkeys(netx_graph.adj) netx_graph.nodes.update(n) netx_graph.edges.update(e) netx_graph.adj.update(a) #netx_graph = model.to_markov_model() #pos = netx.pygraphviz_layout(netx_graph) #pos = netx.graphviz_layout(netx_graph) pos = netx.nx_pydot.pydot_layout(netx_graph) node_color = [pt.WHITE] * len(pos) drawkw = dict(pos=pos, ax=ax, with_labels=True, node_color=node_color, node_size=2000) netx.draw(netx_graph, **drawkw) if kwargs.get('show_title', True): pt.set_figtitle('Junction/Clique Tree / Cluster Graph')
def label_ticks(label_texts): import plottool_ibeis 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()]
def plot(self, fnum, pnum): self.infr.update_visual_attrs(self.show_cuts) layoutkw = dict(prog='neato', splines='spline', sep=10 / 72) #draw_implicit=self.show_cuts) self.plotinfo = pt.show_nx( self.infr.graph, as_directed=False, fnum=self.fnum, layoutkw=layoutkw, #node_labels=True, modify_ax=False, use_image=self.use_image, verbose=0) ut.util_graph.graph_info(self.infr.graph, verbose=True) #_, edge_weights, edge_colors = self.infr.get_colored_edge_weights() #pt.colorbar(edge_weights, edge_colors, lbl='weights') # _normal_ticks = np.linspace(0, 1, num=11) # _normal_scores = np.linspace(0, 1, num=500) # _normal_colors = self.infr.get_colored_weights(_normal_scores) # cb = pt.colorbar(_normal_scores, _normal_colors, lbl='weights', # ticklabels=_normal_ticks) # cb.ax.annotate('threshold', # xy=(1, self.infr.thresh), # xytext=(2.5, .3 if self.infr.thresh < .5 else .7), # arrowprops=dict( # alpha=.5, # fc="0.6", # connectionstyle="angle3,angleA=90,angleB=0"),) ax = pt.gca() self.enable_pan_and_zoom(ax) #ax.autoscale() for aid in self.selected_aids: self.highlight_aid(aid, pt.ORANGE) #self.static_plot(fnum, pnum) self.make_hud() #print(ut.repr2(self.infr.graph.edges, nl=2)) print('Finished Plot')
def get_popup_options(self): from ibeis.gui import inspect_gui options = [] ax = pt.gca() # HACK from plottool_ibeis import plot_helpers as ph viztype = ph.get_plotdat(ax, 'viztype', '') is_match_type = viztype in ['matches', 'multi_match'] if is_match_type: options += inspect_gui.get_aidpair_context_menu_options( self.ibs, self.qaid, self.daid, self.cm, qreq_=self.qreq_, #update_callback=self.show_page, #backend_callback=None, aid_list=aid_list) ) options += [ #('Toggle same_fig', self.toggle_samefig), #('Toggle vert', self.toggle_vert), ('query last feature', self.query_last_feature), ('show each chip', self.show_each_chip), ('show each distinctiveness chip', self.show_each_dstncvs_chip), ('show each foreground weight chip', self.show_each_fgweight_chip), ('show each probchip', self.show_each_probchip), ('show coverage', self.show_coverage), #('show each probchip', self.query_last_feature), ] #options.append(('name_interaction', self.name_interaction)) #if self.H1 is not None: # options.append(('Toggle homog', self.toggle_homog)) if ut.is_developer(): options.append(('dev_reload', self.dev_reload)) options.append(('dev_embed', self.dev_embed)) #options.append(('cancel', lambda: print('cancel'))) options += super(MatchInteraction, self).get_popup_options() return options
def draw_junction_tree(model, fnum=None, **kwargs): import plottool_ibeis as pt fnum = pt.ensure_fnum(fnum) pt.figure(fnum=fnum) ax = pt.gca() from pgmpy.models import JunctionTree if not isinstance(model, JunctionTree): netx_graph = model.to_junction_tree() else: netx_graph = model # prettify nodes def fixtupkeys(dict_): return { ', '.join(k) if isinstance(k, tuple) else k: fixtupkeys(v) for k, v in dict_.items() } n = fixtupkeys(netx_graph.nodes) e = fixtupkeys(netx_graph.edge) a = fixtupkeys(netx_graph.adj) netx_graph.nodes = n netx_graph.edge = e netx_graph.adj = a #netx_graph = model.to_markov_model() #pos = nx.nx_agraph.pygraphviz_layout(netx_graph) #pos = nx.nx_agraph.graphviz_layout(netx_graph) pos = nx.pydot_layout(netx_graph) node_color = [pt.NEUTRAL] * len(pos) drawkw = dict(pos=pos, ax=ax, with_labels=True, node_color=node_color, node_size=2000) nx.draw(netx_graph, **drawkw) if kwargs.get('show_title', True): pt.set_figtitle('Junction / Clique Tree / Cluster Graph')
def show_time_distributions(ibs, unixtime_list): r""" """ #import vtool_ibeis as vt import plottool_ibeis as pt unixtime_list = np.array(unixtime_list) num_nan = np.isnan(unixtime_list).sum() num_total = len(unixtime_list) unixtime_list = unixtime_list[~np.isnan(unixtime_list)] from ibeis.scripts.thesis import TMP_RC import matplotlib as mpl mpl.rcParams.update(TMP_RC) if False: from matplotlib import dates as mpldates #data_list = list(map(ut.unixtime_to_datetimeobj, unixtime_list)) n, bins, patches = pt.plt.hist(unixtime_list, 365) #n_ = list(map(ut.unixtime_to_datetimeobj, n)) #bins_ = list(map(ut.unixtime_to_datetimeobj, bins)) pt.plt.setp(patches, 'facecolor', 'g', 'alpha', 0.75) ax = pt.gca() #ax.xaxis.set_major_locator(mpldates.YearLocator()) #hfmt = mpldates.DateFormatter('%y/%m/%d') #ax.xaxis.set_major_formatter(hfmt) mpldates.num2date(unixtime_list) #pt.gcf().autofmt_xdate() #y = pt.plt.normpdf( bins, unixtime_list.mean(), unixtime_list.std()) #ax.set_xticks(bins_) #l = pt.plt.plot(bins_, y, 'k--', linewidth=1.5) else: pt.draw_time_distribution(unixtime_list) #pt.draw_histogram() ax = pt.gca() ax.set_xlabel('Date') ax.set_title('Timestamp distribution of %s. #nan=%d/%d' % (ibs.get_dbname_alias(), num_nan, num_total)) pt.gcf().autofmt_xdate() icon = ibs.get_database_icon() if False and icon is not None: #import matplotlib as mpl #import vtool_ibeis as vt ax = pt.gca() # Overlay a species icon # http://matplotlib.org/examples/pylab_examples/demo_annotation_box.html #icon = vt.convert_image_list_colorspace([icon], 'RGB', 'BGR')[0] # pt.overlay_icon(icon, coords=(0, 1), bbox_alignment=(0, 1)) pt.overlay_icon(icon, coords=(0, 1), bbox_alignment=(0, 1), as_artist=1, max_asize=(100, 200)) #imagebox = mpl.offsetbox.OffsetImage(icon, zoom=1.0) ##xy = [ax.get_xlim()[0] + 5, ax.get_ylim()[1]] ##ax.set_xlim(1, 100) ##ax.set_ylim(0, 100) ##x = np.array(ax.get_xlim()).sum() / 2 ##y = np.array(ax.get_ylim()).sum() / 2 ##xy = [x, y] ##print('xy = %r' % (xy,)) ##x = np.nanmin(unixtime_list) ##xy = [x, y] ##print('xy = %r' % (xy,)) ##ax.get_ylim()[0]] #xy = [ax.get_xlim()[0], ax.get_ylim()[1]] #ab = mpl.offsetbox.AnnotationBbox( # imagebox, xy, xycoords='data', # xybox=(-0., 0.), # boxcoords="offset points", # box_alignment=(0, 1), pad=0.0) #ax.add_artist(ab) if ut.get_argflag('--contextadjust'): #pt.adjust_subplots(left=.08, bottom=.1, top=.9, wspace=.3, hspace=.1) pt.adjust_subplots(use_argv=True)
def draw_bayesian_model(model, evidence={}, soft_evidence={}, fnum=None, pnum=None, **kwargs): from pgmpy.models import BayesianModel if not isinstance(model, BayesianModel): model = model.to_bayesian_model() import plottool_ibeis as pt import networkx as nx kwargs = kwargs.copy() factor_list = kwargs.pop('factor_list', []) ttype_colors, ttype_scalars = make_colorcodes(model) textprops = { 'horizontalalignment': 'left', 'family': 'monospace', 'size': 8, } # build graph attrs tup = get_node_viz_attrs(model, evidence, soft_evidence, factor_list, ttype_colors, **kwargs) node_color, pos_list, pos_dict, takws = tup # draw graph has_inferred = evidence or 'factor_list' in kwargs if False: fig = pt.figure(fnum=fnum, pnum=pnum, doclf=True) # NOQA ax = pt.gca() drawkw = dict(pos=pos_dict, ax=ax, with_labels=True, node_size=1100, node_color=node_color) nx.draw(model, **drawkw) else: # BE VERY CAREFUL if 1: graph = model.copy() graph.__class__ = nx.DiGraph graph.graph['groupattrs'] = ut.ddict(dict) #graph = model. if getattr(graph, 'ttype2_cpds', None) is not None: # Add invis edges and ttype groups for ttype in model.ttype2_cpds.keys(): ttype_cpds = model.ttype2_cpds[ttype] # use defined ordering ttype_nodes = ut.list_getattr(ttype_cpds, 'variable') # ttype_nodes = sorted(ttype_nodes) invis_edges = list(ut.itertwo(ttype_nodes)) graph.add_edges_from(invis_edges) nx.set_edge_attributes( graph, name='style', values={edge: 'invis' for edge in invis_edges}) nx.set_node_attributes( graph, name='groupid', values={node: ttype for node in ttype_nodes}) graph.graph['groupattrs'][ttype]['rank'] = 'same' graph.graph['groupattrs'][ttype]['cluster'] = False else: graph = model pt.show_nx(graph, layout_kw={'prog': 'dot'}, fnum=fnum, pnum=pnum, verbose=0) pt.zoom_factory() fig = pt.gcf() ax = pt.gca() pass hacks = [ pt.draw_text_annotations(textprops=textprops, **takw) for takw in takws if takw ] xmin, ymin = np.array(pos_list).min(axis=0) xmax, ymax = np.array(pos_list).max(axis=0) if 'name' in model.ttype2_template: num_names = len(model.ttype2_template['name'].basis) num_annots = len(model.ttype2_cpds['name']) if num_annots > 4: ax.set_xlim((xmin - 40, xmax + 40)) ax.set_ylim((ymin - 50, ymax + 50)) fig.set_size_inches(30, 7) else: ax.set_xlim((xmin - 42, xmax + 42)) ax.set_ylim((ymin - 50, ymax + 50)) fig.set_size_inches(23, 7) title = 'num_names=%r, num_annots=%r' % ( num_names, num_annots, ) else: title = '' map_assign = kwargs.get('map_assign', None) def word_insert(text): return '' if len(text) == 0 else text + ' ' top_assignments = kwargs.get('top_assignments', None) if top_assignments is not None: map_assign, map_prob = top_assignments[0] if map_assign is not None: title += '\n%sMAP: ' % (word_insert(kwargs.get('method', ''))) title += map_assign + ' @' + '%.2f%%' % (100 * map_prob, ) if kwargs.get('show_title', True): pt.set_figtitle(title, size=14) for hack in hacks: hack() if has_inferred: # Hack in colorbars # if ut.list_type(basis) is int: # pt.colorbar(scalars, colors, lbl='score', ticklabels=np.array(basis) + 1) # else: # pt.colorbar(scalars, colors, lbl='score', ticklabels=basis) keys = ['name', 'score'] locs = ['left', 'right'] for key, loc in zip(keys, locs): if key in ttype_colors: basis = model.ttype2_template[key].basis # scalars = colors = ttype_colors[key] scalars = ttype_scalars[key] pt.colorbar(scalars, colors, lbl=key, ticklabels=basis, ticklocation=loc)
def show_chip(ibs, aid, in_image=False, annote=True, title_suffix='', weight_label=None, weights=None, config2_=None, **kwargs): r""" Driver function to show chips Args: ibs (ibeis.IBEISController): aid (int): annotation rowid in_image (bool): displays annotation with the context of its source image annote (bool): enables overlay annoations title_suffix (str): weight_label (None): (default = None) weights (None): (default = None) config2_ (dict): (default = None) Kwargs: enable_chip_title_prefix, nokpts, kpts_subset, kpts, text_color, notitle, draw_lbls, show_aidstr, show_gname, show_name, show_nid, show_exemplar, show_num_gt, show_quality_text, show_viewcode, fnum, title, figtitle, pnum, interpolation, cmap, heatmap, data_colorbar, darken, update, xlabel, redraw_image, ax, alpha, docla, doclf, projection, pts, ell color (3/4-tuple, ndarray, or str): colors for keypoints CommandLine: python -m ibeis.viz.viz_chip show_chip --show --ecc python -c "import utool as ut; ut.print_auto_docstr('ibeis.viz.viz_chip', 'show_chip')" python -m ibeis.viz.viz_chip show_chip --show --db NNP_Master3 --aids 14047 --no-annote python -m ibeis.viz.viz_chip show_chip --show --db NNP_Master3 --aids 14047 --no-annote python -m ibeis.viz.viz_chip show_chip --show --db PZ_MTEST --aid 1 --bgmethod=cnn python -m ibeis.viz.viz_chip show_chip --show --db PZ_MTEST --aid 1 --bgmethod=cnn --scale_max=30 python -m ibeis.viz.viz_chip show_chip --show --db PZ_MTEST --aid 1 --ecc --draw_lbls=False --notitle --save=~/slides/lnbnn_query.jpg --dpi=300 Example: >>> # VIZ_TEST >>> from ibeis.viz.viz_chip import * # NOQA >>> import numpy as np >>> import vtool_ibeis as vt >>> in_image = False >>> ibs, aid_list, kwargs, config2_ = testdata_showchip() >>> aid = aid_list[0] >>> if True: >>> import matplotlib as mpl >>> from ibeis.scripts.thesis import TMP_RC >>> mpl.rcParams.update(TMP_RC) >>> if ut.get_argflag('--ecc'): >>> kpts = ibs.get_annot_kpts(aid, config2_=config2_) >>> weights = ibs.get_annot_fgweights([aid], ensure=True, config2_=config2_)[0] >>> kpts = ut.random_sample(kpts[weights > .9], 200, seed=0) >>> ecc = vt.get_kpts_eccentricity(kpts) >>> scale = 1 / vt.get_scales(kpts) >>> #s = ecc if config2_.affine_invariance else scale >>> s = scale >>> colors = pt.scores_to_color(s, cmap_='jet') >>> kwargs['color'] = colors >>> kwargs['kpts'] = kpts >>> kwargs['ell_linewidth'] = 3 >>> kwargs['ell_alpha'] = .7 >>> show_chip(ibs, aid, in_image=in_image, config2_=config2_, **kwargs) >>> pt.show_if_requested() """ if ut.VERBOSE: print('[viz] show_chip(aid=%r)' % (aid, )) #ibs.assert_valid_aids((aid,)) # Get chip #print('in_image = %r' % (in_image,)) chip = vh.get_chips(ibs, aid, in_image=in_image, config2_=config2_) # Create chip title chip_text = vh.get_annot_texts(ibs, [aid], **kwargs)[0] if kwargs.get('enable_chip_title_prefix', True): chip_title_text = chip_text + title_suffix else: chip_title_text = title_suffix chip_title_text = chip_title_text.strip('\n') # Draw chip fig, ax = pt.imshow(chip, **kwargs) # Populate axis user data vh.set_ibsdat(ax, 'viztype', 'chip') vh.set_ibsdat(ax, 'aid', aid) if annote and not kwargs.get('nokpts', False): # Get and draw keypoints if 'color' not in kwargs: if weight_label == 'fg_weights': if weights is None and ibs.has_species_detector( ibs.get_annot_species_texts(aid)): weight_label = 'fg_weights' weights = ibs.get_annot_fgweights([aid], ensure=True, config2_=config2_)[0] if weights is not None: cmap_ = 'hot' #if weight_label == 'dstncvs': # cmap_ = 'rainbow' color = pt.scores_to_color(weights, cmap_=cmap_, reverse_cmap=False) kwargs['color'] = color kwargs['ell_color'] = color kwargs['pts_color'] = color kpts_ = vh.get_kpts(ibs, aid, in_image, config2_=config2_, kpts_subset=kwargs.get('kpts_subset', None), kpts=kwargs.pop('kpts', None)) pt.viz_keypoints._annotate_kpts(kpts_, **kwargs) if kwargs.get('draw_lbls', True): pt.upperleft_text(chip_text, color=kwargs.get('text_color', None)) use_title = not kwargs.get('notitle', False) if use_title: pt.set_title(chip_title_text) if in_image: gid = ibs.get_annot_gids(aid) aid_list = ibs.get_image_aids(gid) annotekw = viz_image.get_annot_annotations(ibs, aid_list, sel_aids=[aid], draw_lbls=kwargs.get( 'draw_lbls', True)) # Put annotation centers in the axis ph.set_plotdat(ax, 'annotation_bbox_list', annotekw['bbox_list']) ph.set_plotdat(ax, 'aid_list', aid_list) pt.viz_image2.draw_image_overlay(ax, **annotekw) zoom_ = ut.get_argval('--zoom', type_=float, default=None) if zoom_ is not None: import vtool_ibeis as vt # Zoom into the chip for some image context rotated_verts = ibs.get_annot_rotated_verts(aid) bbox = ibs.get_annot_bboxes(aid) #print(bbox) #print(rotated_verts) rotated_bbox = vt.bbox_from_verts(rotated_verts) imgw, imgh = ibs.get_image_sizes(gid) pad_factor = zoom_ pad_length = min(bbox[2], bbox[3]) * pad_factor minx = max(rotated_bbox[0] - pad_length, 0) miny = max(rotated_bbox[1] - pad_length, 0) maxx = min((rotated_bbox[0] + rotated_bbox[2]) + pad_length, imgw) maxy = min((rotated_bbox[1] + rotated_bbox[3]) + pad_length, imgh) #maxy = imgh - maxy #miny = imgh - miny ax = pt.gca() ax.set_xlim(minx, maxx) ax.set_ylim(miny, maxy) ax.invert_yaxis() else: ph.set_plotdat(ax, 'chipshape', chip.shape) #if 'featweights' in vars() and 'color' in kwargs: if weights is not None and weight_label is not None: ## HACK HACK HACK if len(weights) > 0: cb = pt.colorbar(weights, kwargs['color']) cb.set_label(weight_label) return fig, ax
def hackshow_names(ibs, aid_list, fnum=None): r""" Args: ibs (IBEISController): ibeis controller object aid_list (list): CommandLine: python -m ibeis.other.dbinfo --exec-hackshow_names --show python -m ibeis.other.dbinfo --exec-hackshow_names --show --db PZ_Master1 Example: >>> # DISABLE_DOCTEST >>> from ibeis.other.dbinfo import * # NOQA >>> import ibeis >>> ibs = ibeis.opendb(defaultdb='PZ_MTEST') >>> aid_list = ibs.get_valid_aids() >>> result = hackshow_names(ibs, aid_list) >>> print(result) >>> ut.show_if_requested() """ import plottool_ibeis as pt import vtool_ibeis as vt grouped_aids, nid_list = ibs.group_annots_by_name(aid_list) grouped_aids = [aids for aids in grouped_aids if len(aids) > 1] unixtimes_list = ibs.unflat_map(ibs.get_annot_image_unixtimes_asfloat, grouped_aids) yaws_list = ibs.unflat_map(ibs.get_annot_yaws, grouped_aids) #markers_list = [[(1, 2, yaw * 360 / (np.pi * 2)) for yaw in yaws] for yaws in yaws_list] unixtime_list = ut.flatten(unixtimes_list) timemax = np.nanmax(unixtime_list) timemin = np.nanmin(unixtime_list) timerange = timemax - timemin unixtimes_list = [((unixtimes[:] - timemin) / timerange) for unixtimes in unixtimes_list] for unixtimes in unixtimes_list: num_nan = sum(np.isnan(unixtimes)) unixtimes[np.isnan(unixtimes)] = np.linspace(-1, -.5, num_nan) #ydata_list = [np.arange(len(aids)) for aids in grouped_aids] sortx_list = vt.argsort_groups(unixtimes_list, reverse=False) #markers_list = ut.list_ziptake(markers_list, sortx_list) yaws_list = ut.list_ziptake(yaws_list, sortx_list) ydatas_list = vt.ziptake(unixtimes_list, sortx_list) #ydatas_list = sortx_list #ydatas_list = vt.argsort_groups(unixtimes_list, reverse=False) # Sort by num members #ydatas_list = ut.take(ydatas_list, np.argsort(list(map(len, ydatas_list)))) xdatas_list = [ np.zeros(len(ydatas)) + count for count, ydatas in enumerate(ydatas_list) ] #markers = ut.flatten(markers_list) #yaws = np.array(ut.flatten(yaws_list)) y_data = np.array(ut.flatten(ydatas_list)) x_data = np.array(ut.flatten(xdatas_list)) fnum = pt.ensure_fnum(fnum) pt.figure(fnum=fnum) ax = pt.gca() #unique_yaws, groupxs = vt.group_indices(yaws) ax.scatter(x_data, y_data, color=[1, 0, 0], s=1, marker='.') #pt.draw_stems(x_data, y_data, marker=markers, setlims=True, linestyle='') pt.dark_background() ax = pt.gca() ax.set_xlim(min(x_data) - .1, max(x_data) + .1) ax.set_ylim(min(y_data) - .1, max(y_data) + .1)
def viz_netx_chipgraph(ibs, graph, fnum=None, use_image=False, layout=None, zoom=None, prog='neato', as_directed=False, augment_graph=True, layoutkw=None, framewidth=True, **kwargs): r""" DEPRICATE or improve Args: ibs (IBEISController): ibeis controller object graph (nx.DiGraph): fnum (int): figure number(default = None) use_image (bool): (default = False) zoom (float): (default = 0.4) Returns: ?: pos CommandLine: python -m ibeis --tf viz_netx_chipgraph --show Cand: ibeis review_tagged_joins --save figures4/mergecase.png --figsize=15,15 --clipwhite --diskshow ibeis compute_occurrence_groups --save figures4/occurgraph.png --figsize=40,40 --clipwhite --diskshow ~/code/ibeis/ibeis/algo/preproc/preproc_occurrence.py Example: >>> # DISABLE_DOCTEST >>> from ibeis.viz.viz_graph import * # NOQA >>> import ibeis >>> ibs = ibeis.opendb(defaultdb='PZ_MTEST') >>> nid_list = ibs.get_valid_nids()[0:10] >>> fnum = None >>> use_image = True >>> zoom = 0.4 >>> make_name_graph_interaction(ibs, nid_list, prog='neato') >>> ut.show_if_requested() """ import plottool_ibeis as pt print('[viz_graph] drawing chip graph') fnum = pt.ensure_fnum(fnum) pt.figure(fnum=fnum, pnum=(1, 1, 1)) ax = pt.gca() if layout is None: layout = 'agraph' print('layout = %r' % (layout, )) if use_image: ensure_node_images(ibs, graph) nx.set_node_attributes(graph, name='shape', values='rect') if layoutkw is None: layoutkw = {} layoutkw['prog'] = layoutkw.get('prog', prog) layoutkw.update(kwargs) if prog == 'neato': graph = graph.to_undirected() plotinfo = pt.show_nx( graph, ax=ax, # img_dict=img_dict, layout=layout, # hacknonode=bool(use_image), layoutkw=layoutkw, as_directed=as_directed, framewidth=framewidth, ) return plotinfo
def show_name_matches(ibs, qaid, name_daid_list, name_fm_list, name_fs_list, name_H1_list, name_featflag_list, qreq_=None, **kwargs): """ Called from chip_match.py Args: ibs (IBEISController): ibeis controller object qaid (int): query annotation id name_daid_list (list): name_fm_list (list): name_fs_list (list): name_H1_list (list): name_featflag_list (list): qreq_ (QueryRequest): query request object with hyper-parameters(default = None) Kwargs: draw_fmatches, name_rank, fnum, pnum, colorbar_, nonvote_mode, fastmode, show_matches, fs, fm_norm, lbl1, lbl2, rect, draw_border, cmap, H1, H2, scale_factor1, scale_factor2, draw_pts, draw_ell, draw_lines, show_nMatches, all_kpts, in_image, show_query, draw_lbl, name_annot_scores, score, rawscore, aid2_raw_rank, show_name, show_nid, show_aid, show_annot_score, show_truth, name_score, show_name_score, show_name_rank, show_timedelta CommandLine: python -m ibeis.viz.viz_matches --exec-show_name_matches python -m ibeis.viz.viz_matches --test-show_name_matches --show Example: >>> # DISABLE_DOCTEST >>> from ibeis.viz.viz_matches import * # NOQA >>> from ibeis.algo.hots import chip_match >>> from ibeis.algo.hots import name_scoring >>> import vtool_ibeis as vt >>> from ibeis.algo.hots import _pipeline_helpers as plh # NOQA >>> import numpy as np >>> func = chip_match.ChipMatch.show_single_namematch >>> sourcecode = ut.get_func_sourcecode(func, stripdef=True, stripret=True, >>> strip_docstr=True) >>> setup = ut.regex_replace('viz_matches.show_name_matches', '#', sourcecode) >>> homog = False >>> print(ut.indent(setup, '>>> ')) >>> ibs, qreq_, cm_list = plh.testdata_post_sver('PZ_MTEST', qaid_list=[1]) >>> cm = cm_list[0] >>> cm.score_name_nsum(qreq_) >>> dnid = ibs.get_annot_nids(cm.qaid) >>> # +--- COPIED SECTION >>> locals_ = locals() >>> var_list = ut.exec_func_src( >>> func, locals_=locals_, >>> sentinal='name_annot_scores = cm.annot_score_list.take(sorted_groupxs') >>> exec(ut.execstr_dict(var_list)) >>> # L___ COPIED SECTION >>> kwargs = {} >>> show_name_matches(ibs, qaid, name_daid_list, name_fm_list, >>> name_fs_list, name_h1_list, name_featflag_list, >>> qreq_=qreq_, **kwargs) >>> ut.quit_if_noshow() >>> ut.show_if_requested() """ #print("SHOW NAME MATCHES") #print(ut.repr2(kwargs, nl=True)) #from ibeis import constants as const from ibeis import tag_funcs draw_fmatches = kwargs.pop('draw_fmatches', True) rchip1, kpts1 = get_query_annot_pair_info(ibs, qaid, qreq_, draw_fmatches) rchip2_list, kpts2_list = get_data_annot_pair_info(ibs, name_daid_list, qreq_, draw_fmatches) heatmask = kwargs.pop('heatmask', False) if heatmask: from vtool_ibeis.coverage_kpts import make_kpts_heatmask import numpy as np import vtool_ibeis as vt wh1 = vt.get_size(rchip1) fx1 = np.unique(np.hstack([fm.T[0] for fm in name_fm_list])) heatmask1 = make_kpts_heatmask(kpts1[fx1], wh1) rchip1 = vt.overlay_alpha_images(heatmask1, rchip1) # Hack cast back to uint8 rchip1 = (rchip1 * 255).astype(np.uint8) rchip2_list_ = rchip2_list rchip2_list = [] for rchip2, kpts2, fm in zip(rchip2_list_, kpts2_list, name_fm_list): fx2 = fm.T[1] wh2 = vt.get_size(rchip2) heatmask2 = make_kpts_heatmask(kpts2[fx2], wh2) rchip2 = vt.overlay_alpha_images(heatmask2, rchip2) # Hack cast back to uint8 rchip2 = (rchip2 * 255).astype(np.uint8) rchip2_list.append(rchip2) # fm_list = name_fm_list fs_list = name_fs_list featflag_list = name_featflag_list offset_list, sf_list, bbox_list = show_multichip_match( rchip1, rchip2_list, kpts1, kpts2_list, fm_list, fs_list, featflag_list, **kwargs) aid_list = [qaid] + name_daid_list annotate_matches3(ibs, aid_list, bbox_list, offset_list, name_fm_list, name_fs_list, qreq_=None, **kwargs) ax = pt.gca() title = vh.get_query_text(ibs, None, name_daid_list, False, qaid=qaid, **kwargs) pt.set_title(title, ax) # Case tags annotmatch_rowid_list = ibs.get_annotmatch_rowid_from_superkey( [qaid] * len(name_daid_list), name_daid_list) annotmatch_rowid_list = ut.filter_Nones(annotmatch_rowid_list) tags_list = ibs.get_annotmatch_case_tags(annotmatch_rowid_list) if not ut.get_argflag('--show'): # False: tags_list = tag_funcs.consolodate_annotmatch_tags(tags_list) tag_list = ut.unique_ordered(ut.flatten(tags_list)) name_rank = kwargs.get('name_rank', None) truth = get_multitruth(ibs, aid_list) xlabel = {1: 'Correct ID', 0: 'Incorrect ID', 2: 'Unknown ID'}[truth] if False: if name_rank is None: xlabel = {1: 'Genuine', 0: 'Imposter', 2: 'Unknown'}[truth] #xlabel = {1: 'True', 0: 'False', 2: 'Unknown'}[truth] else: if name_rank == 0: xlabel = { 1: 'True Positive', 0: 'False Positive', 2: 'Unknown' }[truth] else: xlabel = { 1: 'False Negative', 0: 'True Negative', 2: 'Unknown' }[truth] if len(tag_list) > 0: xlabel += '\n' + ', '.join(tag_list) noshow_truth = ut.get_argflag('--noshow_truth') if not noshow_truth: pt.set_xlabel(xlabel) return ax
def show_model(model, evidence={}, soft_evidence={}, **kwargs): """ References: http://stackoverflow.com/questions/22207802/pygraphviz-networkx-set-node-level-or-layer Ignore: pkg-config --libs-only-L libcgraph sudo apt-get install libgraphviz-dev -y sudo apt-get install libgraphviz4 -y # sudo apt-get install pkg-config sudo apt-get install libgraphviz-dev # pip install git+git://github.com/pygraphviz/pygraphviz.git pip install pygraphviz python -c "import pygraphviz; print(pygraphviz.__file__)" sudo pip3 install pygraphviz --install-option="--include-path=/usr/include/graphviz" --install-option="--library-path=/usr/lib/graphviz/" python3 -c "import pygraphviz; print(pygraphviz.__file__)" """ if ut.get_argval('--hackmarkov') or ut.get_argval('--hackjunc'): draw_tree_model(model, **kwargs) return import plottool_ibeis as pt import networkx as netx import matplotlib as mpl fnum = pt.ensure_fnum(None) fig = pt.figure(fnum=fnum, pnum=(3, 1, (slice(0, 2), 0)), doclf=True) # NOQA #fig = pt.figure(fnum=fnum, pnum=(3, 2, (1, slice(1, 2))), doclf=True) # NOQA ax = pt.gca() var2_post = {f.variables[0]: f for f in kwargs.get('factor_list', [])} netx_graph = (model) #netx_graph.graph.setdefault('graph', {})['size'] = '"10,5"' #netx_graph.graph.setdefault('graph', {})['rankdir'] = 'LR' pos = get_hacked_pos(netx_graph) #netx.nx_agraph.pygraphviz_layout(netx_graph) #pos = netx.nx_agraph.pydot_layout(netx_graph, prog='dot') #pos = netx.nx_agraph.graphviz_layout(netx_graph) drawkw = dict(pos=pos, ax=ax, with_labels=True, node_size=1500) if evidence is not None: node_colors = [ # (pt.TRUE_BLUE (pt.WHITE if node not in soft_evidence else pt.LIGHT_PINK) if node not in evidence else pt.FALSE_RED for node in netx_graph.nodes()] for node in netx_graph.nodes(): cpd = model.var2_cpd[node] if cpd.ttype == 'score': pass drawkw['node_color'] = node_colors netx.draw(netx_graph, **drawkw) show_probs = True if show_probs: textprops = { 'family': 'monospace', 'horizontalalignment': 'left', #'horizontalalignment': 'center', #'size': 12, 'size': 8, } textkw = dict( xycoords='data', boxcoords='offset points', pad=0.25, framewidth=True, arrowprops=dict(arrowstyle='->'), #bboxprops=dict(fc=node_attr['fillcolor']), ) netx_nodes = model.nodes(data=True) node_key_list = ut.get_list_column(netx_nodes, 0) pos_list = ut.dict_take(pos, node_key_list) artist_list = [] offset_box_list = [] for pos_, node in zip(pos_list, netx_nodes): x, y = pos_ variable = node[0] cpd = model.var2_cpd[variable] prior_marg = (cpd if cpd.evidence is None else cpd.marginalize(cpd.evidence, inplace=False)) prior_text = None text = None if variable in evidence: text = cpd.variable_statenames[evidence[variable]] elif variable in var2_post: post_marg = var2_post[variable] text = pgm_ext.make_factor_text(post_marg, 'post') prior_text = pgm_ext.make_factor_text(prior_marg, 'prior') else: if len(evidence) == 0 and len(soft_evidence) == 0: prior_text = pgm_ext.make_factor_text(prior_marg, 'prior') show_post = kwargs.get('show_post', False) show_prior = kwargs.get('show_prior', False) show_prior = True show_post = True show_ev = (evidence is not None and variable in evidence) if (show_post or show_ev) and text is not None: offset_box = mpl.offsetbox.TextArea(text, textprops) artist = mpl.offsetbox.AnnotationBbox( # offset_box, (x + 5, y), xybox=(20., 5.), offset_box, (x, y + 5), xybox=(4., 20.), #box_alignment=(0, 0), box_alignment=(.5, 0), **textkw) offset_box_list.append(offset_box) artist_list.append(artist) if show_prior and prior_text is not None: offset_box2 = mpl.offsetbox.TextArea(prior_text, textprops) artist2 = mpl.offsetbox.AnnotationBbox( # offset_box2, (x - 5, y), xybox=(-20., -15.), # offset_box2, (x, y - 5), xybox=(-15., -20.), offset_box2, (x, y - 5), xybox=(-4, -20.), #box_alignment=(1, 1), box_alignment=(.5, 1), **textkw) offset_box_list.append(offset_box2) artist_list.append(artist2) for artist in artist_list: ax.add_artist(artist) xmin, ymin = np.array(pos_list).min(axis=0) xmax, ymax = np.array(pos_list).max(axis=0) num_annots = len(model.ttype2_cpds['name']) if num_annots > 4: ax.set_xlim((xmin - 40, xmax + 40)) ax.set_ylim((ymin - 50, ymax + 50)) fig.set_size_inches(30, 7) else: ax.set_xlim((xmin - 42, xmax + 42)) ax.set_ylim((ymin - 50, ymax + 50)) fig.set_size_inches(23, 7) fig = pt.gcf() title = 'num_names=%r, num_annots=%r' % (model.num_names, num_annots,) map_assign = kwargs.get('map_assign', None) #max_marginal_list = [] #for name, marginal in marginalized_joints.items(): # states = list(ut.iprod(*marginal.statenames)) # vals = marginal.values.ravel() # x = vals.argmax() # max_marginal_list += ['P(' + ', '.join(states[x]) + ') = ' + str(vals[x])] # title += str(marginal) top_assignments = kwargs.get('top_assignments', None) if top_assignments is not None: map_assign, map_prob = top_assignments[0] if map_assign is not None: # title += '\nMAP=' + ut.repr2(map_assign, strvals=True) title += '\nMAP: ' + map_assign + ' @' + '%.2f%%' % (100 * map_prob,) if kwargs.get('show_title', True): pt.set_figtitle(title, size=14) #pt.set_xlabel() def hack_fix_centeralign(): if textprops['horizontalalignment'] == 'center': print('Fixing centeralign') fig = pt.gcf() fig.canvas.draw() # Superhack for centered text. Fix bug in # /usr/local/lib/python2.7/dist-packages/matplotlib/offsetbox.py # /usr/local/lib/python2.7/dist-packages/matplotlib/text.py for offset_box in offset_box_list: offset_box.set_offset z = offset_box._text.get_window_extent() (z.x1 - z.x0) / 2 offset_box._text T = offset_box._text.get_transform() A = mpl.transforms.Affine2D() A.clear() A.translate((z.x1 - z.x0) / 2, 0) offset_box._text.set_transform(T + A) hack_fix_centeralign() top_assignments = kwargs.get('top_assignments', None) if top_assignments is not None: bin_labels = ut.get_list_column(top_assignments, 0) bin_vals = ut.get_list_column(top_assignments, 1) # bin_labels = ['\n'.join(ut.textwrap.wrap(_lbl, width=30)) for _lbl in bin_labels] pt.draw_histogram(bin_labels, bin_vals, fnum=fnum, pnum=(3, 8, (2, slice(4, None))), transpose=True, use_darkbackground=False, #xtick_rotation=-10, ylabel='Prob', xlabel='assignment') pt.set_title('Assignment probabilities')
def plot_chip(self, aid, nRows, nCols, px, **kwargs): """ Plots an individual chip in a subaxis """ ibs = self.ibs enable_chip_title_prefix = ut.is_developer() #enable_chip_title_prefix = False if aid in self.comp_aids: score = self.cm.get_annot_scores([aid])[0] rawscore = self.cm.get_annot_scores([aid])[0] title_suf = kwargs.get('title_suffix', '') if score != rawscore: if score is None: title_suf += '\n score=____' else: title_suf += '\n score=%0.2f' % score title_suf += '\n rawscore=%0.2f' % rawscore else: title_suf = kwargs.get('title_suffix', '') if enable_chip_title_prefix: title_suf = '\n' + title_suf #nid = ibs.get_annot_name_rowids(aid) viz_chip_kw = { 'fnum': self.fnum, 'pnum': (nRows, nCols, px), 'nokpts': True, 'show_gname': False, 'show_exemplar': False, 'show_num_gt': False, 'show_gname': False, 'title_suffix': title_suf, # 'text_color': kwargs.get('color'), ### #'show_name': False, #'show_aidstr': False, 'enable_chip_title_prefix': enable_chip_title_prefix, 'show_name': True, 'show_aidstr': True, 'show_viewcode': True, 'show_quality_text': True, } viz_chip.show_chip(ibs, aid, **viz_chip_kw) ax = pt.gca() if kwargs.get('make_buttons', True): divider = pt.ensure_divider(ax) butkw = { 'divider': divider, 'size': '13%' } self.aid2_ax = {} self.aid2_border = {} if aid in self.comp_aids: callback = partial(self.select, aid) self.append_button('Select This Animal', callback=callback, **butkw) #Hack to toggle colors if aid in self.aid_checkbox_states: #If we are selecting it, then make it green, otherwise change it back to grey if self.aid_checkbox_states[aid]: border = pt.draw_border(ax, color=(0, 1, 0), lw=4) else: border = pt.draw_border(ax, color=(.7, .7, .7), lw=4) self.aid2_border[aid] = border else: self.aid_checkbox_states[aid] = False self.append_button('Examine', callback=partial(self.examine, aid), **butkw)
def show_model(model, evidence={}, soft_evidence={}, **kwargs): """ References: http://stackoverflow.com/questions/22207802/pygraphviz-networkx-set-node-level-or-layer Ignore: pkg-config --libs-only-L libcgraph sudo apt-get install libgraphviz-dev -y sudo apt-get install libgraphviz4 -y # sudo apt-get install pkg-config sudo apt-get install libgraphviz-dev # pip install git+git://github.com/pygraphviz/pygraphviz.git pip install pygraphviz python -c "import pygraphviz; print(pygraphviz.__file__)" sudo pip3 install pygraphviz --install-option="--include-path=/usr/include/graphviz" --install-option="--library-path=/usr/lib/graphviz/" python3 -c "import pygraphviz; print(pygraphviz.__file__)" CommandLine: python -m ibeis.algo.hots.bayes --exec-show_model --show Example: >>> # DISABLE_DOCTEST >>> from ibeis.algo.hots.bayes import * # NOQA >>> model = '?' >>> evidence = {} >>> soft_evidence = {} >>> result = show_model(model, evidence, soft_evidence) >>> print(result) >>> ut.quit_if_noshow() >>> import plottool_ibeis as pt >>> ut.show_if_requested() """ if ut.get_argval('--hackmarkov') or ut.get_argval('--hackjunc'): draw_tree_model(model, **kwargs) return import plottool_ibeis as pt import networkx as netx fnum = pt.ensure_fnum(None) netx_graph = (model) #netx_graph.graph.setdefault('graph', {})['size'] = '"10,5"' #netx_graph.graph.setdefault('graph', {})['rankdir'] = 'LR' pos_dict = get_hacked_pos(netx_graph) #pos_dict = netx.nx_agraph.pygraphviz_layout(netx_graph) #pos = netx.nx_agraph.nx_pydot.pydot_layout(netx_graph, prog='dot') #pos_dict = netx.nx_agraph.graphviz_layout(netx_graph) textprops = { 'family': 'monospace', 'horizontalalignment': 'left', #'horizontalalignment': 'center', #'size': 12, 'size': 8, } netx_nodes = model.nodes(data=True) node_key_list = ut.get_list_column(netx_nodes, 0) pos_list = ut.dict_take(pos_dict, node_key_list) var2_post = {f.variables[0]: f for f in kwargs.get('factor_list', [])} prior_text = None post_text = None evidence_tas = [] post_tas = [] prior_tas = [] node_color = [] has_inferred = evidence or var2_post if has_inferred: ignore_prior_with_ttype = [SCORE_TTYPE, MATCH_TTYPE] show_prior = False else: ignore_prior_with_ttype = [] #show_prior = True show_prior = False dpy = 5 dbx, dby = (20, 20) takw1 = {'bbox_align': (.5, 0), 'pos_offset': [0, dpy], 'bbox_offset': [dbx, dby]} takw2 = {'bbox_align': (.5, 1), 'pos_offset': [0, -dpy], 'bbox_offset': [-dbx, -dby]} name_colors = pt.distinct_colors(max(model.num_names, 10)) name_colors = name_colors[:model.num_names] #cmap_ = 'hot' #mx = 0.65 #mn = 0.15 cmap_, mn, mx = 'plasma', 0.15, 1.0 _cmap = pt.plt.get_cmap(cmap_) def cmap(x): return _cmap((x * mx) + mn) for node, pos in zip(netx_nodes, pos_list): variable = node[0] cpd = model.var2_cpd[variable] prior_marg = (cpd if cpd.evidence is None else cpd.marginalize(cpd.evidence, inplace=False)) show_evidence = variable in evidence show_prior = cpd.ttype not in ignore_prior_with_ttype show_post = variable in var2_post show_prior |= cpd.ttype not in ignore_prior_with_ttype post_marg = None if show_post: post_marg = var2_post[variable] def get_name_color(phi): order = phi.values.argsort()[::-1] if len(order) < 2: dist_next = phi.values[order[0]] else: dist_next = phi.values[order[0]] - phi.values[order[1]] dist_total = (phi.values[order[0]]) confidence = (dist_total * dist_next) ** (2.5 / 4) #print('confidence = %r' % (confidence,)) color = name_colors[order[0]] color = pt.color_funcs.desaturate_rgb(color, 1 - confidence) color = np.array(color) return color if variable in evidence: if cpd.ttype == SCORE_TTYPE: cmap_index = evidence[variable] / (cpd.variable_card - 1) color = cmap(cmap_index) color = pt.lighten_rgb(color, .4) color = np.array(color) node_color.append(color) elif cpd.ttype == NAME_TTYPE: color = name_colors[evidence[variable]] color = np.array(color) node_color.append(color) else: color = pt.FALSE_RED node_color.append(color) #elif variable in soft_evidence: # color = pt.LIGHT_PINK # show_prior = True # color = get_name_color(prior_marg) # node_color.append(color) else: if cpd.ttype == NAME_TTYPE and post_marg is not None: color = get_name_color(post_marg) node_color.append(color) elif cpd.ttype == MATCH_TTYPE and post_marg is not None: color = cmap(post_marg.values[1]) color = pt.lighten_rgb(color, .4) color = np.array(color) node_color.append(color) else: #color = pt.WHITE color = pt.NEUTRAL node_color.append(color) if show_prior: if variable in soft_evidence: prior_color = pt.LIGHT_PINK else: prior_color = None prior_text = pgm_ext.make_factor_text(prior_marg, 'prior') prior_tas.append(dict(text=prior_text, pos=pos, color=prior_color, **takw2)) if show_evidence: _takw1 = takw1 if cpd.ttype == SCORE_TTYPE: _takw1 = takw2 evidence_text = cpd.variable_statenames[evidence[variable]] if isinstance(evidence_text, int): evidence_text = '%d/%d' % (evidence_text + 1, cpd.variable_card) evidence_tas.append(dict(text=evidence_text, pos=pos, color=color, **_takw1)) if show_post: _takw1 = takw1 if cpd.ttype == MATCH_TTYPE: _takw1 = takw2 post_text = pgm_ext.make_factor_text(post_marg, 'post') post_tas.append(dict(text=post_text, pos=pos, color=None, **_takw1)) def trnps_(dict_list): """ tranpose dict list """ list_dict = ut.ddict(list) for dict_ in dict_list: for key, val in dict_.items(): list_dict[key + '_list'].append(val) return list_dict takw1_ = trnps_(post_tas + evidence_tas) takw2_ = trnps_(prior_tas) # Draw graph if has_inferred: pnum1 = (3, 1, (slice(0, 2), 0)) else: pnum1 = None fig = pt.figure(fnum=fnum, pnum=pnum1, doclf=True) # NOQA ax = pt.gca() #print('node_color = %s' % (ut.repr3(node_color),)) drawkw = dict(pos=pos_dict, ax=ax, with_labels=True, node_size=1500, node_color=node_color) netx.draw(netx_graph, **drawkw) hacks = [] if len(post_tas + evidence_tas): hacks.append(pt.draw_text_annotations(textprops=textprops, **takw1_)) if prior_tas: hacks.append(pt.draw_text_annotations(textprops=textprops, **takw2_)) xmin, ymin = np.array(pos_list).min(axis=0) xmax, ymax = np.array(pos_list).max(axis=0) num_annots = len(model.ttype2_cpds[NAME_TTYPE]) if num_annots > 4: ax.set_xlim((xmin - 40, xmax + 40)) ax.set_ylim((ymin - 50, ymax + 50)) fig.set_size_inches(30, 7) else: ax.set_xlim((xmin - 42, xmax + 42)) ax.set_ylim((ymin - 50, ymax + 50)) fig.set_size_inches(23, 7) fig = pt.gcf() title = 'num_names=%r, num_annots=%r' % (model.num_names, num_annots,) map_assign = kwargs.get('map_assign', None) top_assignments = kwargs.get('top_assignments', None) if top_assignments is not None: map_assign, map_prob = top_assignments[0] if map_assign is not None: def word_insert(text): return '' if len(text) == 0 else text + ' ' title += '\n%sMAP: ' % (word_insert(kwargs.get('method', ''))) title += map_assign + ' @' + '%.2f%%' % (100 * map_prob,) if kwargs.get('show_title', True): pt.set_figtitle(title, size=14) for hack in hacks: hack() # Hack in colorbars if has_inferred: pt.colorbar(np.linspace(0, 1, len(name_colors)), name_colors, lbl=NAME_TTYPE, ticklabels=model.ttype2_template[NAME_TTYPE].basis, ticklocation='left') basis = model.ttype2_template[SCORE_TTYPE].basis scalars = np.linspace(0, 1, len(basis)) scalars = np.linspace(0, 1, 100) colors = pt.scores_to_color(scalars, cmap_=cmap_, reverse_cmap=False, cmap_range=(mn, mx)) colors = [pt.lighten_rgb(c, .4) for c in colors] if ut.list_type(basis) is int: pt.colorbar(scalars, colors, lbl=SCORE_TTYPE, ticklabels=np.array(basis) + 1) else: pt.colorbar(scalars, colors, lbl=SCORE_TTYPE, ticklabels=basis) #print('basis = %r' % (basis,)) # Draw probability hist if has_inferred and top_assignments is not None: bin_labels = ut.get_list_column(top_assignments, 0) bin_vals = ut.get_list_column(top_assignments, 1) # bin_labels = ['\n'.join(ut.textwrap.wrap(_lbl, width=30)) for _lbl in bin_labels] pt.draw_histogram(bin_labels, bin_vals, fnum=fnum, pnum=(3, 8, (2, slice(4, None))), transpose=True, use_darkbackground=False, #xtick_rotation=-10, ylabel='Prob', xlabel='assignment') pt.set_title('Assignment probabilities')
def _dev_iters_until_threshold(): """ INTERACTIVE DEVELOPMENT FUNCTION How many iterations of ewma until you hit the poisson / biniomal threshold This establishes a principled way to choose the threshold for the refresh criterion in my thesis. There are paramters --- moving parts --- that we need to work with: `a` the patience, `s` the span, and `mu` our ewma. `s` is a span paramter indicating how far we look back. `mu` is the average number of label-changing reviews in roughly the last `s` manual decisions. These numbers are used to estimate the probability that any of the next `a` manual decisions will be label-chanigng. When that probability falls below a threshold we terminate. The goal is to choose `a`, `s`, and the threshold `t`, such that the probability will fall below the threshold after a maximum of `a` consecutive non-label-chaning reviews. IE we want to tie the patience paramter (how far we look ahead) to how far we actually are willing to go. """ import numpy as np import utool as ut import sympy as sym i = sym.symbols('i', integer=True, nonnegative=True, finite=True) # mu_i = sym.symbols('mu_i', integer=True, nonnegative=True, finite=True) s = sym.symbols('s', integer=True, nonnegative=True, finite=True) # NOQA thresh = sym.symbols('tau', real=True, nonnegative=True, finite=True) # NOQA alpha = sym.symbols('alpha', real=True, nonnegative=True, finite=True) # NOQA c_alpha = sym.symbols('c_alpha', real=True, nonnegative=True, finite=True) # patience a = sym.symbols('a', real=True, nonnegative=True, finite=True) available_subs = { a: 20, s: a, alpha: 2 / (s + 1), c_alpha: (1 - alpha), } def subs(expr, d=available_subs): """ recursive expression substitution """ expr1 = expr.subs(d) if expr == expr1: return expr1 else: return subs(expr1, d=d) # mu is either the support for the poisson distribution # or is is the p in the binomial distribution # It is updated at timestep i based on ewma, assuming each incoming responce is 0 mu_0 = 1.0 mu_i = c_alpha ** i # Estimate probability that any event will happen in the next `a` reviews # at time `i`. poisson_i = 1 - sym.exp(-mu_i * a) binom_i = 1 - (1 - mu_i) ** a # Expand probabilities to be a function of i, s, and a part = ut.delete_dict_keys(available_subs.copy(), [a, s]) mu_i = subs(mu_i, d=part) poisson_i = subs(poisson_i, d=part) binom_i = subs(binom_i, d=part) if True: # ewma of mu at time i if review is always not label-changing (meaningful) mu_1 = c_alpha * mu_0 # NOQA mu_2 = c_alpha * mu_1 # NOQA if True: i_vals = np.arange(0, 100) mu_vals = np.array([subs(mu_i).subs({i: i_}).evalf() for i_ in i_vals]) # NOQA binom_vals = np.array([subs(binom_i).subs({i: i_}).evalf() for i_ in i_vals]) # NOQA poisson_vals = np.array([subs(poisson_i).subs({i: i_}).evalf() for i_ in i_vals]) # NOQA # Find how many iters it actually takes my expt to terminate thesis_draft_thresh = np.exp(-2) np.where(mu_vals < thesis_draft_thresh)[0] np.where(binom_vals < thesis_draft_thresh)[0] np.where(poisson_vals < thesis_draft_thresh)[0] sym.pprint(sym.simplify(mu_i)) sym.pprint(sym.simplify(binom_i)) sym.pprint(sym.simplify(poisson_i)) # Find the thresholds that force termination after `a` reviews have passed # do this by setting i=a poisson_thresh = poisson_i.subs({i: a}) binom_thresh = binom_i.subs({i: a}) print('Poisson thresh') print(sym.latex(sym.Eq(thresh, poisson_thresh))) print(sym.latex(sym.Eq(thresh, sym.simplify(poisson_thresh)))) poisson_thresh.subs({a: 115, s: 30}).evalf() sym.pprint(sym.Eq(thresh, poisson_thresh)) sym.pprint(sym.Eq(thresh, sym.simplify(poisson_thresh))) print('Binomial thresh') sym.pprint(sym.simplify(binom_thresh)) sym.pprint(sym.simplify(poisson_thresh.subs({s: a}))) def taud(coeff): return coeff * 360 if 'poisson_cache' not in vars(): poisson_cache = {} binom_cache = {} S, A = np.meshgrid(np.arange(1, 150, 1), np.arange(0, 150, 1)) import plottool_ibeis as pt SA_coords = list(zip(S.ravel(), A.ravel())) for sval, aval in ut.ProgIter(SA_coords): if (sval, aval) not in poisson_cache: poisson_cache[(sval, aval)] = float(poisson_thresh.subs({a: aval, s: sval}).evalf()) poisson_zdata = np.array( [poisson_cache[(sval, aval)] for sval, aval in SA_coords]).reshape(A.shape) fig = pt.figure(fnum=1, doclf=True) pt.gca().set_axis_off() pt.plot_surface3d(S, A, poisson_zdata, xlabel='s', ylabel='a', rstride=3, cstride=3, zlabel='poisson', mode='wire', contour=True, title='poisson3d') pt.gca().set_zlim(0, 1) pt.gca().view_init(elev=taud(1 / 16), azim=taud(5 / 8)) fig.set_size_inches(10, 6) fig.savefig('a-s-t-poisson3d.png', dpi=300, bbox_inches=pt.extract_axes_extents(fig, combine=True)) for sval, aval in ut.ProgIter(SA_coords): if (sval, aval) not in binom_cache: binom_cache[(sval, aval)] = float(binom_thresh.subs({a: aval, s: sval}).evalf()) binom_zdata = np.array( [binom_cache[(sval, aval)] for sval, aval in SA_coords]).reshape(A.shape) fig = pt.figure(fnum=2, doclf=True) pt.gca().set_axis_off() pt.plot_surface3d(S, A, binom_zdata, xlabel='s', ylabel='a', rstride=3, cstride=3, zlabel='binom', mode='wire', contour=True, title='binom3d') pt.gca().set_zlim(0, 1) pt.gca().view_init(elev=taud(1 / 16), azim=taud(5 / 8)) fig.set_size_inches(10, 6) fig.savefig('a-s-t-binom3d.png', dpi=300, bbox_inches=pt.extract_axes_extents(fig, combine=True)) # Find point on the surface that achieves a reasonable threshold # Sympy can't solve this # sym.solve(sym.Eq(binom_thresh.subs({s: 50}), .05)) # sym.solve(sym.Eq(poisson_thresh.subs({s: 50}), .05)) # Find a numerical solution def solve_numeric(expr, target, want, fixed, method=None, bounds=None): """ Args: expr (Expr): symbolic expression target (float): numberic value fixed (dict): fixed values of the symbol expr = poisson_thresh expr.free_symbols fixed = {s: 10} solve_numeric(poisson_thresh, .05, {s: 30}, method=None) solve_numeric(poisson_thresh, .05, {s: 30}, method='Nelder-Mead') solve_numeric(poisson_thresh, .05, {s: 30}, method='BFGS') """ import scipy.optimize # Find the symbol you want to solve for want_symbols = expr.free_symbols - set(fixed.keys()) # TODO: can probably extend this to multiple params assert len(want_symbols) == 1, 'specify all but one var' assert want == list(want_symbols)[0] fixed_expr = expr.subs(fixed) def func(a1): expr_value = float(fixed_expr.subs({want: a1}).evalf()) return (expr_value - target) ** 2 # if method is None: # method = 'Nelder-Mead' # method = 'Newton-CG' # method = 'BFGS' # Use one of the other params the startin gpoing a1 = list(fixed.values())[0] result = scipy.optimize.minimize(func, x0=a1, method=method, bounds=bounds) if not result.success: print('\n') print(result) print('\n') return result # Numeric measurments of thie line thresh_vals = [.001, .01, .05, .1, .135] svals = np.arange(1, 100) target_poisson_plots = {} for target in ut.ProgIter(thresh_vals, bs=False, freq=1): poisson_avals = [] for sval in ut.ProgIter(svals, 'poisson', freq=1): expr = poisson_thresh fixed = {s: sval} want = a aval = solve_numeric(expr, target, want, fixed, method='Nelder-Mead').x[0] poisson_avals.append(aval) target_poisson_plots[target] = (svals, poisson_avals) fig = pt.figure(fnum=3) for target, dat in target_poisson_plots.items(): pt.plt.plot(*dat, label='prob={}'.format(target)) pt.gca().set_xlabel('s') pt.gca().set_ylabel('a') pt.legend() pt.gca().set_title('poisson') fig.set_size_inches(5, 3) fig.savefig('a-vs-s-poisson.png', dpi=300, bbox_inches=pt.extract_axes_extents(fig, combine=True)) target_binom_plots = {} for target in ut.ProgIter(thresh_vals, bs=False, freq=1): binom_avals = [] for sval in ut.ProgIter(svals, 'binom', freq=1): aval = solve_numeric(binom_thresh, target, a, {s: sval}, method='Nelder-Mead').x[0] binom_avals.append(aval) target_binom_plots[target] = (svals, binom_avals) fig = pt.figure(fnum=4) for target, dat in target_binom_plots.items(): pt.plt.plot(*dat, label='prob={}'.format(target)) pt.gca().set_xlabel('s') pt.gca().set_ylabel('a') pt.legend() pt.gca().set_title('binom') fig.set_size_inches(5, 3) fig.savefig('a-vs-s-binom.png', dpi=300, bbox_inches=pt.extract_axes_extents(fig, combine=True)) # ---- if True: fig = pt.figure(fnum=5, doclf=True) s_vals = [1, 2, 3, 10, 20, 30, 40, 50] for sval in s_vals: pp = poisson_thresh.subs({s: sval}) a_vals = np.arange(0, 200) pp_vals = np.array([float(pp.subs({a: aval}).evalf()) for aval in a_vals]) # NOQA pt.plot(a_vals, pp_vals, label='s=%r' % (sval,)) pt.legend() pt.gca().set_xlabel('a') pt.gca().set_ylabel('poisson prob after a reviews') fig.set_size_inches(5, 3) fig.savefig('a-vs-thresh-poisson.png', dpi=300, bbox_inches=pt.extract_axes_extents(fig, combine=True)) fig = pt.figure(fnum=6, doclf=True) s_vals = [1, 2, 3, 10, 20, 30, 40, 50] for sval in s_vals: pp = binom_thresh.subs({s: sval}) a_vals = np.arange(0, 200) pp_vals = np.array([float(pp.subs({a: aval}).evalf()) for aval in a_vals]) # NOQA pt.plot(a_vals, pp_vals, label='s=%r' % (sval,)) pt.legend() pt.gca().set_xlabel('a') pt.gca().set_ylabel('binom prob after a reviews') fig.set_size_inches(5, 3) fig.savefig('a-vs-thresh-binom.png', dpi=300, bbox_inches=pt.extract_axes_extents(fig, combine=True)) # ------- fig = pt.figure(fnum=5, doclf=True) a_vals = [1, 2, 3, 10, 20, 30, 40, 50] for aval in a_vals: pp = poisson_thresh.subs({a: aval}) s_vals = np.arange(1, 200) pp_vals = np.array([float(pp.subs({s: sval}).evalf()) for sval in s_vals]) # NOQA pt.plot(s_vals, pp_vals, label='a=%r' % (aval,)) pt.legend() pt.gca().set_xlabel('s') pt.gca().set_ylabel('poisson prob') fig.set_size_inches(5, 3) fig.savefig('s-vs-thresh-poisson.png', dpi=300, bbox_inches=pt.extract_axes_extents(fig, combine=True)) fig = pt.figure(fnum=5, doclf=True) a_vals = [1, 2, 3, 10, 20, 30, 40, 50] for aval in a_vals: pp = binom_thresh.subs({a: aval}) s_vals = np.arange(1, 200) pp_vals = np.array([float(pp.subs({s: sval}).evalf()) for sval in s_vals]) # NOQA pt.plot(s_vals, pp_vals, label='a=%r' % (aval,)) pt.legend() pt.gca().set_xlabel('s') pt.gca().set_ylabel('binom prob') fig.set_size_inches(5, 3) fig.savefig('s-vs-thresh-binom.png', dpi=300, bbox_inches=pt.extract_axes_extents(fig, combine=True)) #--------------------- # Plot out a table mu_i.subs({s: 75, a: 75}).evalf() poisson_thresh.subs({s: 75, a: 75}).evalf() sval = 50 for target, dat in target_poisson_plots.items(): slope = np.median(np.diff(dat[1])) aval = int(np.ceil(sval * slope)) thresh = float(poisson_thresh.subs({s: sval, a: aval}).evalf()) print('aval={}, sval={}, thresh={}, target={}'.format(aval, sval, thresh, target)) for target, dat in target_binom_plots.items(): slope = np.median(np.diff(dat[1])) aval = int(np.ceil(sval * slope))
def show_single_namematch(): import plottool_ibeis as pt ax = cm.show_single_namematch(qreq_, aid2, mode=0) ax = pt.gca() ax.figure.canvas.draw() pt.update()
def do_infr_test(ccs, edges, new_edges): """ Creates a graph with `ccs` + `edges` and then adds `new_edges` """ # import networkx as nx import plottool_ibeis as pt infr = demo.make_demo_infr(ccs, edges) if ut.show_was_requested(): pt.qtensure() # Preshow fnum = 1 if ut.show_was_requested(): infr.set_node_attrs('shape', 'circle') infr.show(pnum=(2, 1, 1), fnum=fnum, show_unreviewed_edges=True, show_reviewed_cuts=True, splines='spline', show_inferred_diff=True, groupby='name_label', show_labels=True, pickable=True) pt.set_title('pre-review') pt.gca().set_aspect('equal') infr.set_node_attrs('pin', 'true') # fig1 = pt.gcf() # fig1.canvas.mpl_connect('pick_event', ut.partial(on_pick, infr=infr)) infr1 = infr infr2 = infr.copy() for new_edge in new_edges: aid1, aid2, data = new_edge evidence_decision = data['evidence_decision'] infr2.add_feedback((aid1, aid2), evidence_decision) infr2.relabel_using_reviews(rectify=False) infr2.apply_nondynamic_update() # Postshow if ut.show_was_requested(): infr2.show(pnum=(2, 1, 2), fnum=fnum, show_unreviewed_edges=True, show_inferred_diff=True, show_labels=True) pt.gca().set_aspect('equal') pt.set_title('post-review') # fig2 = pt.gcf() # if fig2 is not fig1: # fig2.canvas.mpl_connect('pick_event', ut.partial(on_pick, infr=infr2)) class Checker(object): """ Asserts pre and post test properties of the graph """ def __init__(self, infr1, infr2): self._errors = [] self.infr1 = infr1 self.infr2 = infr2 def __call__(self, infr, u, v, key, val, msg): data = infr.get_nonvisual_edge_data((u, v)) if data is None: assert infr.graph.has_edge(u, v), ( 'uv=%r, %r does not exist' % (u, v)) got = data.get(key) if got != val: msg1 = 'key=%s %r!=%r, ' % (key, got, val) errmsg = ''.join([msg1, msg, '\nedge=', ut.repr2((u, v)), '\n', infr.repr_edge_data(data)]) self._errors.append(errmsg) def custom_precheck(self, func): try: func(self.infr1) except AssertionError as ex: self._errors.append(str(ex)) def after(self, errors=[]): """ Delays error reporting until after visualization prints errors, then shows you the graph, then finally if any errors were discovered they are raised """ errors = errors + self._errors if errors: ut.cprint('PRINTING %d FAILURE' % (len(errors)), 'red') for msg in errors: print(msg) ut.cprint('HAD %d FAILURE' % (len(errors)), 'red') if ut.show_was_requested(): pt.all_figures_tile(percent_w=.5) ut.show_if_requested() if errors: raise AssertionError('There were errors') check = Checker(infr1, infr2) return infr1, infr2, check
def plot_chip(self, aid, nRows, nCols, px, fulldraw=True, **kwargs): """ Plots an individual chip in a subaxis """ ibs = self.ibs if aid in [self.aid1, self.aid2]: # Bold color for the matching chips lw = 5 text_color = np.array((135, 206, 235, 255)) / 255.0 else: lw = 2 text_color = None pnum = (nRows, nCols, px) if not fulldraw: # not doing full draw so we have to clear any axes # that are here already manually ax = self.fig.add_subplot(*pnum) self.clear_parent_axes(ax) #ut.embed() #print(subax) viz_chip_kw = { 'fnum': self.fnum, 'pnum': pnum, 'nokpts': True, 'show_name': True, 'show_gname': False, 'show_aidstr': True, 'notitle': True, 'show_num_gt': False, 'text_color': text_color, } if False and ut.is_developer(): enable_chip_title_prefix = True viz_chip_kw.update({ 'enable_chip_title_prefix': enable_chip_title_prefix, 'show_name': True, 'show_aidstr': True, 'show_viewcode': True, 'show_num_gt': True, 'show_quality_text': True, }) viz_chip.show_chip(ibs, aid, **viz_chip_kw) ax = pt.gca() pt.draw_border(ax, color=kwargs.get('color'), lw=lw) if kwargs.get('make_buttons', True): #divider = pt.ensure_divider(ax) butkw = { #'divider': divider, 'ax': ax, 'size': '13%' #'size': '15%' } # Chip matching/naming options nid = ibs.get_annot_name_rowids(aid) annotation_unknown = ibs.is_nid_unknown([nid])[0] if not annotation_unknown: # remove name callback = functools.partial(self.unname_annotation, aid) self.append_button('remove name (' + ibs.get_name_texts(nid) + ')', callback=callback, **butkw) else: # new name callback = functools.partial(self.mark_annotation_as_new_name, aid) self.append_button('mark as new name', callback=callback, **butkw) if nid != self.nid2 and not ibs.is_nid_unknown( [self.nid2])[0] and not self.is_split_case: # match to nid2 callback = functools.partial(self.rename_annotation, aid, self.nid2) text = 'match to name2: ' + ibs.get_name_texts(self.nid2) self.append_button(text, callback=callback, **butkw) if nid != self.nid1 and not ibs.is_nid_unknown([self.nid1])[0]: # match to nid1 callback = functools.partial(self.rename_annotation, aid, self.nid1) text = 'match to name1: ' + ibs.get_name_texts(self.nid1) self.append_button(text, callback=callback, **butkw) other_nid_list = self.get_other_nids() for other_nid in other_nid_list: if other_nid == nid: continue # rename nid2 callback = functools.partial(self.rename_annotation, aid, other_nid) text = 'match to: ' + ibs.get_name_texts(other_nid) self.append_button(text, callback=callback, **butkw) return ax
def draw_markov_model(model, fnum=None, **kwargs): import plottool_ibeis as pt fnum = pt.ensure_fnum(fnum) pt.figure(fnum=fnum, doclf=True) ax = pt.gca() from pgmpy.models import MarkovModel if isinstance(model, MarkovModel): markovmodel = model else: markovmodel = model.to_markov_model() # pos = nx.nx_agraph.pydot_layout(markovmodel) pos = nx.nx_agraph.pygraphviz_layout(markovmodel) # Referenecs: # https://groups.google.com/forum/#!topic/networkx-discuss/FwYk0ixLDuY # pos = nx.spring_layout(markovmodel) # pos = nx.circular_layout(markovmodel) # curved-arrow # markovmodel.edge_attr['curved-arrow'] = True # markovmodel.graph.setdefault('edge', {})['splines'] = 'curved' # markovmodel.graph.setdefault('graph', {})['splines'] = 'curved' # markovmodel.graph.setdefault('edge', {})['splines'] = 'curved' node_color = [pt.NEUTRAL] * len(pos) drawkw = dict( pos=pos, ax=ax, with_labels=True, node_color=node_color, # NOQA node_size=1100) from matplotlib.patches import FancyArrowPatch, Circle import numpy as np def draw_network(G, pos, ax, sg=None): for n in G: c = Circle(pos[n], radius=10, alpha=0.5, color=pt.NEUTRAL_BLUE) ax.add_patch(c) G.nodes[n]['patch'] = c x, y = pos[n] pt.ax_absolute_text(x, y, n, ha='center', va='center') seen = {} for (u, v, d) in G.edges(data=True): n1 = G.nodes[u]['patch'] n2 = G.nodes[v]['patch'] rad = 0.1 if (u, v) in seen: rad = seen.get((u, v)) rad = (rad + np.sign(rad) * 0.1) * -1 alpha = 0.5 color = 'k' e = FancyArrowPatch( n1.center, n2.center, patchA=n1, patchB=n2, # arrowstyle='-|>', arrowstyle='-', connectionstyle='arc3,rad=%s' % rad, mutation_scale=10.0, lw=2, alpha=alpha, color=color) seen[(u, v)] = rad ax.add_patch(e) return e # nx.draw(markovmodel, **drawkw) draw_network(markovmodel, pos, ax) ax.autoscale() pt.plt.axis('equal') pt.plt.axis('off') if kwargs.get('show_title', True): pt.set_figtitle('Markov Model')
def annotate_matches3(ibs, aid_list, bbox_list, offset_list, name_fm_list, name_fs_list, qreq_=None, **kwargs): """ TODO: use this as the main function. """ # TODO Use this function when you clean show_matches in_image = kwargs.get('in_image', False) #show_query = kwargs.get('show_query', True) draw_border = kwargs.get('draw_border', True) draw_lbl = kwargs.get('draw_lbl', True) notitle = kwargs.get('notitle', False) # List of annotation scores for each annot in the name #printDBG('[viz] annotate_matches3()') #truth = ibs.get_match_truth(aid1, aid2) #name_equality = ( # np.array(ibs.get_annot_nids(aid_list[1:])) == ibs.get_annot_nids(aid_list[0]) #).tolist() #truth = 1 if all(name_equality) else (2 if any(name_equality) else 0) #truth_color = vh.get_truth_color(truth) ## Build title #score = kwargs.pop('score', None) #rawscore = kwargs.pop('rawscore', None) #aid2_raw_rank = kwargs.pop('aid2_raw_rank', None) #print(kwargs) #title = vh.get_query_text(ibs, None, aid2, truth, qaid=aid1, **kwargs) # Build xlbl ax = pt.gca() ph.set_plotdat(ax, 'viztype', 'multi_match') ph.set_plotdat(ax, 'qaid', aid_list[0]) ph.set_plotdat(ax, 'num_matches', len(aid_list) - 1) ph.set_plotdat(ax, 'aid_list', aid_list[1:]) for count, aid in enumerate(aid_list, start=1): ph.set_plotdat(ax, 'aid%d' % (count, ), aid) #name_equality = (ibs.get_annot_nids(aid_list[0]) == # np.array(ibs.get_annot_nids(aid_list[1:]))) #truth = 1 if np.all(name_equality) else (2 if np.any(name_equality) else 0) truth = get_multitruth(ibs, aid_list) if any(ibs.is_aid_unknown(aid_list[1:])) or ibs.is_aid_unknown( aid_list[0]): truth = ibs.const.EVIDENCE_DECISION.UNKNOWN truth_color = vh.get_truth_color(truth) name_annot_scores = kwargs.get('name_annot_scores', None) if len(aid_list) == 2: # HACK; generalize to multple annots title = vh.get_query_text(ibs, None, aid_list[1], truth, qaid=aid_list[0], **kwargs) if not notitle: pt.set_title(title, ax) if draw_lbl: # Build labels nid_list = ibs.get_annot_nids(aid_list, distinguish_unknowns=False) name_list = ibs.get_annot_names(aid_list) lbls_list = [[] for _ in range(len(aid_list))] if kwargs.get('show_name', False): for count, (lbls, name) in enumerate(zip(lbls_list, name_list)): lbls.append(ut.repr2((name))) if kwargs.get('show_nid', True): for count, (lbls, nid) in enumerate(zip(lbls_list, nid_list)): # only label the first two images with nids LABEL_ALL_NIDS = False if count <= 1 or LABEL_ALL_NIDS: #lbls.append(vh.get_nidstrs(nid)) lbls.append(('q' if count == 0 else '') + vh.get_nidstrs(nid)) if kwargs.get('show_aid', True): for count, (lbls, aid) in enumerate(zip(lbls_list, aid_list)): lbls.append(('q' if count == 0 else '') + vh.get_aidstrs(aid)) if (kwargs.get('show_annot_score', True) and name_annot_scores is not None): max_digits = kwargs.get('score_precision', None) for (lbls, score) in zip(lbls_list[1:], name_annot_scores): lbls.append(ut.num_fmt(score, max_digits=max_digits)) lbl_list = [' : '.join(lbls) for lbls in lbls_list] else: lbl_list = [None] * len(aid_list) # Plot annotations over images if in_image: in_image_bbox_list = vh.get_bboxes(ibs, aid_list, offset_list) in_image_theta_list = ibs.get_annot_thetas(aid_list) # HACK! #if show_query: # pt.draw_bbox(bbox1, bbox_color=pt.ORANGE, lbl=lbl1, theta=theta1) bbox_color = pt.ORANGE bbox_color = truth_color if draw_border else pt.ORANGE for bbox, theta, lbl in zip(in_image_bbox_list, in_image_theta_list, lbl_list): pt.draw_bbox(bbox, bbox_color=bbox_color, lbl=lbl, theta=theta) pass else: xy, w, h = pt.get_axis_xy_width_height(ax) if draw_border: pt.draw_border(ax, color=truth_color, lw=4) if draw_lbl: # Custom user lbl for chips 1 and 2 for bbox, lbl in zip(bbox_list, lbl_list): (x, y, w, h) = bbox pt.absolute_lbl(x + w, y, lbl) # No matches draw a red box if True: no_matches = (name_fm_list is None or all( [True if fm is None else len(fm) == 0 for fm in name_fm_list])) if no_matches: xy, w, h = pt.get_axis_xy_width_height(ax) #axes_bbox = (xy[0], xy[1], w, h) if draw_border: pass
def demo_refresh(): r""" CommandLine: python -m ibeis.algo.graph.refresh demo_refresh \ --num_pccs=40 --size=2 --show Example: >>> # ENABLE_DOCTEST >>> from ibeis.algo.graph.refresh import * # NOQA >>> demo_refresh() >>> ut.show_if_requested() """ from ibeis.algo.graph import demo demokw = ut.argparse_dict({'num_pccs': 50, 'size': 4}) refreshkw = ut.argparse_funckw(RefreshCriteria) # make an inference object infr = demo.demodata_infr(size_std=0, **demokw) edges = list(infr.dummy_verif.find_candidate_edges(K=100)) scores = np.array(infr.dummy_verif.predict_edges(edges)) sortx = scores.argsort()[::-1] edges = ut.take(edges, sortx) scores = scores[sortx] ys = infr.match_state_df(edges)[POSTV].values y_remainsum = ys[::-1].cumsum()[::-1] # Do oracle reviews and wait to converge refresh = RefreshCriteria(**refreshkw) xdata = [] pprob_any = [] rfrac_any = [] for count, (edge, y) in enumerate(zip(edges, ys)): refresh.add(y, user_id='user:oracle') rfrac_any.append(y_remainsum[count] / y_remainsum[0]) pprob_any.append(refresh.prob_any_remain()) xdata.append(count + 1) if refresh.check(): break xdata = xdata ydatas = ut.odict([ ('Est. probability any remain', pprob_any), ('Fraction remaining', rfrac_any), ]) ut.quit_if_noshow() import plottool_ibeis as pt pt.qtensure() from ibeis.scripts.thesis import TMP_RC import matplotlib as mpl mpl.rcParams.update(TMP_RC) pt.multi_plot( xdata, ydatas, xlabel='# manual reviews', rcParams=TMP_RC, marker='', ylim=(0, 1), use_legend=False, ) demokw = ut.map_keys({'num_pccs': '#PCC', 'size': 'PCC size'}, demokw) thresh = refreshkw.pop('thresh') refreshkw['span'] = refreshkw.pop('window') pt.relative_text((.02, .58 + .0), ut.get_cfg_lbl(demokw, sep=' ')[1:], valign='bottom') pt.relative_text((.02, .68 + .0), ut.get_cfg_lbl(refreshkw, sep=' ')[1:], valign='bottom') legend = pt.gca().legend() legend.get_frame().set_alpha(1.0) pt.plt.plot([xdata[0], xdata[-1]], [thresh, thresh], 'g--', label='thresh')
def annotate_matches2( ibs, aid1, aid2, fm, fs, offset1=(0, 0), offset2=(0, 0), xywh2=None, # (0, 0, 0, 0), xywh1=None, # (0, 0, 0, 0), qreq_=None, **kwargs): """ TODO: use this as the main function. """ if True: aid_list = [aid1, aid2] bbox_list = [xywh1, xywh2] offset_list = [offset1, offset2] name_fm_list = [fm] name_fs_list = [fs] return annotate_matches3(ibs, aid_list, bbox_list, offset_list, name_fm_list, name_fs_list, qreq_=qreq_, **kwargs) else: # TODO: make sure all of this functionality is incorporated into annotate_matches3 in_image = kwargs.get('in_image', False) show_query = kwargs.get('show_query', True) draw_border = kwargs.get('draw_border', True) draw_lbl = kwargs.get('draw_lbl', True) notitle = kwargs.get('notitle', False) truth = ibs.get_match_truth(aid1, aid2) truth_color = vh.get_truth_color(truth) # Build title title = vh.get_query_text(ibs, None, aid2, truth, qaid=aid1, **kwargs) # Build xlbl ax = pt.gca() ph.set_plotdat(ax, 'viztype', 'matches') ph.set_plotdat(ax, 'qaid', aid1) ph.set_plotdat(ax, 'aid1', aid1) ph.set_plotdat(ax, 'aid2', aid2) if draw_lbl: name1, name2 = ibs.get_annot_names([aid1, aid2]) nid1, nid2 = ibs.get_annot_name_rowids([aid1, aid2], distinguish_unknowns=False) #lbl1 = repr(name1) + ' : ' + 'q' + vh.get_aidstrs(aid1) #lbl2 = repr(name2) + ' : ' + vh.get_aidstrs(aid2) lbl1_list = [] lbl2_list = [] if kwargs.get('show_aid', True): lbl1_list.append('q' + vh.get_aidstrs(aid1)) lbl2_list.append(vh.get_aidstrs(aid2)) if kwargs.get('show_name', True): lbl1_list.append(repr((name1))) lbl2_list.append(repr((name2))) if kwargs.get('show_nid', True): lbl1_list.append(vh.get_nidstrs(nid1)) lbl2_list.append(vh.get_nidstrs(nid2)) lbl1 = ' : '.join(lbl1_list) lbl2 = ' : '.join(lbl2_list) else: lbl1, lbl2 = None, None if vh.NO_LBL_OVERRIDE: title = '' if not notitle: pt.set_title(title, ax) # Plot annotations over images if in_image: bbox1, bbox2 = vh.get_bboxes(ibs, [aid1, aid2], [offset1, offset2]) theta1, theta2 = ibs.get_annot_thetas([aid1, aid2]) # HACK! if show_query: pt.draw_bbox(bbox1, bbox_color=pt.ORANGE, lbl=lbl1, theta=theta1) bbox_color2 = truth_color if draw_border else pt.ORANGE pt.draw_bbox(bbox2, bbox_color=bbox_color2, lbl=lbl2, theta=theta2) else: xy, w, h = pt.get_axis_xy_width_height(ax) bbox2 = (xy[0], xy[1], w, h) theta2 = 0 if xywh2 is None: #xywh2 = (xy[0], xy[1], w, h) # weird when sidebyside is off y seems to be inverted xywh2 = (0, 0, w, h) if not show_query and xywh1 is None: data_config2 = (None if qreq_ is None else qreq_.extern_data_config2) # FIXME, pass data in kpts2 = ibs.get_annot_kpts([aid2], config2_=data_config2)[0] #pt.draw_kpts2(kpts2.take(fm.T[1], axis=0)) # Draw any selected matches #sm_kw = dict(rect=True, colors=pt.BLUE) pt.plot_fmatch(None, xywh2, None, kpts2, fm, fs=fs, **kwargs) if draw_border: pt.draw_border(ax, truth_color, 4, offset=offset2) if draw_lbl: # Custom user lbl for chips 1 and 2 if show_query: (x1, y1, w1, h1) = xywh1 pt.absolute_lbl(x1 + w1, y1, lbl1) (x2, y2, w2, h2) = xywh2 pt.absolute_lbl(x2 + w2, y2, lbl2) if True: # No matches draw a red box if fm is None or len(fm) == 0: if draw_border: pass