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
