def dump_match_img(qres, ibs, aid, qreq_=None, fnum=None, *args, **kwargs):
import plottool as pt
import matplotlib as mpl
# Pop save kwargs from kwargs
save_keys = ['dpi', 'figsize', 'saveax', 'fpath', 'fpath_strict', 'verbose']
save_vals = ut.dict_take_pop(kwargs, save_keys, None)
savekw = dict(zip(save_keys, save_vals))
fpath = savekw.pop('fpath')
if fpath is None and 'fpath_strict' not in savekw:
savekw['usetitle'] = True
was_interactive = mpl.is_interactive()
if was_interactive:
mpl.interactive(False)
# Make new figure
if fnum is None:
fnum = pt.next_fnum()
#fig = pt.figure(fnum=fnum, doclf=True, docla=True)
fig = pt.plt.figure(fnum)
fig.clf()
# Draw Matches
ax, xywh1, xywh2 = qres.show_matches(ibs, aid, colorbar_=False, qreq_=qreq_, fnum=fnum, **kwargs)
if not kwargs.get('notitle', False):
pt.set_figtitle(qres.make_smaller_title())
# Save Figure
# Setting fig=fig might make the dpi and figsize code not work
img_fpath = pt.save_figure(fpath=fpath, fig=fig, **savekw)
if was_interactive:
mpl.interactive(was_interactive)
pt.plt.close(fig) # Ensure that this figure will not pop up
#if False:
# ut.startfile(img_fpath)
return img_fpath
def show_power_law_plots():
"""
CommandLine:
python -m ibeis.algo.hots.devcases --test-show_power_law_plots --show
Example:
>>> # DISABLE_DOCTEST
>>> #%pylab qt4
>>> from ibeis.all_imports import * # NOQA
>>> from ibeis.algo.hots.devcases import * # NOQA
>>> show_power_law_plots()
>>> pt.show_if_requested()
"""
import numpy as np
import plottool as pt
xdata = np.linspace(0, 1, 1000)
ydata = xdata
fnum = 1
powers = [.01, .1, .5, 1, 2, 30, 70, 100, 1000]
nRows, nCols = pt.get_square_row_cols(len(powers), fix=True)
pnum_next = pt.make_pnum_nextgen(nRows, nCols)
for p in powers:
plotkw = dict(
fnum=fnum,
marker='g-',
linewidth=2,
pnum=pnum_next(),
title='p=%r' % (p,)
)
ydata_ = ydata ** p
pt.plot2(xdata, ydata_, **plotkw)
pt.set_figtitle('power laws y = x ** p')
def plot(self, fnum=None, pnum=(1, 1, 1), **kwargs):
import plottool as pt
fnum = pt.ensure_fnum(fnum)
pt.figure(fnum=fnum, docla=True, doclf=True)
show_keypoints(self.chip, self.kpts, fnum=fnum, pnum=pnum, **kwargs)
if self.figtitle is not None:
pt.set_figtitle(self.figtitle)
def show_power_law_plots():
"""
CommandLine:
python -m ibeis.algo.hots.devcases --test-show_power_law_plots --show
Example:
>>> # DISABLE_DOCTEST
>>> #%pylab qt4
>>> from ibeis.all_imports import * # NOQA
>>> from ibeis.algo.hots.devcases import * # NOQA
>>> show_power_law_plots()
>>> pt.show_if_requested()
"""
import numpy as np
import plottool as pt
xdata = np.linspace(0, 1, 1000)
ydata = xdata
fnum = 1
powers = [.01, .1, .5, 1, 2, 30, 70, 100, 1000]
nRows, nCols = pt.get_square_row_cols(len(powers), fix=True)
pnum_next = pt.make_pnum_nextgen(nRows, nCols)
for p in powers:
plotkw = dict(fnum=fnum,
marker='g-',
linewidth=2,
pnum=pnum_next(),
title='p=%r' % (p, ))
ydata_ = ydata**p
pt.plot2(xdata, ydata_, **plotkw)
pt.set_figtitle('power laws y = x ** p')
def show_single_coverage_mask(qreq_, cm, weight_mask_m, weight_mask, daids, fnum=None):
import plottool as pt
from ibeis import viz
fnum = pt.ensure_fnum(fnum)
idx_list = ut.dict_take(cm.daid2_idx, daids)
nPlots = len(idx_list) + 1
nRows, nCols = pt.get_square_row_cols(nPlots)
pnum_ = pt.make_pnum_nextgen(nRows, nCols)
pt.figure(fnum=fnum, pnum=(1, 2, 1))
# Draw coverage masks with bbox
# <FlipHack>
#weight_mask_m = np.fliplr(np.flipud(weight_mask_m))
#weight_mask = np.fliplr(np.flipud(weight_mask))
# </FlipHack>
stacked_weights, offset_tup, sf_tup = vt.stack_images(weight_mask_m, weight_mask, return_sf=True)
(woff, hoff) = offset_tup[1]
wh1 = weight_mask_m.shape[0:2][::-1]
wh2 = weight_mask.shape[0:2][::-1]
pt.imshow(255 * (stacked_weights), fnum=fnum, pnum=pnum_(0), title='(query image) What did match vs what should match')
pt.draw_bbox(( 0, 0) + wh1, bbox_color=(0, 0, 1))
pt.draw_bbox((woff, hoff) + wh2, bbox_color=(0, 0, 1))
# Get contributing matches
qaid = cm.qaid
daid_list = daids
fm_list = ut.take(cm.fm_list, idx_list)
fs_list = ut.take(cm.fs_list, idx_list)
# Draw matches
for px, (daid, fm, fs) in enumerate(zip(daid_list, fm_list, fs_list), start=1):
viz.viz_matches.show_matches2(qreq_.ibs, qaid, daid, fm, fs,
draw_pts=False, draw_lines=True,
draw_ell=False, fnum=fnum, pnum=pnum_(px),
darken=.5)
coverage_score = score_matching_mask(weight_mask_m, weight_mask)
pt.set_figtitle('score=%.4f' % (coverage_score,))
def dump_match_img(qres, ibs, aid, qreq_=None, fnum=None, *args, **kwargs):
import plottool as pt
import matplotlib as mpl
# Pop save kwargs from kwargs
save_keys = ['dpi', 'figsize', 'saveax', 'fpath', 'fpath_strict', 'verbose']
save_vals = ut.dict_take_pop(kwargs, save_keys, None)
savekw = dict(zip(save_keys, save_vals))
fpath = savekw.pop('fpath')
if fpath is None and 'fpath_strict' not in savekw:
savekw['usetitle'] = True
was_interactive = mpl.is_interactive()
if was_interactive:
mpl.interactive(False)
# Make new figure
if fnum is None:
fnum = pt.next_fnum()
#fig = pt.figure(fnum=fnum, doclf=True, docla=True)
fig = pt.plt.figure(fnum)
fig.clf()
# Draw Matches
ax, xywh1, xywh2 = qres.show_matches(ibs, aid, colorbar_=False, qreq_=qreq_, fnum=fnum, **kwargs)
if not kwargs.get('notitle', False):
pt.set_figtitle(qres.make_smaller_title())
# Save Figure
# Setting fig=fig might make the dpi and figsize code not work
img_fpath = pt.save_figure(fpath=fpath, fig=fig, **savekw)
if was_interactive:
mpl.interactive(was_interactive)
pt.plt.close(fig) # Ensure that this figure will not pop up
#if False:
# ut.startfile(img_fpath)
return img_fpath
def plot(self, fnum=None, pnum=(1, 1, 1), **kwargs):
import plottool as pt
fnum = pt.ensure_fnum(fnum)
pt.figure(fnum=fnum, docla=True, doclf=True)
show_keypoints(self.chip, self.kpts, fnum=fnum, pnum=pnum, **kwargs)
if self.figtitle is not None:
pt.set_figtitle(self.figtitle)
def draw_junction_tree(model, fnum=None, **kwargs):
import plottool 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.node)
e = fixtupkeys(netx_graph.edge)
a = fixtupkeys(netx_graph.adj)
netx_graph.node = n
netx_graph.edge = e
netx_graph.adj = a
#netx_graph = model.to_markov_model()
#pos = netx.pygraphviz_layout(netx_graph)
#pos = netx.graphviz_layout(netx_graph)
pos = netx.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)
netx.draw(netx_graph, **drawkw)
if kwargs.get('show_title', True):
pt.set_figtitle('Junction / Clique Tree / Cluster Graph')
def show_hist_submaxima(hist_, edges=None, centers=None, maxima_thresh=.8, pnum=(1, 1, 1)):
r"""
For C++ to show data
Args:
hist_ (?):
edges (None):
centers (None):
CommandLine:
python -m vtool.histogram --test-show_hist_submaxima --show
python -m pyhesaff._pyhesaff --test-test_rot_invar --show
python -m vtool.histogram --test-show_hist_submaxima --dpath figures --save ~/latex/crall-candidacy-2015/figures/show_hist_submaxima.jpg
Example:
>>> # DISABLE_DOCTEST
>>> import plottool as pt
>>> from vtool.histogram import * # NOQA
>>> # build test data
>>> hist_ = np.array(list(map(float, ut.get_argval('--hist', type_=list, default=[1, 4, 2, 5, 3, 3]))))
>>> edges = np.array(list(map(float, ut.get_argval('--edges', type_=list, default=[0, 1, 2, 3, 4, 5, 6]))))
>>> maxima_thresh = ut.get_argval('--maxima_thresh', type_=float, default=.8)
>>> centers = None
>>> # execute function
>>> show_hist_submaxima(hist_, edges, centers, maxima_thresh)
>>> pt.show_if_requested()
"""
#print(repr(hist_))
#print(repr(hist_.shape))
#print(repr(edges))
#print(repr(edges.shape))
#ut.embed()
import plottool as pt
#ut.embed()
if centers is None:
centers = hist_edges_to_centers(edges)
bin_colors = pt.get_orientation_color(centers)
pt.figure(fnum=pt.next_fnum(), pnum=pnum)
POLAR = False
if POLAR:
pt.df2.plt.subplot(*pnum, polar=True, axisbg='#000000')
pt.draw_hist_subbin_maxima(hist_, centers, bin_colors=bin_colors, maxima_thresh=maxima_thresh)
#pt.gca().set_rmax(hist_.max() * 1.1)
#pt.gca().invert_yaxis()
#pt.gca().invert_xaxis()
pt.dark_background()
#if ut.get_argflag('--legend'):
# pt.figure(fnum=pt.next_fnum())
# centers_ = np.append(centers, centers[0])
# r = np.ones(centers_.shape) * .2
# ax = pt.df2.plt.subplot(111, polar=True)
# pt.plots.colorline(centers_, r, cmap=pt.df2.plt.get_cmap('hsv'), linewidth=10)
# #ax.plot(centers_, r, 'm', color=bin_colors, linewidth=100)
# ax.set_rmax(.2)
# #ax.grid(True)
# #ax.set_title("Angle Colors", va='bottom')
title = ut.get_argval('--title', default='')
import plottool as pt
pt.set_figtitle(title)
def draw_tree_model(model, **kwargs):
import plottool 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 _chip_view(mode=0, pnum=(1, 1, 1), **kwargs):
print('... _chip_view mode=%r' % mode_ptr[0])
kwargs['ell'] = mode_ptr[0] == 1
kwargs['pts'] = mode_ptr[0] == 2
if not ischild:
pt.figure(fnum=fnum, pnum=pnum, docla=True, doclf=True)
# Toggle no keypoints view
viz.show_chip(ibs, aid, fnum=fnum, pnum=pnum, config2_=config2_,
**kwargs)
pt.set_figtitle('Chip View')
def show_single_coverage_mask(qreq_,
cm,
weight_mask_m,
weight_mask,
daids,
fnum=None):
import plottool as pt
from ibeis import viz
fnum = pt.ensure_fnum(fnum)
idx_list = ut.dict_take(cm.daid2_idx, daids)
nPlots = len(idx_list) + 1
nRows, nCols = pt.get_square_row_cols(nPlots)
pnum_ = pt.make_pnum_nextgen(nRows, nCols)
pt.figure(fnum=fnum, pnum=(1, 2, 1))
# Draw coverage masks with bbox
# <FlipHack>
#weight_mask_m = np.fliplr(np.flipud(weight_mask_m))
#weight_mask = np.fliplr(np.flipud(weight_mask))
# </FlipHack>
stacked_weights, offset_tup, sf_tup = vt.stack_images(weight_mask_m,
weight_mask,
return_sf=True)
(woff, hoff) = offset_tup[1]
wh1 = weight_mask_m.shape[0:2][::-1]
wh2 = weight_mask.shape[0:2][::-1]
pt.imshow(255 * (stacked_weights),
fnum=fnum,
pnum=pnum_(0),
title='(query image) What did match vs what should match')
pt.draw_bbox((0, 0) + wh1, bbox_color=(0, 0, 1))
pt.draw_bbox((woff, hoff) + wh2, bbox_color=(0, 0, 1))
# Get contributing matches
qaid = cm.qaid
daid_list = daids
fm_list = ut.take(cm.fm_list, idx_list)
fs_list = ut.take(cm.fs_list, idx_list)
# Draw matches
for px, (daid, fm, fs) in enumerate(zip(daid_list, fm_list, fs_list),
start=1):
viz.viz_matches.show_matches2(qreq_.ibs,
qaid,
daid,
fm,
fs,
draw_pts=False,
draw_lines=True,
draw_ell=False,
fnum=fnum,
pnum=pnum_(px),
darken=.5)
coverage_score = score_matching_mask(weight_mask_m, weight_mask)
pt.set_figtitle('score=%.4f' % (coverage_score, ))
def chipmatch_view(self, fnum=None, pnum=(1, 1, 1), verbose=None, **kwargs_):
"""
just visualizes the matches using some type of lines
CommandLine:
python -m ibeis.viz.interact.interact_matches --test-chipmatch_view --show
Example:
>>> # DISABLE_DOCTEST
>>> from ibeis.viz.interact.interact_matches import * # NOQA
>>> self = testdata_match_interact()
>>> self.chipmatch_view()
>>> pt.show_if_requested()
"""
if fnum is None:
fnum = self.fnum
if verbose is None:
verbose = ut.VERBOSE
ibs = self.ibs
aid = self.daid
qaid = self.qaid
figtitle = self.figtitle
# drawing mode draw: with/without lines/feats
mode = kwargs_.get('mode', self.mode)
draw_ell = mode >= 1
draw_lines = mode == 2
#self.mode = (self.mode + 1) % 3
pt.figure(fnum=fnum, docla=True, doclf=True)
show_matches_kw = self.kwargs.copy()
show_matches_kw.update(
dict(fnum=fnum, pnum=pnum, draw_lines=draw_lines,
draw_ell=draw_ell, colorbar_=True, vert=self.vert))
show_matches_kw.update(kwargs_)
if self.warp_homog:
show_matches_kw['H1'] = self.H1
#show_matches_kw['score'] = self.score
show_matches_kw['rawscore'] = self.score
show_matches_kw['aid2_raw_rank'] = self.rank
tup = viz.viz_matches.show_matches2(ibs, self.qaid, self.daid,
self.fm, self.fs,
qreq_=self.qreq_,
**show_matches_kw)
ax, xywh1, xywh2 = tup
self.xywh2 = xywh2
pt.set_figtitle(figtitle + ' ' + vh.get_vsstr(qaid, aid))
def draw_tree_model(model, **kwargs):
import plottool 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'], '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.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()
}
n = fixtupkeys(netx_graph.node)
e = fixtupkeys(netx_graph.edge)
a = fixtupkeys(netx_graph.adj)
netx_graph.node = n
netx_graph.edge = e
netx_graph.adj = a
#netx_graph = model.to_markov_model()
#pos = netx.pygraphviz_layout(netx_graph)
#pos = netx.graphviz_layout(netx_graph)
pos = netx.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 show_hud(self):
""" Creates heads up display """
# Button positioners
hl_slot, hr_slot = pt.make_bbox_positioners(y=.02, w=.16,
h=3 * ut.PHI_B ** 4,
xpad=.05, startx=0, stopx=1)
select_none_text = 'None of these'
if self.suggest_aids is not None and len(self.suggest_aids) == 0:
select_none_text += '\n(SUGGESTED BY IBEIS)'
none_tup = self.append_button(select_none_text, callback=partial(self.select_none), rect=hl_slot(0))
#Draw boarder around the None of these button
none_button_axis = none_tup[1]
if self.other_checkbox_states['none']:
pt.draw_border(none_button_axis, color=(0, 1, 0), lw=4, adjust=False)
else:
pt.draw_border(none_button_axis, color=(.7, .7, .7), lw=4, adjust=False)
select_junk_text = 'Junk Query Image'
junk_tup = self.append_button(select_junk_text, callback=partial(self.select_junk), rect=hl_slot(1))
#Draw boarder around the None of these button
junk_button_axis = junk_tup[1]
if self.other_checkbox_states['junk']:
pt.draw_border(junk_button_axis, color=(0, 1, 0), lw=4, adjust=False)
else:
pt.draw_border(junk_button_axis, color=(.7, .7, .7), lw=4, adjust=False)
#Add other HUD buttons
self.append_button('Quit', callback=partial(self.quit), rect=hr_slot(0))
self.append_button('Confirm Selection', callback=partial(self.confirm), rect=hr_slot(1))
if self.progress_current is not None and self.progress_total is not None:
self.progress_string = str(self.progress_current) + '/' + str(self.progress_total)
else:
self.progress_string = ''
figtitle_fmt = '''
Animal Identification {progress_string}
'''
figtitle = figtitle_fmt.format(**self.__dict__) # sexy: using obj dict as fmtkw
pt.set_figtitle(figtitle)
def draw_junction_tree(model, fnum=None, **kwargs):
import plottool 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.node)
e = fixtupkeys(netx_graph.edge)
a = fixtupkeys(netx_graph.adj)
netx_graph.node = 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_model(model, evidence={}, soft_evidence={}, **kwargs):
"""
References:
http://stackoverflow.com/questions/22207802/pygraphviz-networkx-set-node-level-or-layer
Ignore:
pkg-config --libs-only-L libcgraph
sudo apt-get install libgraphviz-dev -y
sudo apt-get install libgraphviz4 -y
# sudo apt-get install pkg-config
sudo apt-get install libgraphviz-dev
# pip install git+git://github.com/pygraphviz/pygraphviz.git
pip install pygraphviz
python -c "import pygraphviz; print(pygraphviz.__file__)"
sudo pip3 install pygraphviz --install-option="--include-path=/usr/include/graphviz" --install-option="--library-path=/usr/lib/graphviz/"
python3 -c "import pygraphviz; print(pygraphviz.__file__)"
CommandLine:
python -m ibeis.algo.hots.bayes --exec-show_model --show
Example:
>>> # DISABLE_DOCTEST
>>> from ibeis.algo.hots.bayes import * # NOQA
>>> model = '?'
>>> evidence = {}
>>> soft_evidence = {}
>>> result = show_model(model, evidence, soft_evidence)
>>> print(result)
>>> ut.quit_if_noshow()
>>> import plottool as pt
>>> ut.show_if_requested()
"""
if ut.get_argval('--hackmarkov') or ut.get_argval('--hackjunc'):
draw_tree_model(model, **kwargs)
return
import plottool as pt
import networkx as netx
fnum = pt.ensure_fnum(None)
netx_graph = (model)
#netx_graph.graph.setdefault('graph', {})['size'] = '"10,5"'
#netx_graph.graph.setdefault('graph', {})['rankdir'] = 'LR'
pos_dict = get_hacked_pos(netx_graph)
#pos_dict = netx.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 draw_markov_model(model, fnum=None, **kwargs):
import plottool 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 = netx.pydot_layout(markovmodel)
pos = netx.pygraphviz_layout(markovmodel)
# Referenecs:
# https://groups.google.com/forum/#!topic/networkx-discuss/FwYk0ixLDuY
# pos = netx.spring_layout(markovmodel)
# pos = netx.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.node[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.node[u]['patch']
n2 = G.node[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
# netx.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 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 as pt
import networkx as netx
factor_list = kwargs.get('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_infered = evidence or 'factor_list' in kwargs
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)
netx.draw(model, **drawkw)
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_infered:
# 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_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 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 show_hist_submaxima(hist_,
edges=None,
centers=None,
maxima_thresh=.8,
pnum=(1, 1, 1)):
r"""
For C++ to show data
Args:
hist_ (?):
edges (None):
centers (None):
CommandLine:
python -m vtool.histogram --test-show_hist_submaxima --show
python -m pyhesaff._pyhesaff --test-test_rot_invar --show
python -m vtool.histogram --test-show_hist_submaxima --dpath figures --save ~/latex/crall-candidacy-2015/figures/show_hist_submaxima.jpg
Example:
>>> # DISABLE_DOCTEST
>>> import plottool as pt
>>> from vtool.histogram import * # NOQA
>>> # build test data
>>> hist_ = np.array(list(map(float, ut.get_argval('--hist', type_=list, default=[1, 4, 2, 5, 3, 3]))))
>>> edges = np.array(list(map(float, ut.get_argval('--edges', type_=list, default=[0, 1, 2, 3, 4, 5, 6]))))
>>> maxima_thresh = ut.get_argval('--maxima_thresh', type_=float, default=.8)
>>> centers = None
>>> # execute function
>>> show_hist_submaxima(hist_, edges, centers, maxima_thresh)
>>> pt.show_if_requested()
"""
#print(repr(hist_))
#print(repr(hist_.shape))
#print(repr(edges))
#print(repr(edges.shape))
#ut.embed()
import plottool as pt
#ut.embed()
if centers is None:
centers = hist_edges_to_centers(edges)
bin_colors = pt.get_orientation_color(centers)
pt.figure(fnum=pt.next_fnum(), pnum=pnum)
POLAR = False
if POLAR:
pt.df2.plt.subplot(*pnum, polar=True, axisbg='#000000')
pt.draw_hist_subbin_maxima(hist_,
centers,
bin_colors=bin_colors,
maxima_thresh=maxima_thresh)
#pt.gca().set_rmax(hist_.max() * 1.1)
#pt.gca().invert_yaxis()
#pt.gca().invert_xaxis()
pt.dark_background()
#if ut.get_argflag('--legend'):
# pt.figure(fnum=pt.next_fnum())
# centers_ = np.append(centers, centers[0])
# r = np.ones(centers_.shape) * .2
# ax = pt.df2.plt.subplot(111, polar=True)
# pt.plots.colorline(centers_, r, cmap=pt.df2.plt.get_cmap('hsv'), linewidth=10)
# #ax.plot(centers_, r, 'm', color=bin_colors, linewidth=100)
# ax.set_rmax(.2)
# #ax.grid(True)
# #ax.set_title("Angle Colors", va='bottom')
title = ut.get_argval('--title', default='')
import plottool as pt
pt.set_figtitle(title)
def show_hud(self):
""" Creates heads up display
button bar on bottom and title string
Example:
>>> # DISABLE_DOCTEST
>>> from ibeis.viz.interact.interact_name import * # NOQA
>>> # build test data
>>> self = testsdata_match_verification('PZ_MTEST', 30, 32)
>>> # execute function
>>> result = self.show_hud()
>>> # verify results
>>> print(result)
>>> ut.quit_if_noshow():
>>> self.show_page()
>>> pt.show_if_requested()
"""
# Button positioners
hl_slot, hr_slot = pt.make_bbox_positioners(y=.02,
w=.15,
h=.063,
xpad=.02,
startx=0,
stopx=1)
# hack make a second bbox positioner to get different sized buttons on #
# the left
hl_slot2, hr_slot2 = pt.make_bbox_positioners(y=.02,
w=.08,
h=.05,
xpad=.015,
startx=0,
stopx=1)
def next_rect(accum=[-1]):
accum[0] += 1
return hr_slot(accum[0])
def next_rect2(accum=[-1]):
accum[0] += 1
return hl_slot2(accum[0])
ibs = self.ibs
name1, name2 = self.name1, self.name2
nid1_is_known = not ibs.is_nid_unknown(self.nid1)
nid2_is_known = not ibs.is_nid_unknown(self.nid2)
all_nid_list = ibs.get_annot_name_rowids(self.all_aid_list)
is_unknown = ibs.is_nid_unknown(all_nid_list)
is_name1 = [nid == self.nid1 for nid in all_nid_list]
is_name2 = [nid == self.nid2 for nid in all_nid_list]
# option to remove all names only if at least one name exists
if not all(is_unknown):
unname_all_text = 'remove all names'
self.append_button(unname_all_text,
callback=self.unname_all,
rect=next_rect())
# option to merge all into a new name if all are unknown
if all(is_unknown) and not nid1_is_known and not nid2_is_known:
joinnew_text = 'match all (nonjunk)\n to a new name'
self.append_button(joinnew_text,
callback=self.merge_nonjunk_into_new_name,
rect=next_rect())
# option dismiss all and give new names to all nonjunk images
if any(is_unknown):
self.append_button('mark all unknowns\nas not matching',
callback=self.dismiss_all,
rect=next_rect())
# merges all into the first name
if nid1_is_known and not all(is_name1):
join1_text = 'match all to name1:\n{name1}'.format(name1=name1)
callback = functools.partial(self.merge_all_into_nid, self.nid1)
self.append_button(join1_text, callback=callback, rect=next_rect())
# merges all into the seoncd name
if name1 != name2 and nid2_is_known and not all(is_name2):
join2_text = 'match all to name2:\n{name2}'.format(name2=name2)
callback = functools.partial(self.merge_all_into_nid, self.nid2)
self.append_button(join2_text, callback=callback, rect=next_rect())
###
self.append_button('close', callback=self.close_, rect=next_rect2())
if self.qres_callback is not None:
self.append_button('review',
callback=self.review,
rect=next_rect2())
self.append_button('reset',
callback=self.reset_all_names,
rect=next_rect2())
self.dbname = ibs.get_dbname()
self.vsstr = 'qaid%d-vs-aid%d' % (self.aid1, self.aid2)
figtitle_fmt = '''
Match Review Interface - {dbname}
{match_text}:
{vsstr}
'''
figtitle = figtitle_fmt.format(
**self.__dict__) # sexy: using obj dict as fmtkw
pt.set_figtitle(figtitle)
def test_score_normalization():
"""
CommandLine:
python ibeis/algo/hots/score_normalization.py --test-test_score_normalization
python dev.py -t custom --cfg codename:vsone_unnorm --db PZ_MTEST --allgt --vf --va
python dev.py -t custom --cfg codename:vsone_unnorm --db PZ_MTEST --allgt --vf --va --index 0:8:3 --dindex 0:10 --verbose
Example:
>>> # DISABLE_DOCTEST
>>> #from ibeis.algo.hots import score_normalization
>>> #score_normalization.rrr()
>>> from ibeis.algo.hots.score_normalization import * # NOQA
>>> locals_ = test_score_normalization()
>>> execstr = ut.execstr_dict(locals_)
>>> #print(execstr)
>>> exec(execstr)
>>> import plottool as pt
>>> exec(pt.present())
"""
import ibeis
import plottool as pt # NOQA
# Load IBEIS database
dbname = 'PZ_MTEST'
#dbname = 'GZ_ALL'
ibs = ibeis.opendb(dbname)
qaid_list = daid_list = ibs.get_valid_aids()
# Get unnormalized query results
#cfgdict = dict(codename='nsum_unnorm')
cfgdict = dict(codename='vsone_unnorm')
cm_list = ibs.query_chips(qaid_list, daid_list, cfgdict, return_cm=True)
# Get a training sample
datatup = get_ibeis_score_training_data(ibs, cm_list)
(tp_support, tn_support, tp_support_labels, tn_support_labels) = datatup
# Print raw score statistics
ut.print_stats(tp_support, lbl='tp_support')
ut.print_stats(tn_support, lbl='tn_support')
normkw_list = ut.util_dict.all_dict_combinations(
{
'monotonize': [True], # [True, False],
#'adjust': [1, 4, 8],
'adjust': [4, 8],
#'adjust': [8],
}
)
if len(normkw_list) > 32:
raise AssertionError('Too many plots to test!')
fnum = pt.next_fnum()
true_color = pt.TRUE_BLUE # pt.TRUE_GREEN
false_color = pt.FALSE_RED
unknown_color = pt.UNKNOWN_PURP
pt.plots.plot_sorted_scores(
(tn_support, tp_support),
('true negative scores', 'true positive scores'),
score_colors=(false_color, true_color),
#logscale=True,
logscale=False,
figtitle='sorted nscores',
fnum=fnum)
for normkw in normkw_list:
# Learn the appropriate normalization
#normkw = {} # dict(gridsize=1024, adjust=8, clip_factor=ut.PHI + 1, return_all=True)
(score_domain, p_tp_given_score, p_tn_given_score, p_score_given_tp, p_score_given_tn,
p_score, clip_score) = learn_score_normalization(tp_support, tn_support, return_all=True, **normkw)
assert clip_score > tn_support.max()
inspect_pdfs(tn_support, tp_support, score_domain,
p_tp_given_score, p_tn_given_score, p_score_given_tp, p_score_given_tn, p_score)
pt.set_figtitle('ScoreNorm ' + ibs.get_dbname() + ' ' + ut.dict_str(normkw))
locals_ = locals()
return locals_
def show_ori_image_ondisk():
r"""
Args:
img (ndarray[uint8_t, ndim=2]): image data
ori (?):
gmag (?):
CommandLine:
python -m vtool.histogram --test-show_ori_image_ondisk --show
python -m vtool.histogram --test-show_ori_image_ondisk --show --patch_img_fpath patches/KP_0_PATCH.png --ori_img_fpath patches/KP_0_orientations01.png --weights_img_fpath patches/KP_0_WEIGHTS.png --grady_img_fpath patches/KP_0_ygradient.png --gradx_img_fpath patches/KP_0_xgradient.png --title cpp_show_ori_ondisk
python -m pyhesaff._pyhesaff --test-test_rot_invar --show --rebuild-hesaff --no-rmbuild
Example:
>>> # DISABLE_DOCTEST
>>> from vtool.histogram import * # NOQA
>>> import plottool as pt
>>> import vtool as vt
>>> result = show_ori_image_ondisk()
>>> pt.show_if_requested()
"""
#if img_fpath is not None:
# img_fpath = ut.get_argval('--fpath', type_=str, default=ut.grab_test_imgpath('star.png'))
# img_fpath = ut.get_argval('--fpath', type_=str, default=ut.grab_test_imgpath('star.png'))
# img = vt.imread(img_fpath)
# ori_img_fpath = ut.get_argval('--fpath-ori', type_=str,
# default=ut.augpath(img_fpath, '_ori'))
# weights_img_fpath = ut.get_argval('--fpath-weight', type_=str,
# default=ut.augpath(img_fpath, '_mag'))
# vt.imwrite(ori_img_fpath, vt.patch_ori(*vt.patch_gradient(img)))
# vt.imwrite(weights_img_fpath, vt.patch_mag(*vt.patch_gradient(img)))
import vtool as vt
print('show_ori_image_ondisk')
def parse_img_from_arg(argstr_):
fpath = ut.get_argval(argstr_, type_=str, default='None')
if fpath is not None and fpath != 'None':
img = vt.imread(fpath, grayscale=True)
print('Reading %s with stats %s' %
(fpath, ut.get_stats_str(img, axis=None)))
else:
print('Did not read %s' % (fpath))
img = None
return img
patch = parse_img_from_arg('--patch_img_fpath')
gori = parse_img_from_arg('--ori_img_fpath') / 255.0 * TAU
weights = parse_img_from_arg('--weights_img_fpath') / 255.0
gradx = parse_img_from_arg('--gradx_img_fpath') / 255.0
grady = parse_img_from_arg('--grady_img_fpath') / 255.0
gauss = parse_img_from_arg('--gauss_weights_img_fpath') / 255.0
#print(' * ori_img_fpath = %r' % (ori_img_fpath,))
#print(' * weights_img_fpath = %r' % (weights_img_fpath,))
#print(' * gradx_img_fpath = %r' % (gradx_img_fpath,))
#print(' * grady_img_fpath = %r' % (grady_img_fpath,))
#import cv2
#cv2.imread(ori_img_fpath, cv2.IMREAD_UNCHANGED)
show_ori_image(gori, weights, patch, gradx, grady, gauss)
title = ut.get_argval('--title', default='')
import plottool as pt
pt.set_figtitle(title)
def show_hud(self):
""" Creates heads up display """
# Button positioners
hl_slot, hr_slot = pt.make_bbox_positioners(y=.02,
w=.16,
h=3 * ut.PHI_B**4,
xpad=.05,
startx=0,
stopx=1)
select_none_text = 'None of these'
if self.suggest_aids is not None and len(self.suggest_aids) == 0:
select_none_text += '\n(SUGGESTED BY IBEIS)'
none_tup = self.append_button(select_none_text,
callback=partial(self.select_none),
rect=hl_slot(0))
#Draw boarder around the None of these button
none_button_axis = none_tup[1]
if self.other_checkbox_states['none']:
pt.draw_border(none_button_axis,
color=(0, 1, 0),
lw=4,
adjust=False)
else:
pt.draw_border(none_button_axis,
color=(.7, .7, .7),
lw=4,
adjust=False)
select_junk_text = 'Junk Query Image'
junk_tup = self.append_button(select_junk_text,
callback=partial(self.select_junk),
rect=hl_slot(1))
#Draw boarder around the None of these button
junk_button_axis = junk_tup[1]
if self.other_checkbox_states['junk']:
pt.draw_border(junk_button_axis,
color=(0, 1, 0),
lw=4,
adjust=False)
else:
pt.draw_border(junk_button_axis,
color=(.7, .7, .7),
lw=4,
adjust=False)
#Add other HUD buttons
self.append_button('Quit',
callback=partial(self.quit),
rect=hr_slot(0))
self.append_button('Confirm Selection',
callback=partial(self.confirm),
rect=hr_slot(1))
if self.progress_current is not None and self.progress_total is not None:
self.progress_string = str(self.progress_current) + '/' + str(
self.progress_total)
else:
self.progress_string = ''
figtitle_fmt = '''
Animal Identification {progress_string}
'''
figtitle = figtitle_fmt.format(
**self.__dict__) # sexy: using obj dict as fmtkw
pt.set_figtitle(figtitle)
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 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_infered = 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, 'style', {edge: 'invis' for edge in invis_edges})
nx.set_node_attributes(graph, 'groupid', {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_infered:
# 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_hud(self):
""" Creates heads up display
button bar on bottom and title string
Example:
>>> # DISABLE_DOCTEST
>>> from ibeis.viz.interact.interact_name import * # NOQA
>>> # build test data
>>> self = testsdata_match_verification('PZ_MTEST', 30, 32)
>>> # execute function
>>> result = self.show_hud()
>>> # verify results
>>> print(result)
>>> ut.quit_if_noshow():
>>> self.show_page()
>>> pt.show_if_requested()
"""
# Button positioners
hl_slot, hr_slot = pt.make_bbox_positioners(y=.02, w=.15, h=.063,
xpad=.02, startx=0, stopx=1)
# hack make a second bbox positioner to get different sized buttons on #
# the left
hl_slot2, hr_slot2 = pt.make_bbox_positioners(y=.02, w=.08, h=.05,
xpad=.015, startx=0, stopx=1)
def next_rect(accum=[-1]):
accum[0] += 1
return hr_slot(accum[0])
def next_rect2(accum=[-1]):
accum[0] += 1
return hl_slot2(accum[0])
ibs = self.ibs
name1, name2 = self.name1, self.name2
nid1_is_known = not ibs.is_nid_unknown(self.nid1)
nid2_is_known = not ibs.is_nid_unknown(self.nid2)
all_nid_list = ibs.get_annot_name_rowids(self.all_aid_list)
is_unknown = ibs.is_nid_unknown(all_nid_list)
is_name1 = [nid == self.nid1 for nid in all_nid_list]
is_name2 = [nid == self.nid2 for nid in all_nid_list]
# option to remove all names only if at least one name exists
if not all(is_unknown):
unname_all_text = 'remove all names'
self.append_button(unname_all_text, callback=self.unname_all, rect=next_rect())
# option to merge all into a new name if all are unknown
if all(is_unknown) and not nid1_is_known and not nid2_is_known:
joinnew_text = 'match all (nonjunk)\n to a new name'
self.append_button(joinnew_text, callback=self.merge_nonjunk_into_new_name, rect=next_rect())
# option dismiss all and give new names to all nonjunk images
if any(is_unknown):
self.append_button('mark all unknowns\nas not matching', callback=self.dismiss_all, rect=next_rect())
# merges all into the first name
if nid1_is_known and not all(is_name1):
join1_text = 'match all to name1:\n{name1}'.format(name1=name1)
callback = functools.partial(self.merge_all_into_nid, self.nid1)
self.append_button(join1_text, callback=callback, rect=next_rect())
# merges all into the seoncd name
if name1 != name2 and nid2_is_known and not all(is_name2):
join2_text = 'match all to name2:\n{name2}'.format(name2=name2)
callback = functools.partial(self.merge_all_into_nid, self.nid2)
self.append_button(join2_text, callback=callback, rect=next_rect())
###
self.append_button('close', callback=self.close_, rect=next_rect2())
if self.qres_callback is not None:
self.append_button('review', callback=self.review, rect=next_rect2())
self.append_button('reset', callback=self.reset_all_names, rect=next_rect2())
self.dbname = ibs.get_dbname()
self.vsstr = ibsfuncs.vsstr(self.aid1, self.aid2)
figtitle_fmt = '''
Match Review Interface - {dbname}
{match_text}:
{vsstr}
'''
figtitle = figtitle_fmt.format(**self.__dict__) # sexy: using obj dict as fmtkw
pt.set_figtitle(figtitle)
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 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_infered = 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, 'style',
{edge: 'invis'
for edge in invis_edges})
nx.set_node_attributes(
graph, 'groupid',
{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_infered:
# 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 augment_nnindexer_experiment():
"""
References:
http://answers.opencv.org/question/44592/flann-index-training-fails-with-segfault/
CommandLine:
utprof.py -m ibeis.algo.hots._neighbor_experiment --test-augment_nnindexer_experiment
python -m ibeis.algo.hots._neighbor_experiment --test-augment_nnindexer_experiment
python -m ibeis.algo.hots._neighbor_experiment --test-augment_nnindexer_experiment --db PZ_MTEST --diskshow --adjust=.1 --save "augment_experiment_{db}.png" --dpath='.' --dpi=180 --figsize=9,6
python -m ibeis.algo.hots._neighbor_experiment --test-augment_nnindexer_experiment --db PZ_Master0 --diskshow --adjust=.1 --save "augment_experiment_{db}.png" --dpath='.' --dpi=180 --figsize=9,6 --nosave-flann --show
python -m ibeis.algo.hots._neighbor_experiment --test-augment_nnindexer_experiment --db PZ_Master0 --diskshow --adjust=.1 --save "augment_experiment_{db}.png" --dpath='.' --dpi=180 --figsize=9,6 --nosave-flann --show
python -m ibeis.algo.hots._neighbor_experiment --test-augment_nnindexer_experiment --db PZ_Master0 --diskshow --adjust=.1 --save "augment_experiment_{db}.png" --dpath='.' --dpi=180 --figsize=9,6 --nosave-flann --no-api-cache --nocache-uuids
python -m ibeis.algo.hots._neighbor_experiment --test-augment_nnindexer_experiment --db PZ_MTEST --show
python -m ibeis.algo.hots._neighbor_experiment --test-augment_nnindexer_experiment --db PZ_Master0 --show
# RUNS THE SEGFAULTING CASE
python -m ibeis.algo.hots._neighbor_experiment --test-augment_nnindexer_experiment --db PZ_Master0 --show
# Debug it
gdb python
run -m ibeis.algo.hots._neighbor_experiment --test-augment_nnindexer_experiment --db PZ_Master0 --show
gdb python
run -m ibeis.algo.hots._neighbor_experiment --test-augment_nnindexer_experiment --db PZ_Master0 --diskshow --adjust=.1 --save "augment_experiment_{db}.png" --dpath='.' --dpi=180 --figsize=9,6
Example:
>>> # DISABLE_DOCTEST
>>> from ibeis.algo.hots._neighbor_experiment import * # NOQA
>>> # execute function
>>> augment_nnindexer_experiment()
>>> # verify results
>>> ut.show_if_requested()
"""
import ibeis
# build test data
#ibs = ibeis.opendb('PZ_MTEST')
ibs = ibeis.opendb(defaultdb='PZ_Master0')
if ibs.get_dbname() == 'PZ_MTEST':
initial = 1
addition_stride = 4
max_ceiling = 100
elif ibs.get_dbname() == 'PZ_Master0':
initial = 128
#addition_stride = 64
#addition_stride = 128
addition_stride = 256
max_ceiling = 10000
#max_ceiling = 4000
#max_ceiling = 2000
#max_ceiling = 600
else:
assert False
all_daids = ibs.get_valid_aids(species='zebra_plains')
qreq_ = ibs.new_query_request(all_daids, all_daids)
max_num = min(max_ceiling, len(all_daids))
# Clear Caches
ibs.delete_flann_cachedir()
neighbor_index_cache.clear_memcache()
neighbor_index_cache.clear_uuid_cache(qreq_)
# Setup
all_randomize_daids_ = ut.deterministic_shuffle(all_daids[:])
# ensure all features are computed
#ibs.get_annot_vecs(all_randomize_daids_, ensure=True)
#ibs.get_annot_fgweights(all_randomize_daids_, ensure=True)
nnindexer_list = []
addition_lbl = 'Addition'
_addition_iter = list(range(initial + 1, max_num, addition_stride))
addition_iter = iter(ut.ProgressIter(_addition_iter, lbl=addition_lbl,
freq=1, autoadjust=False))
time_list_addition = []
#time_list_reindex = []
addition_count_list = []
tmp_cfgstr_list = []
#for _ in range(80):
# next(addition_iter)
try:
memtrack = ut.MemoryTracker(disable=False)
for count in addition_iter:
aid_list_ = all_randomize_daids_[0:count]
# Request an indexer which could be an augmented version of an existing indexer.
with ut.Timer(verbose=False) as t:
memtrack.report('BEFORE AUGMENT')
nnindexer_ = neighbor_index_cache.request_augmented_ibeis_nnindexer(qreq_, aid_list_)
memtrack.report('AFTER AUGMENT')
nnindexer_list.append(nnindexer_)
addition_count_list.append(count)
time_list_addition.append(t.ellapsed)
tmp_cfgstr_list.append(nnindexer_.cfgstr)
print('===============\n\n')
print(ut.list_str(time_list_addition))
print(ut.list_str(list(map(id, nnindexer_list))))
print(ut.list_str(tmp_cfgstr_list))
print(ut.list_str(list([nnindxer.cfgstr for nnindxer in nnindexer_list])))
IS_SMALL = False
if IS_SMALL:
nnindexer_list = []
reindex_label = 'Reindex'
# go backwards for reindex
_reindex_iter = list(range(initial + 1, max_num, addition_stride))[::-1]
reindex_iter = ut.ProgressIter(_reindex_iter, lbl=reindex_label)
time_list_reindex = []
#time_list_reindex = []
reindex_count_list = []
for count in reindex_iter:
print('\n+===PREDONE====================\n')
# check only a single size for memory leaks
#count = max_num // 16 + ((x % 6) * 1)
#x += 1
aid_list_ = all_randomize_daids_[0:count]
# Call the same code, but force rebuilds
memtrack.report('BEFORE REINDEX')
with ut.Timer(verbose=False) as t:
nnindexer_ = neighbor_index_cache.request_augmented_ibeis_nnindexer(
qreq_, aid_list_, force_rebuild=True, memtrack=memtrack)
memtrack.report('AFTER REINDEX')
ibs.print_cachestats_str()
print('[nnindex.MEMCACHE] size(NEIGHBOR_CACHE) = %s' % (
ut.get_object_size_str(neighbor_index_cache.NEIGHBOR_CACHE.items()),))
print('[nnindex.MEMCACHE] len(NEIGHBOR_CACHE) = %s' % (
len(neighbor_index_cache.NEIGHBOR_CACHE.items()),))
print('[nnindex.MEMCACHE] size(UUID_MAP_CACHE) = %s' % (
ut.get_object_size_str(neighbor_index_cache.UUID_MAP_CACHE),))
print('totalsize(nnindexer) = ' + ut.get_object_size_str(nnindexer_))
memtrack.report_type(neighbor_index_cache.NeighborIndex)
ut.print_object_size_tree(nnindexer_, lbl='nnindexer_')
if IS_SMALL:
nnindexer_list.append(nnindexer_)
reindex_count_list.append(count)
time_list_reindex.append(t.ellapsed)
#import cv2
#import matplotlib as mpl
#print(mem_top.mem_top(limit=30, width=120,
# #exclude_refs=[cv2.__dict__, mpl.__dict__]
# ))
print('L___________________\n\n\n')
print(ut.list_str(time_list_reindex))
if IS_SMALL:
print(ut.list_str(list(map(id, nnindexer_list))))
print(ut.list_str(list([nnindxer.cfgstr for nnindxer in nnindexer_list])))
except KeyboardInterrupt:
print('\n[train] Caught CRTL+C')
resolution = ''
from six.moves import input
while not (resolution.isdigit()):
print('\n[train] What do you want to do?')
print('[train] 0 - Continue')
print('[train] 1 - Embed')
print('[train] ELSE - Stop network training')
resolution = input('[train] Resolution: ')
resolution = int(resolution)
# We have a resolution
if resolution == 0:
print('resuming training...')
elif resolution == 1:
ut.embed()
import plottool as pt
next_fnum = iter(range(0, 1)).next # python3 PY3
pt.figure(fnum=next_fnum())
if len(addition_count_list) > 0:
pt.plot2(addition_count_list, time_list_addition, marker='-o', equal_aspect=False,
x_label='num_annotations', label=addition_lbl + ' Time')
if len(reindex_count_list) > 0:
pt.plot2(reindex_count_list, time_list_reindex, marker='-o', equal_aspect=False,
x_label='num_annotations', label=reindex_label + ' Time')
pt.set_figtitle('Augmented indexer experiment')
pt.legend()
def test_siamese_performance(model, data, labels, flat_metadata, dataname=''):
r"""
CommandLine:
utprof.py -m ibeis_cnn --tf pz_patchmatch --db liberty --test --weights=liberty:current --arch=siaml2_128 --test
python -m ibeis_cnn --tf netrun --db liberty --arch=siaml2_128 --test --ensure
python -m ibeis_cnn --tf netrun --db liberty --arch=siaml2_128 --test --ensure --weights=new
python -m ibeis_cnn --tf netrun --db liberty --arch=siaml2_128 --train --weights=new
python -m ibeis_cnn --tf netrun --db pzmtest --weights=liberty:current --arch=siaml2_128 --test # NOQA
python -m ibeis_cnn --tf netrun --db pzmtest --weights=liberty:current --arch=siaml2_128
"""
import vtool as vt
import plottool as pt
# TODO: save in model.trainind_dpath/diagnostics/figures
ut.colorprint('\n[siam_perf] Testing Siamese Performance', 'white')
#epoch_dpath = model.get_epoch_diagnostic_dpath()
epoch_dpath = model.arch_dpath
ut.vd(epoch_dpath)
dataname += ' ' + model.get_history_hashid() + '\n'
history_text = ut.list_str(model.era_history, newlines=True)
ut.write_to(ut.unixjoin(epoch_dpath, 'era_history.txt'), history_text)
#if True:
# import matplotlib as mpl
# mpl.rcParams['agg.path.chunksize'] = 100000
#data = data[::50]
#labels = labels[::50]
#from ibeis_cnn import utils
#data, labels = utils.random_xy_sample(data, labels, 10000, model.data_per_label_input)
FULL = not ut.get_argflag('--quick')
fnum_gen = pt.make_fnum_nextgen()
ut.colorprint('[siam_perf] Show era history', 'white')
fig = model.show_era_loss(fnum=fnum_gen())
pt.save_figure(fig=fig, dpath=epoch_dpath, dpi=180)
# hack
ut.colorprint('[siam_perf] Show weights image', 'white')
fig = model.show_weights_image(fnum=fnum_gen())
pt.save_figure(fig=fig, dpath=epoch_dpath, dpi=180)
#model.draw_all_conv_layer_weights(fnum=fnum_gen())
#model.imwrite_weights(1)
#model.imwrite_weights(2)
# Compute each type of score
ut.colorprint('[siam_perf] Building Scores', 'white')
test_outputs = model.predict2(model, data)
network_output = test_outputs['network_output_determ']
# hack converting network output to distances for non-descriptor networks
if len(network_output.shape) == 2 and network_output.shape[1] == 1:
cnn_scores = network_output.T[0]
elif len(network_output.shape) == 1:
cnn_scores = network_output
elif len(network_output.shape) == 2 and network_output.shape[1] > 1:
assert model.data_per_label_output == 2
vecs1 = network_output[0::2]
vecs2 = network_output[1::2]
cnn_scores = vt.L2(vecs1, vecs2)
else:
assert False
cnn_scores = cnn_scores.astype(np.float64)
# Segfaults with the data passed in is large (AND MEMMAPPED apparently)
# Fixed in hesaff implementation
SIFT = FULL
if SIFT:
sift_scores, sift_list = test_sift_patchmatch_scores(data, labels)
sift_scores = sift_scores.astype(np.float64)
ut.colorprint('[siam_perf] Learning Encoders', 'white')
# Learn encoders
encoder_kw = {
#'monotonize': False,
'monotonize': True,
}
cnn_encoder = vt.ScoreNormalizer(**encoder_kw)
cnn_encoder.fit(cnn_scores, labels)
if SIFT:
sift_encoder = vt.ScoreNormalizer(**encoder_kw)
sift_encoder.fit(sift_scores, labels)
# Visualize
ut.colorprint('[siam_perf] Visualize Encoders', 'white')
viz_kw = dict(
with_scores=False,
with_postbayes=False,
with_prebayes=False,
target_tpr=.95,
)
inter_cnn = cnn_encoder.visualize(
figtitle=dataname + ' CNN scores. #data=' + str(len(data)),
fnum=fnum_gen(), **viz_kw)
if SIFT:
inter_sift = sift_encoder.visualize(
figtitle=dataname + ' SIFT scores. #data=' + str(len(data)),
fnum=fnum_gen(), **viz_kw)
# Save
pt.save_figure(fig=inter_cnn.fig, dpath=epoch_dpath)
if SIFT:
pt.save_figure(fig=inter_sift.fig, dpath=epoch_dpath)
# Save out examples of hard errors
#cnn_fp_label_indicies, cnn_fn_label_indicies =
#cnn_encoder.get_error_indicies(cnn_scores, labels)
#sift_fp_label_indicies, sift_fn_label_indicies =
#sift_encoder.get_error_indicies(sift_scores, labels)
with_patch_examples = FULL
if with_patch_examples:
ut.colorprint('[siam_perf] Visualize Confusion Examples', 'white')
cnn_indicies = cnn_encoder.get_confusion_indicies(cnn_scores, labels)
if SIFT:
sift_indicies = sift_encoder.get_confusion_indicies(sift_scores, labels)
warped_patch1_list, warped_patch2_list = list(zip(*ut.ichunks(data, 2)))
samp_args = (warped_patch1_list, warped_patch2_list, labels)
_sample = functools.partial(draw_results.get_patch_sample_img, *samp_args)
cnn_fp_img = _sample({'fs': cnn_scores}, cnn_indicies.fp)[0]
cnn_fn_img = _sample({'fs': cnn_scores}, cnn_indicies.fn)[0]
cnn_tp_img = _sample({'fs': cnn_scores}, cnn_indicies.tp)[0]
cnn_tn_img = _sample({'fs': cnn_scores}, cnn_indicies.tn)[0]
if SIFT:
sift_fp_img = _sample({'fs': sift_scores}, sift_indicies.fp)[0]
sift_fn_img = _sample({'fs': sift_scores}, sift_indicies.fn)[0]
sift_tp_img = _sample({'fs': sift_scores}, sift_indicies.tp)[0]
sift_tn_img = _sample({'fs': sift_scores}, sift_indicies.tn)[0]
#if ut.show_was_requested():
#def rectify(arr):
# return np.flipud(arr)
SINGLE_FIG = False
if SINGLE_FIG:
def dump_img(img_, lbl, fnum):
fig, ax = pt.imshow(img_, figtitle=dataname + ' ' + lbl, fnum=fnum)
pt.save_figure(fig=fig, dpath=epoch_dpath, dpi=180)
dump_img(cnn_fp_img, 'cnn_fp_img', fnum_gen())
dump_img(cnn_fn_img, 'cnn_fn_img', fnum_gen())
dump_img(cnn_tp_img, 'cnn_tp_img', fnum_gen())
dump_img(cnn_tn_img, 'cnn_tn_img', fnum_gen())
dump_img(sift_fp_img, 'sift_fp_img', fnum_gen())
dump_img(sift_fn_img, 'sift_fn_img', fnum_gen())
dump_img(sift_tp_img, 'sift_tp_img', fnum_gen())
dump_img(sift_tn_img, 'sift_tn_img', fnum_gen())
#vt.imwrite(dataname + '_' + 'cnn_fp_img.png', (cnn_fp_img))
#vt.imwrite(dataname + '_' + 'cnn_fn_img.png', (cnn_fn_img))
#vt.imwrite(dataname + '_' + 'sift_fp_img.png', (sift_fp_img))
#vt.imwrite(dataname + '_' + 'sift_fn_img.png', (sift_fn_img))
else:
print('Drawing TP FP TN FN')
fnum = fnum_gen()
pnum_gen = pt.make_pnum_nextgen(4, 2)
fig = pt.figure(fnum)
pt.imshow(cnn_fp_img, title='CNN FP', fnum=fnum, pnum=pnum_gen())
pt.imshow(sift_fp_img, title='SIFT FP', fnum=fnum, pnum=pnum_gen())
pt.imshow(cnn_fn_img, title='CNN FN', fnum=fnum, pnum=pnum_gen())
pt.imshow(sift_fn_img, title='SIFT FN', fnum=fnum, pnum=pnum_gen())
pt.imshow(cnn_tp_img, title='CNN TP', fnum=fnum, pnum=pnum_gen())
pt.imshow(sift_tp_img, title='SIFT TP', fnum=fnum, pnum=pnum_gen())
pt.imshow(cnn_tn_img, title='CNN TN', fnum=fnum, pnum=pnum_gen())
pt.imshow(sift_tn_img, title='SIFT TN', fnum=fnum, pnum=pnum_gen())
pt.set_figtitle(dataname + ' confusions')
pt.adjust_subplots(left=0, right=1.0, bottom=0., wspace=.01, hspace=.05)
pt.save_figure(fig=fig, dpath=epoch_dpath, dpi=180, figsize=(9, 18))
with_patch_desc = FULL
if with_patch_desc:
ut.colorprint('[siam_perf] Visualize Patch Descriptors', 'white')
fnum = fnum_gen()
fig = pt.figure(fnum=fnum, pnum=(1, 1, 1))
num_rows = 7
pnum_gen = pt.make_pnum_nextgen(num_rows, 3)
# Compare actual output descriptors
for index in ut.random_indexes(len(sift_list), num_rows):
vec_sift = sift_list[index]
vec_cnn = network_output[index]
patch = data[index]
pt.imshow(patch, fnum=fnum, pnum=pnum_gen())
pt.plot_descriptor_signature(vec_cnn, 'cnn vec', fnum=fnum, pnum=pnum_gen())
pt.plot_sift_signature(vec_sift, 'sift vec', fnum=fnum, pnum=pnum_gen())
pt.set_figtitle('Patch Descriptors')
pt.adjust_subplots(left=0, right=0.95, bottom=0., wspace=.1, hspace=.15)
pt.save_figure(fig=fig, dpath=epoch_dpath, dpi=180, figsize=(9, 18))
def myquery():
r"""
BUG::
THERE IS A BUG SOMEWHERE: HOW IS THIS POSSIBLE?
if everything is weightd ) how di the true positive even get a score
while the true negative did not
qres_copy.filtkey_list = ['ratio', 'fg', 'homogerr', 'distinctiveness']
CORRECT STATS
{
'max' : [0.832, 0.968, 0.604, 0.000],
'min' : [0.376, 0.524, 0.000, 0.000],
'mean' : [0.561, 0.924, 0.217, 0.000],
'std' : [0.114, 0.072, 0.205, 0.000],
'nMin' : [1, 1, 1, 51],
'nMax' : [1, 1, 1, 1],
'shape': (52, 4),
}
INCORRECT STATS
{
'max' : [0.759, 0.963, 0.264, 0.000],
'min' : [0.379, 0.823, 0.000, 0.000],
'mean' : [0.506, 0.915, 0.056, 0.000],
'std' : [0.125, 0.039, 0.078, 0.000],
'nMin' : [1, 1, 1, 24],
'nMax' : [1, 1, 1, 1],
'shape': (26, 4),
# score_diff, tp_score, tn_score, p, K, dcvs_clip_max, fg_power, homogerr_power
0.494, 0.494, 0.000, 73.000, 2, 0.500, 0.100, 10.000
see how seperability changes as we very things
CommandLine:
python -m ibeis.algo.hots.devcases --test-myquery
python -m ibeis.algo.hots.devcases --test-myquery --show --index 0
python -m ibeis.algo.hots.devcases --test-myquery --show --index 1
python -m ibeis.algo.hots.devcases --test-myquery --show --index 2
References:
http://en.wikipedia.org/wiki/Pareto_distribution <- look into
Example:
>>> # DISABLE_DOCTEST
>>> from ibeis.all_imports import * # NOQA
>>> from ibeis.algo.hots.devcases import * # NOQA
>>> ut.dev_ipython_copypaster(myquery) if ut.inIPython() else myquery()
>>> pt.show_if_requested()
"""
from ibeis.algo.hots import special_query # NOQA
from ibeis.algo.hots import distinctiveness_normalizer # NOQA
from ibeis import viz # NOQA
import plottool as pt
index = ut.get_argval('--index', int, 0)
ibs, aid1, aid2, tn_aid = testdata_my_exmaples(index)
qaids = [aid1]
daids = [aid2] + [tn_aid]
qvuuid = ibs.get_annot_visual_uuids(aid1)
cfgdict_vsone = dict(
sv_on=True,
#sv_on=False,
#codename='vsone_unnorm_dist_ratio_extern_distinctiveness',
codename='vsone_unnorm_ratio_extern_distinctiveness',
sver_output_weighting=True,
)
use_cache = False
save_qcache = False
qres_list, qreq_ = ibs.query_chips(qaids,
daids,
cfgdict=cfgdict_vsone,
return_request=True,
use_cache=use_cache,
save_qcache=save_qcache,
verbose=True)
qreq_.load_distinctiveness_normalizer()
qres = qres_list[0]
top_aids = qres.get_top_aids() # NOQA
qres_orig = qres # NOQA
def test_config(qreq_, qres_orig, cfgdict):
""" function to grid search over """
qres_copy = copy.deepcopy(qres_orig)
qreq_vsone_ = qreq_
qres_vsone = qres_copy
filtkey = hstypes.FiltKeys.DISTINCTIVENESS
newfsv_list, newscore_aids = special_query.get_extern_distinctiveness(
qreq_, qres_copy, **cfgdict)
special_query.apply_new_qres_filter_scores(qreq_vsone_, qres_vsone,
newfsv_list, newscore_aids,
filtkey)
tp_score = qres_copy.aid2_score[aid2]
tn_score = qres_copy.aid2_score[tn_aid]
return qres_copy, tp_score, tn_score
#[.01, .1, .2, .5, .6, .7, .8, .9, 1.0]),
#FiltKeys = hstypes.FiltKeys
# FIXME: Use other way of doing gridsearch
grid_basis = distinctiveness_normalizer.DCVS_DEFAULT.get_grid_basis()
gridsearch = ut.GridSearch(grid_basis, label='qvuuid=%r' % (qvuuid, ))
print('Begin Grid Search')
for cfgdict in ut.ProgressIter(gridsearch, lbl='GridSearch'):
qres_copy, tp_score, tn_score = test_config(qreq_, qres_orig, cfgdict)
gridsearch.append_result(tp_score, tn_score)
print('Finish Grid Search')
# Get best result
best_cfgdict = gridsearch.get_rank_cfgdict()
qres_copy, tp_score, tn_score = test_config(qreq_, qres_orig, best_cfgdict)
# Examine closely what you can do with scores
if False:
qres_copy = copy.deepcopy(qres_orig)
qreq_vsone_ = qreq_
filtkey = hstypes.FiltKeys.DISTINCTIVENESS
newfsv_list, newscore_aids = special_query.get_extern_distinctiveness(
qreq_, qres_copy, **cfgdict)
ut.embed()
def make_cm_very_old_tuple(qres_copy):
assert ut.listfind(qres_copy.filtkey_list, filtkey) is None
weight_filters = hstypes.WEIGHT_FILTERS
weight_filtxs, nonweight_filtxs = special_query.index_partition(
qres_copy.filtkey_list, weight_filters)
aid2_fsv = {}
aid2_fs = {}
aid2_score = {}
for new_fsv_vsone, daid in zip(newfsv_list, newscore_aids):
pass
break
#scorex_vsone = ut.listfind(qres_copy.filtkey_list, filtkey)
#if scorex_vsone is None:
# TODO: add spatial verification as a filter score
# augment the vsone scores
# TODO: paramaterize
weighted_ave_score = True
if weighted_ave_score:
# weighted average scoring
new_fs_vsone = special_query.weighted_average_scoring(
new_fsv_vsone, weight_filtxs, nonweight_filtxs)
else:
# product scoring
new_fs_vsone = special_query.product_scoring(new_fsv_vsone)
new_score_vsone = new_fs_vsone.sum()
aid2_fsv[daid] = new_fsv_vsone
aid2_fs[daid] = new_fs_vsone
aid2_score[daid] = new_score_vsone
return aid2_fsv, aid2_fs, aid2_score
# Look at plot of query products
for new_fsv_vsone, daid in zip(newfsv_list, newscore_aids):
new_fs_vsone = special_query.product_scoring(new_fsv_vsone)
scores_list = np.array(new_fs_vsone)[:, None].T
pt.plot_sorted_scores(scores_list,
logscale=False,
figtitle=str(daid))
pt.iup()
special_query.apply_new_qres_filter_scores(qreq_vsone_, qres_copy,
newfsv_list, newscore_aids,
filtkey)
# PRINT INFO
import functools
#ut.rrrr()
get_stats_str = functools.partial(ut.get_stats_str,
axis=0,
newlines=True,
precision=3)
tp_stats_str = ut.align(get_stats_str(qres_copy.aid2_fsv[aid2]), ':')
tn_stats_str = ut.align(get_stats_str(qres_copy.aid2_fsv[tn_aid]), ':')
info_str_list = []
info_str_list.append('qres_copy.filtkey_list = %r' %
(qres_copy.filtkey_list, ))
info_str_list.append('CORRECT STATS')
info_str_list.append(tp_stats_str)
info_str_list.append('INCORRECT STATS')
info_str_list.append(tn_stats_str)
info_str = '\n'.join(info_str_list)
print(info_str)
# SHOW BEST RESULT
#qres_copy.ishow_top(ibs, fnum=pt.next_fnum())
#qres_orig.ishow_top(ibs, fnum=pt.next_fnum())
# Text Informatio
param_lbl = 'dcvs_power'
param_stats_str = gridsearch.get_dimension_stats_str(param_lbl)
print(param_stats_str)
csvtext = gridsearch.get_csv_results(10)
print(csvtext)
# Paramter visuzliation
fnum = pt.next_fnum()
# plot paramter influence
param_label_list = gridsearch.get_param_lbls()
pnum_ = pt.get_pnum_func(2, len(param_label_list))
for px, param_label in enumerate(param_label_list):
gridsearch.plot_dimension(param_label, fnum=fnum, pnum=pnum_(px))
# plot match figure
pnum2_ = pt.get_pnum_func(2, 2)
qres_copy.show_matches(ibs, aid2, fnum=fnum, pnum=pnum2_(2))
qres_copy.show_matches(ibs, tn_aid, fnum=fnum, pnum=pnum2_(3))
# Add figure labels
figtitle = 'Effect of parameters on vsone separation for a single case'
subtitle = 'qvuuid = %r' % (qvuuid)
figtitle += '\n' + subtitle
pt.set_figtitle(figtitle)
# Save Figure
#fig_fpath = pt.save_figure(usetitle=True)
#print(fig_fpath)
# Write CSV Results
#csv_fpath = fig_fpath + '.csv.txt'
#ut.write_to(csv_fpath, csvtext)
#qres_copy.ishow_top(ibs)
#from matplotlib import pyplot as plt
#plt.show()
#print(ut.list_str()))
# TODO: plot max variation dims
#import plottool as pt
#pt.plot(p_list, diff_list)
"""
def compare_featscores():
"""
CommandLine:
ibeis --tf compare_featscores --db PZ_MTEST \
--nfscfg :disttype=[L2_sift,lnbnn],top_percent=[None,.5,.1] -a timectrl \
-p default:K=[1,2],normalizer_rule=name \
--save featscore{db}.png --figsize=13,20 --diskshow
ibeis --tf compare_featscores --db PZ_MTEST \
--nfscfg :disttype=[L2_sift,normdist,lnbnn],top_percent=[None,.5] -a timectrl \
-p default:K=[1],normalizer_rule=name,sv_on=[True,False] \
--save featscore{db}.png --figsize=13,10 --diskshow
ibeis --tf compare_featscores --nfscfg :disttype=[L2_sift,normdist,lnbnn] \
-a timectrl -p default:K=1,normalizer_rule=name --db PZ_Master1 \
--save featscore{db}.png --figsize=13,13 --diskshow
ibeis --tf compare_featscores --nfscfg :disttype=[L2_sift,normdist,lnbnn] \
-a timectrl -p default:K=1,normalizer_rule=name --db GZ_ALL \
--save featscore{db}.png --figsize=13,13 --diskshow
ibeis --tf compare_featscores --db GIRM_Master1 \
--nfscfg ':disttype=fg,L2_sift,normdist,lnbnn' \
-a timectrl -p default:K=1,normalizer_rule=name \
--save featscore{db}.png --figsize=13,13
ibeis --tf compare_featscores --nfscfg :disttype=[L2_sift,normdist,lnbnn] \
-a timectrl -p default:K=[1,2,3],normalizer_rule=name,sv_on=False \
--db PZ_Master1 --save featscore{db}.png \
--dpi=128 --figsize=15,20 --diskshow
ibeis --tf compare_featscores --show --nfscfg :disttype=[L2_sift,normdist] -a timectrl -p :K=1 --db PZ_MTEST
ibeis --tf compare_featscores --show --nfscfg :disttype=[L2_sift,normdist] -a timectrl -p :K=1 --db GZ_ALL
ibeis --tf compare_featscores --show --nfscfg :disttype=[L2_sift,normdist] -a timectrl -p :K=1 --db PZ_Master1
ibeis --tf compare_featscores --show --nfscfg :disttype=[L2_sift,normdist] -a timectrl -p :K=1 --db GIRM_Master1
ibeis --tf compare_featscores --db PZ_MTEST \
--nfscfg :disttype=[L2_sift,normdist,lnbnn],top_percent=[None,.5,.2] -a timectrl \
-p default:K=[1],normalizer_rule=name \
--save featscore{db}.png --figsize=13,20 --diskshow
ibeis --tf compare_featscores --db PZ_MTEST \
--nfscfg :disttype=[L2_sift,normdist,lnbnn],top_percent=[None,.5,.2] -a timectrl \
-p default:K=[1],normalizer_rule=name \
--save featscore{db}.png --figsize=13,20 --diskshow
Example:
>>> # DISABLE_DOCTEST
>>> from ibeis.algo.hots.scorenorm import * # NOQA
>>> result = compare_featscores()
>>> print(result)
>>> ut.quit_if_noshow()
>>> import plottool as pt
>>> ut.show_if_requested()
"""
import plottool as pt
import ibeis
nfs_cfg_list = NormFeatScoreConfig.from_argv_cfgs()
learnkw = {}
ibs, testres = ibeis.testdata_expts(
defaultdb='PZ_MTEST', a=['default'], p=['default:K=1'])
print('nfs_cfg_list = ' + ut.repr3(nfs_cfg_list))
encoder_list = []
lbl_list = []
varied_nfs_lbls = ut.get_varied_cfg_lbls(nfs_cfg_list)
varied_qreq_lbls = ut.get_varied_cfg_lbls(testres.cfgdict_list)
#varies_qreq_lbls
#func = ut.cached_func(cache_dir='.')(learn_featscore_normalizer)
for datakw, nlbl in zip(nfs_cfg_list, varied_nfs_lbls):
for qreq_, qlbl in zip(testres.cfgx2_qreq_, varied_qreq_lbls):
lbl = qlbl + ' ' + nlbl
cfgstr = '_'.join([datakw.get_cfgstr(), qreq_.get_full_cfgstr()])
try:
encoder = vt.ScoreNormalizer()
encoder.load(cfgstr=cfgstr)
except IOError:
print('datakw = %r' % (datakw,))
encoder = learn_featscore_normalizer(qreq_, datakw, learnkw)
encoder.save(cfgstr=cfgstr)
encoder_list.append(encoder)
lbl_list.append(lbl)
fnum = 1
# next_pnum = pt.make_pnum_nextgen(nRows=len(encoder_list), nCols=3)
next_pnum = pt.make_pnum_nextgen(nRows=len(encoder_list) + 1, nCols=3, start=3)
iconsize = 94
if len(encoder_list) > 3:
iconsize = 64
icon = qreq_.ibs.get_database_icon(max_dsize=(None, iconsize), aid=qreq_.qaids[0])
score_range = (0, .6)
for encoder, lbl in zip(encoder_list, lbl_list):
#encoder.visualize(figtitle=encoder.get_cfgstr(), with_prebayes=False, with_postbayes=False)
encoder._plot_score_support_hist(fnum, pnum=next_pnum(), titlesuf='\n' + lbl, score_range=score_range)
encoder._plot_prebayes(fnum, pnum=next_pnum())
encoder._plot_roc(fnum, pnum=next_pnum())
if icon is not None:
pt.overlay_icon(icon, coords=(1, 0), bbox_alignment=(1, 0))
nonvaried_lbl = ut.get_nonvaried_cfg_lbls(nfs_cfg_list)[0]
figtitle = qreq_.__str__() + '\n' + nonvaried_lbl
pt.set_figtitle(figtitle)
pt.adjust_subplots(hspace=.5, top=.92, bottom=.08, left=.1, right=.9)
pt.update_figsize()
pt.plt.tight_layout()
def test_rot_invar():
r"""
CommandLine:
python -m pyhesaff test_rot_invar --show --rebuild-hesaff --no-rmbuild
python -m pyhesaff test_rot_invar --show --nocpp
python -m vtool.tests.dummy testdata_ratio_matches --show --ratio_thresh=1.0 --rotation_invariance --rebuild-hesaff
python -m vtool.tests.dummy testdata_ratio_matches --show --ratio_thresh=1.1 --rotation_invariance --rebuild-hesaff
Example:
>>> # DISABLE_DODCTEST
>>> from pyhesaff._pyhesaff import * # NOQA
>>> test_rot_invar()
"""
import cv2
import vtool as vt
import plottool as pt
TAU = 2 * np.pi
fnum = pt.next_fnum()
NUM_PTS = 5 # 9
theta_list = np.linspace(0, TAU, NUM_PTS, endpoint=False)
nRows, nCols = pt.get_square_row_cols(len(theta_list), fix=True)
next_pnum = pt.make_pnum_nextgen(nRows, nCols)
# Expand the border a bit around star.png
pad_ = 100
img_fpath = grab_test_imgpath('star.png')
img_fpath2 = vt.pad_image_ondisk(img_fpath, pad_, value=26)
for theta in theta_list:
print('-----------------')
print('theta = %r' % (theta, ))
img_fpath = vt.rotate_image_ondisk(img_fpath2,
theta,
border_mode=cv2.BORDER_REPLICATE)
if not ub.argflag('--nocpp'):
(kpts_list_ri, vecs_list2) = detect_feats(img_fpath,
rotation_invariance=True)
kpts_ri = kpts_list_ri[0:2]
(kpts_list_gv, vecs_list1) = detect_feats(img_fpath,
rotation_invariance=False)
kpts_gv = kpts_list_gv[0:2]
# find_kpts_direction
imgBGR = vt.imread(img_fpath)
kpts_ripy = vt.find_kpts_direction(imgBGR,
kpts_gv,
DEBUG_ROTINVAR=False)
# Verify results stdout
#print('nkpts = %r' % (len(kpts_gv)))
#print(vt.kpts_repr(kpts_gv))
#print(vt.kpts_repr(kpts_ri))
#print(vt.kpts_repr(kpts_ripy))
# Verify results plot
pt.figure(fnum=fnum, pnum=next_pnum())
pt.imshow(imgBGR)
#if len(kpts_gv) > 0:
# pt.draw_kpts2(kpts_gv, ori=True, ell_color=pt.BLUE, ell_linewidth=10.5)
ell = False
rect = True
if not ub.argflag('--nocpp'):
if len(kpts_ri) > 0:
pt.draw_kpts2(kpts_ri,
rect=rect,
ell=ell,
ori=True,
ell_color=pt.RED,
ell_linewidth=5.5)
if len(kpts_ripy) > 0:
pt.draw_kpts2(kpts_ripy,
rect=rect,
ell=ell,
ori=True,
ell_color=pt.GREEN,
ell_linewidth=3.5)
pt.set_figtitle('green=python, red=C++')
pt.show_if_requested()
def show_model(model, evidence={}, soft_evidence={}, **kwargs):
"""
References:
http://stackoverflow.com/questions/22207802/pygraphviz-networkx-set-node-level-or-layer
Ignore:
pkg-config --libs-only-L libcgraph
sudo apt-get install libgraphviz-dev -y
sudo apt-get install libgraphviz4 -y
# sudo apt-get install pkg-config
sudo apt-get install libgraphviz-dev
# pip install git+git://github.com/pygraphviz/pygraphviz.git
pip install pygraphviz
python -c "import pygraphviz; print(pygraphviz.__file__)"
sudo pip3 install pygraphviz --install-option="--include-path=/usr/include/graphviz" --install-option="--library-path=/usr/lib/graphviz/"
python3 -c "import pygraphviz; print(pygraphviz.__file__)"
CommandLine:
python -m ibeis.algo.hots.bayes --exec-show_model --show
Example:
>>> # DISABLE_DOCTEST
>>> from ibeis.algo.hots.bayes import * # NOQA
>>> model = '?'
>>> evidence = {}
>>> soft_evidence = {}
>>> result = show_model(model, evidence, soft_evidence)
>>> print(result)
>>> ut.quit_if_noshow()
>>> import plottool as pt
>>> ut.show_if_requested()
"""
if ut.get_argval('--hackmarkov') or ut.get_argval('--hackjunc'):
draw_tree_model(model, **kwargs)
return
import plottool as pt
import networkx as netx
fnum = pt.ensure_fnum(None)
netx_graph = (model)
#netx_graph.graph.setdefault('graph', {})['size'] = '"10,5"'
#netx_graph.graph.setdefault('graph', {})['rankdir'] = 'LR'
pos_dict = get_hacked_pos(netx_graph)
#pos_dict = netx.pygraphviz_layout(netx_graph)
#pos = netx.pydot_layout(netx_graph, prog='dot')
#pos_dict = netx.graphviz_layout(netx_graph)
textprops = {
'family': 'monospace',
'horizontalalignment': 'left',
#'horizontalalignment': 'center',
#'size': 12,
'size': 8,
}
netx_nodes = model.nodes(data=True)
node_key_list = ut.get_list_column(netx_nodes, 0)
pos_list = ut.dict_take(pos_dict, node_key_list)
var2_post = {f.variables[0]: f for f in kwargs.get('factor_list', [])}
prior_text = None
post_text = None
evidence_tas = []
post_tas = []
prior_tas = []
node_color = []
has_infered = evidence or var2_post
if has_infered:
ignore_prior_with_ttype = ['score', 'match']
show_prior = False
else:
ignore_prior_with_ttype = []
#show_prior = True
show_prior = False
dpy = 5
dbx, dby = (20, 20)
takw1 = {'bbox_align': (.5, 0), 'pos_offset': [0, dpy], 'bbox_offset': [dbx, dby]}
takw2 = {'bbox_align': (.5, 1), 'pos_offset': [0, -dpy], 'bbox_offset': [-dbx, -dby]}
name_colors = pt.distinct_colors(max(model.num_names, 10))
name_colors = name_colors[:model.num_names]
#cmap_ = 'hot' #mx = 0.65 #mn = 0.15
cmap_, mn, mx = 'plasma', 0.15, 1.0
_cmap = pt.plt.get_cmap(cmap_)
def cmap(x):
return _cmap((x * mx) + mn)
for node, pos in zip(netx_nodes, pos_list):
variable = node[0]
cpd = model.var2_cpd[variable]
prior_marg = (cpd if cpd.evidence is None else
cpd.marginalize(cpd.evidence, inplace=False))
show_evidence = variable in evidence
show_prior = cpd.ttype not in ignore_prior_with_ttype
show_post = variable in var2_post
show_prior |= cpd.ttype not in ignore_prior_with_ttype
post_marg = None
if show_post:
post_marg = var2_post[variable]
def get_name_color(phi):
order = phi.values.argsort()[::-1]
if len(order) < 2:
dist_next = phi.values[order[0]]
else:
dist_next = phi.values[order[0]] - phi.values[order[1]]
dist_total = (phi.values[order[0]])
confidence = (dist_total * dist_next) ** (2.5 / 4)
#print('confidence = %r' % (confidence,))
color = name_colors[order[0]]
color = pt.color_funcs.desaturate_rgb(color, 1 - confidence)
color = np.array(color)
return color
if variable in evidence:
if cpd.ttype == 'score':
cmap_index = evidence[variable] / (cpd.variable_card - 1)
color = cmap(cmap_index)
color = pt.lighten_rgb(color, .4)
color = np.array(color)
node_color.append(color)
elif cpd.ttype == 'name':
color = name_colors[evidence[variable]]
color = np.array(color)
node_color.append(color)
else:
color = pt.FALSE_RED
node_color.append(color)
#elif variable in soft_evidence:
# color = pt.LIGHT_PINK
# show_prior = True
# color = get_name_color(prior_marg)
# node_color.append(color)
else:
if cpd.ttype == 'name' and post_marg is not None:
color = get_name_color(post_marg)
node_color.append(color)
elif cpd.ttype == 'match' and post_marg is not None:
color = cmap(post_marg.values[1])
color = pt.lighten_rgb(color, .4)
color = np.array(color)
node_color.append(color)
else:
#color = pt.WHITE
color = pt.NEUTRAL
node_color.append(color)
if show_prior:
if variable in soft_evidence:
prior_color = pt.LIGHT_PINK
else:
prior_color = None
prior_text = pgm_ext.make_factor_text(prior_marg, 'prior')
prior_tas.append(dict(text=prior_text, pos=pos, color=prior_color, **takw2))
if show_evidence:
_takw1 = takw1
if cpd.ttype == 'score':
_takw1 = takw2
evidence_text = cpd.variable_statenames[evidence[variable]]
if isinstance(evidence_text, int):
evidence_text = '%d/%d' % (evidence_text + 1, cpd.variable_card)
evidence_tas.append(dict(text=evidence_text, pos=pos, color=color, **_takw1))
if show_post:
_takw1 = takw1
if cpd.ttype == 'match':
_takw1 = takw2
post_text = pgm_ext.make_factor_text(post_marg, 'post')
post_tas.append(dict(text=post_text, pos=pos, color=None, **_takw1))
def trnps_(dict_list):
""" tranpose dict list """
list_dict = ut.ddict(list)
for dict_ in dict_list:
for key, val in dict_.items():
list_dict[key + '_list'].append(val)
return list_dict
takw1_ = trnps_(post_tas + evidence_tas)
takw2_ = trnps_(prior_tas)
# Draw graph
if has_infered:
pnum1 = (3, 1, (slice(0, 2), 0))
else:
pnum1 = None
fig = pt.figure(fnum=fnum, pnum=pnum1, doclf=True) # NOQA
ax = pt.gca()
#print('node_color = %s' % (ut.repr3(node_color),))
drawkw = dict(pos=pos_dict, ax=ax, with_labels=True, node_size=1500,
node_color=node_color)
netx.draw(netx_graph, **drawkw)
hacks = []
if len(post_tas + evidence_tas):
hacks.append(pt.draw_text_annotations(textprops=textprops, **takw1_))
if prior_tas:
hacks.append(pt.draw_text_annotations(textprops=textprops, **takw2_))
xmin, ymin = np.array(pos_list).min(axis=0)
xmax, ymax = np.array(pos_list).max(axis=0)
num_annots = len(model.ttype2_cpds['name'])
if num_annots > 4:
ax.set_xlim((xmin - 40, xmax + 40))
ax.set_ylim((ymin - 50, ymax + 50))
fig.set_size_inches(30, 7)
else:
ax.set_xlim((xmin - 42, xmax + 42))
ax.set_ylim((ymin - 50, ymax + 50))
fig.set_size_inches(23, 7)
fig = pt.gcf()
title = 'num_names=%r, num_annots=%r' % (model.num_names, num_annots,)
map_assign = kwargs.get('map_assign', None)
top_assignments = kwargs.get('top_assignments', None)
if top_assignments is not None:
map_assign, map_prob = top_assignments[0]
if map_assign is not None:
def word_insert(text):
return '' if len(text) == 0 else text + ' '
title += '\n%sMAP: ' % (word_insert(kwargs.get('method', '')))
title += map_assign + ' @' + '%.2f%%' % (100 * map_prob,)
if kwargs.get('show_title', True):
pt.set_figtitle(title, size=14)
for hack in hacks:
hack()
# Hack in colorbars
if has_infered:
pt.colorbar(np.linspace(0, 1, len(name_colors)), name_colors, lbl='name',
ticklabels=model.ttype2_template['name'].basis, ticklocation='left')
basis = model.ttype2_template['score'].basis
scalars = np.linspace(0, 1, len(basis))
scalars = np.linspace(0, 1, 100)
colors = pt.scores_to_color(scalars, cmap_=cmap_, reverse_cmap=False,
cmap_range=(mn, mx))
colors = [pt.lighten_rgb(c, .4) for c in colors]
if ut.list_type(basis) is int:
pt.colorbar(scalars, colors, lbl='score', ticklabels=np.array(basis) + 1)
else:
pt.colorbar(scalars, colors, lbl='score', ticklabels=basis)
#print('basis = %r' % (basis,))
# Draw probability hist
if has_infered and top_assignments is not None:
bin_labels = ut.get_list_column(top_assignments, 0)
bin_vals = ut.get_list_column(top_assignments, 1)
# bin_labels = ['\n'.join(ut.textwrap.wrap(_lbl, width=30)) for _lbl in bin_labels]
pt.draw_histogram(bin_labels, bin_vals, fnum=fnum, pnum=(3, 8, (2, slice(4, None))),
transpose=True,
use_darkbackground=False,
#xtick_rotation=-10,
ylabel='Prob', xlabel='assignment')
pt.set_title('Assignment probabilities')
def show_qres(ibs, cm, qreq_=None, **kwargs):
"""
Display Query Result Logic
Defaults to: query chip, groundtruth matches, and top matches
Args:
ibs (ibeis.IBEISController): ibeis controller object
cm (ibeis.ChipMatch): object of feature correspondences and scores
Kwargs:
in_image (bool) show result in image view if True else chip view
annot_mode (int):
if annot_mode == 0, then draw lines and ellipse
elif annot_mode == 1, then dont draw lines or ellipse
elif annot_mode == 2, then draw only lines
See: viz_matches.show_name_matches, viz_helpers.get_query_text
Returns:
mpl.Figure: fig
CommandLine:
./main.py --query 1 -y --db PZ_MTEST --noshow-qtres
python -m ibeis.viz.viz_qres --test-show_qres --show
python -m ibeis.viz.viz_qres --test-show_qres --show --top-aids=10 --db=PZ_MTEST --sidebyside --annot_mode=0 --notitle --no-viz_name_score --qaids=5 --max_nCols=2 --adjust=.01,.01,.01
python -m ibeis.viz.viz_qres --test-show_qres --show --top-aids=10 --db=PZ_MTEST --sidebyside --annot_mode=0 --notitle --no-viz_name_score --qaids=5 --max_nCols=2 --adjust=.01,.01,.01
Example:
>>> # DISABLE_DOCTEST
>>> from ibeis.viz.viz_qres import * # NOQA
>>> import plottool as pt
>>> ibs, cm, qreq_, kwargs = testdata_show_qres()
>>> # execute function
>>> fig = show_qres(ibs, cm, show_query=False, qreq_=qreq_, **kwargs)
>>> # verify results
>>> #fig.show()
>>> pt.show_if_requested()
"""
#ut.print_dict(kwargs)
annot_mode = kwargs.get('annot_mode', 1) % 3 # this is toggled
figtitle = kwargs.get('figtitle', '')
make_figtitle = kwargs.get('make_figtitle', False)
aug = kwargs.get('aug', '')
top_aids = kwargs.get('top_aids', DEFAULT_NTOP)
gt_aids = kwargs.get('gt_aids', [])
all_kpts = kwargs.get('all_kpts', False)
show_query = kwargs.get('show_query', False)
in_image = kwargs.get('in_image', False)
sidebyside = kwargs.get('sidebyside', True)
#name_scoring = kwargs.get('name_scoring', False)
viz_name_score = kwargs.get('viz_name_score', qreq_ is not None)
max_nCols = kwargs.get('max_nCols', None)
failed_to_match = kwargs.get('failed_to_match', False)
fnum = pt.ensure_fnum(kwargs.get('fnum', None))
if ut.VERBOSE and ut.NOT_QUIET:
print('query_info = ' + ut.obj_str(
ibs.get_annot_info(cm.qaid, default=True, gname=False, name=False, notes=False,
exemplar=False), nl=4))
print('top_aids_info = ' + ut.obj_str(
ibs.get_annot_info(top_aids, default=True, gname=False, name=False, notes=False,
exemplar=False, reference_aid=cm.qaid), nl=4))
if make_figtitle is True:
pass
#figtitle = cm.make_title(pack=True)
#figtitle
fig = pt.figure(fnum=fnum, docla=True, doclf=True)
if isinstance(top_aids, int):
#if isinstance(cm, chip_match.ChipMatch):
top_aids = cm.get_top_aids(top_aids)
#else:
# top_aids = cm.get_top_aids(num=top_aids, name_scoring=name_scoring, ibs=ibs)
if failed_to_match:
# HACK to visually indicate failure to match in analysis
top_aids = [None] + top_aids
nTop = len(top_aids)
if max_nCols is None:
max_nCols = 5
if nTop in [6, 7]:
max_nCols = 3
if nTop in [8]:
max_nCols = 4
try:
assert len(list(set(top_aids).intersection(set(gt_aids)))) == 0, (
'gts should be missed. not in top')
except AssertionError as ex:
ut.printex(ex, keys=['top_aids', 'gt_aids'])
raise
if ut.DEBUG2:
print(cm.get_inspect_str())
#--------------------------------------------------
# Get grid / cell information to build subplot grid
#--------------------------------------------------
# Show query or not
nQuerySubplts = 1 if show_query else 0
# The top row is given slots for ground truths and querys
# all aids in gt_aids should not be in top aids
nGtSubplts = nQuerySubplts + (0 if gt_aids is None else len(gt_aids))
# The bottom rows are for the top results
nTopNSubplts = nTop
nTopNCols = min(max_nCols, nTopNSubplts)
nGTCols = min(max_nCols, nGtSubplts)
nGTCols = max(nGTCols, nTopNCols)
nTopNCols = nGTCols
# Get number of rows to show groundtruth
nGtRows = 0 if nGTCols == 0 else int(np.ceil(nGtSubplts / nGTCols))
# Get number of rows to show results
nTopNRows = 0 if nTopNCols == 0 else int(np.ceil(nTopNSubplts / nTopNCols))
nGtCells = nGtRows * nGTCols
# Total number of rows
nRows = nTopNRows + nGtRows
DEBUG_SHOW_QRES = 0
if DEBUG_SHOW_QRES:
allgt_aids = ibs.get_annot_groundtruth(cm.qaid)
nSelGt = len(gt_aids)
nAllGt = len(allgt_aids)
print('[show_qres]========================')
print('[show_qres]----------------')
print('[show_qres] * annot_mode=%r' % (annot_mode,))
print('[show_qres] #nTop=%r #missed_gts=%r/%r' % (nTop, nSelGt, nAllGt))
print('[show_qres] * -----')
print('[show_qres] * nRows=%r' % (nRows,))
print('[show_qres] * nGtSubplts=%r' % (nGtSubplts,))
print('[show_qres] * nTopNSubplts=%r' % (nTopNSubplts,))
print('[show_qres] * nQuerySubplts=%r' % (nQuerySubplts,))
print('[show_qres] * -----')
print('[show_qres] * nGTCols=%r' % (nGTCols,))
print('[show_qres] * -----')
print('[show_qres] * fnum=%r' % (fnum,))
print('[show_qres] * figtitle=%r' % (figtitle,))
print('[show_qres] * max_nCols=%r' % (max_nCols,))
print('[show_qres] * show_query=%r' % (show_query,))
print('[show_qres] * kwargs=%s' % (ut.dict_str(kwargs),))
# HACK:
_color_list = pt.distinct_colors(nTop)
aid2_color = {aid: _color_list[ox] for ox, aid in enumerate(top_aids)}
ranked_aids = cm.get_top_aids()
# Helpers
def _show_query_fn(plotx_shift, rowcols):
""" helper for show_qres """
plotx = plotx_shift + 1
pnum = (rowcols[0], rowcols[1], plotx)
#print('[viz] Plotting Query: pnum=%r' % (pnum,))
_kwshow = dict(draw_kpts=annot_mode)
_kwshow.update(kwargs)
_kwshow['prefix'] = 'q'
_kwshow['pnum'] = pnum
_kwshow['aid2_color'] = aid2_color
_kwshow['draw_ell'] = annot_mode >= 1
viz_chip.show_chip(ibs, cm.qaid, annote=False, qreq_=qreq_, **_kwshow)
def _plot_matches_aids(aid_list, plotx_shift, rowcols):
""" helper for show_qres to draw many aids """
_kwshow = dict(draw_ell=annot_mode, draw_pts=False, draw_lines=annot_mode,
ell_alpha=.5, all_kpts=all_kpts)
_kwshow.update(kwargs)
_kwshow['fnum'] = fnum
_kwshow['in_image'] = in_image
if sidebyside:
# Draw each match side by side the query
_kwshow['draw_ell'] = annot_mode == 1
_kwshow['draw_lines'] = annot_mode >= 1
else:
#print('annot_mode = %r' % (annot_mode,))
_kwshow['draw_ell'] = annot_mode == 1
#_kwshow['draw_pts'] = annot_mode >= 1
#_kwshow['draw_lines'] = False
_kwshow['show_query'] = False
def _show_matches_fn(aid, orank, pnum):
""" Helper function for drawing matches to one aid """
aug = 'rank=%r\n' % orank
_kwshow['pnum'] = pnum
_kwshow['title_aug'] = aug
#draw_ell = annot_mode == 1
#draw_lines = annot_mode >= 1
# If we already are showing the query dont show it here
if sidebyside:
# Draw each match side by side the query
if viz_name_score:
cm.show_single_namematch(qreq_, ibs.get_annot_nids(aid), **_kwshow)
else:
_kwshow['draw_border'] = False
_kwshow['draw_lbl'] = False
_kwshow['notitle'] = True
_kwshow['vert'] = False
cm.show_single_annotmatch(qreq_, aid, **_kwshow)
#viz_matches.show_matches(ibs, cm, aid, qreq_=qreq_, **_kwshow)
else:
# Draw each match by themselves
data_config2_ = None if qreq_ is None else qreq_.get_external_data_config2()
#_kwshow['draw_border'] = kwargs.get('draw_border', True)
#_kwshow['notitle'] = ut.get_argflag(('--no-title', '--notitle'))
viz_chip.show_chip(ibs, aid, annote=False, notitle=True,
data_config2_=data_config2_, **_kwshow)
if DEBUG_SHOW_QRES:
print('[show_qres()] Plotting Chips %s:' % vh.get_aidstrs(aid_list))
if aid_list is None:
return
# Do lazy load before show
#data_config2_ = None if qreq_ is None else qreq_.get_external_data_config2()
tblhack = getattr(qreq_, 'tablename', None)
# HACK FOR HUMPBACKS
# (Also in viz_matches)
if tblhack == 'vsone' or (qreq_ is not None and not qreq_._isnewreq):
# precompute
pass
#ibs.get_annot_chips(aid_list, config2_=data_config2_, ensure=True)
#ibs.get_annot_kpts(aid_list, config2_=data_config2_, ensure=True)
for ox, aid in enumerate(aid_list):
plotx = ox + plotx_shift + 1
pnum = (rowcols[0], rowcols[1], plotx)
oranks = np.where(ranked_aids == aid)[0]
# This pair has no matches between them.
if len(oranks) == 0:
orank = -1
if aid is None:
pt.imshow_null('Failed to find matches\nfor qaid=%r' % (cm.qaid), fnum=fnum, pnum=pnum, fontsize=18)
else:
_show_matches_fn(aid, orank, pnum)
#if DEBUG_SHOW_QRES:
# print('skipping pnum=%r' % (pnum,))
continue
if DEBUG_SHOW_QRES:
print('pnum=%r' % (pnum,))
orank = oranks[0] + 1
_show_matches_fn(aid, orank, pnum)
shift_topN = nGtCells
if nGtSubplts == 1:
nGTCols = 1
if nRows == 0:
pt.imshow_null('[viz_qres] No matches. nRows=0', fnum=fnum)
else:
fig = pt.figure(fnum=fnum, pnum=(nRows, nGTCols, 1), docla=True, doclf=True)
pt.plt.subplot(nRows, nGTCols, 1)
# Plot Query
if show_query:
_show_query_fn(0, (nRows, nGTCols))
# Plot Ground Truth (if given)
_plot_matches_aids(gt_aids, nQuerySubplts, (nRows, nGTCols))
# Plot Results
_plot_matches_aids(top_aids, shift_topN, (nRows, nTopNCols))
figtitle += aug
if failed_to_match:
figtitle += '\n No matches found'
incanvas = kwargs.get('with_figtitle', not vh.NO_LBL_OVERRIDE)
pt.set_figtitle(figtitle, incanvas=incanvas)
# Result Interaction
return fig
def draw_markov_model(model, fnum=None, **kwargs):
import plottool 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.node[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.node[u]['patch']
n2 = G.node[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 show_qres(ibs, cm, qreq_=None, **kwargs):
"""
Display Query Result Logic
Defaults to: query chip, groundtruth matches, and top matches
Args:
ibs (ibeis.IBEISController): ibeis controller object
cm (ibeis.ChipMatch): object of feature correspondences and scores
Kwargs:
in_image (bool) show result in image view if True else chip view
annot_mode (int):
if annot_mode == 0, then draw lines and ellipse
elif annot_mode == 1, then dont draw lines or ellipse
elif annot_mode == 2, then draw only lines
See: viz_matches.show_name_matches, viz_helpers.get_query_text
Returns:
mpl.Figure: fig
CommandLine:
./main.py --query 1 -y --db PZ_MTEST --noshow-qtres
python -m ibeis.viz.viz_qres --test-show_qres --show
python -m ibeis.viz.viz_qres --test-show_qres --show --top-aids=10 --db=PZ_MTEST --sidebyside --annot_mode=0 --notitle --no-viz_name_score --qaids=5 --max_nCols=2 --adjust=.01,.01,.01
python -m ibeis.viz.viz_qres --test-show_qres --show --top-aids=10 --db=PZ_MTEST --sidebyside --annot_mode=0 --notitle --no-viz_name_score --qaids=5 --max_nCols=2 --adjust=.01,.01,.01
Example:
>>> # DISABLE_DOCTEST
>>> from ibeis.viz.viz_qres import * # NOQA
>>> import plottool as pt
>>> ibs, cm, qreq_, kwargs = testdata_show_qres()
>>> # execute function
>>> fig = show_qres(ibs, cm, show_query=False, qreq_=qreq_, **kwargs)
>>> # verify results
>>> #fig.show()
>>> pt.show_if_requested()
"""
#ut.print_dict(kwargs)
annot_mode = kwargs.get('annot_mode', 1) % 3 # this is toggled
figtitle = kwargs.get('figtitle', '')
make_figtitle = kwargs.get('make_figtitle', False)
aug = kwargs.get('aug', '')
top_aids = kwargs.get('top_aids', DEFAULT_NTOP)
gt_aids = kwargs.get('gt_aids', [])
all_kpts = kwargs.get('all_kpts', False)
show_query = kwargs.get('show_query', False)
in_image = kwargs.get('in_image', False)
sidebyside = kwargs.get('sidebyside', True)
#name_scoring = kwargs.get('name_scoring', False)
viz_name_score = kwargs.get('viz_name_score', qreq_ is not None)
max_nCols = kwargs.get('max_nCols', None)
failed_to_match = kwargs.get('failed_to_match', False)
fnum = pt.ensure_fnum(kwargs.get('fnum', None))
if ut.VERBOSE and ut.NOT_QUIET:
print('query_info = ' + ut.obj_str(ibs.get_annot_info(cm.qaid,
default=True,
gname=False,
name=False,
notes=False,
exemplar=False),
nl=4))
print('top_aids_info = ' +
ut.obj_str(ibs.get_annot_info(top_aids,
default=True,
gname=False,
name=False,
notes=False,
exemplar=False,
reference_aid=cm.qaid),
nl=4))
if make_figtitle is True:
pass
#figtitle = cm.make_title(pack=True)
#figtitle
fig = pt.figure(fnum=fnum, docla=True, doclf=True)
if isinstance(top_aids, int):
#if isinstance(cm, chip_match.ChipMatch):
top_aids = cm.get_top_aids(top_aids)
#else:
# top_aids = cm.get_top_aids(num=top_aids, name_scoring=name_scoring, ibs=ibs)
if failed_to_match:
# HACK to visually indicate failure to match in analysis
top_aids = [None] + top_aids
nTop = len(top_aids)
if max_nCols is None:
max_nCols = 5
if nTop in [6, 7]:
max_nCols = 3
if nTop in [8]:
max_nCols = 4
try:
assert len(list(set(top_aids).intersection(
set(gt_aids)))) == 0, ('gts should be missed. not in top')
except AssertionError as ex:
ut.printex(ex, keys=['top_aids', 'gt_aids'])
raise
if ut.DEBUG2:
print(cm.get_inspect_str())
#--------------------------------------------------
# Get grid / cell information to build subplot grid
#--------------------------------------------------
# Show query or not
nQuerySubplts = 1 if show_query else 0
# The top row is given slots for ground truths and querys
# all aids in gt_aids should not be in top aids
nGtSubplts = nQuerySubplts + (0 if gt_aids is None else len(gt_aids))
# The bottom rows are for the top results
nTopNSubplts = nTop
nTopNCols = min(max_nCols, nTopNSubplts)
nGTCols = min(max_nCols, nGtSubplts)
nGTCols = max(nGTCols, nTopNCols)
nTopNCols = nGTCols
# Get number of rows to show groundtruth
nGtRows = 0 if nGTCols == 0 else int(np.ceil(nGtSubplts / nGTCols))
# Get number of rows to show results
nTopNRows = 0 if nTopNCols == 0 else int(np.ceil(nTopNSubplts / nTopNCols))
nGtCells = nGtRows * nGTCols
# Total number of rows
nRows = nTopNRows + nGtRows
DEBUG_SHOW_QRES = 0
if DEBUG_SHOW_QRES:
allgt_aids = ibs.get_annot_groundtruth(cm.qaid)
nSelGt = len(gt_aids)
nAllGt = len(allgt_aids)
print('[show_qres]========================')
print('[show_qres]----------------')
print('[show_qres] * annot_mode=%r' % (annot_mode, ))
print('[show_qres] #nTop=%r #missed_gts=%r/%r' %
(nTop, nSelGt, nAllGt))
print('[show_qres] * -----')
print('[show_qres] * nRows=%r' % (nRows, ))
print('[show_qres] * nGtSubplts=%r' % (nGtSubplts, ))
print('[show_qres] * nTopNSubplts=%r' % (nTopNSubplts, ))
print('[show_qres] * nQuerySubplts=%r' % (nQuerySubplts, ))
print('[show_qres] * -----')
print('[show_qres] * nGTCols=%r' % (nGTCols, ))
print('[show_qres] * -----')
print('[show_qres] * fnum=%r' % (fnum, ))
print('[show_qres] * figtitle=%r' % (figtitle, ))
print('[show_qres] * max_nCols=%r' % (max_nCols, ))
print('[show_qres] * show_query=%r' % (show_query, ))
print('[show_qres] * kwargs=%s' % (ut.dict_str(kwargs), ))
# HACK:
_color_list = pt.distinct_colors(nTop)
aid2_color = {aid: _color_list[ox] for ox, aid in enumerate(top_aids)}
ranked_aids = cm.get_top_aids()
# Helpers
def _show_query_fn(plotx_shift, rowcols):
""" helper for show_qres """
plotx = plotx_shift + 1
pnum = (rowcols[0], rowcols[1], plotx)
#print('[viz] Plotting Query: pnum=%r' % (pnum,))
_kwshow = dict(draw_kpts=annot_mode)
_kwshow.update(kwargs)
_kwshow['prefix'] = 'q'
_kwshow['pnum'] = pnum
_kwshow['aid2_color'] = aid2_color
_kwshow['draw_ell'] = annot_mode >= 1
viz_chip.show_chip(ibs, cm.qaid, annote=False, qreq_=qreq_, **_kwshow)
def _plot_matches_aids(aid_list, plotx_shift, rowcols):
""" helper for show_qres to draw many aids """
_kwshow = dict(draw_ell=annot_mode,
draw_pts=False,
draw_lines=annot_mode,
ell_alpha=.5,
all_kpts=all_kpts)
_kwshow.update(kwargs)
_kwshow['fnum'] = fnum
_kwshow['in_image'] = in_image
if sidebyside:
# Draw each match side by side the query
_kwshow['draw_ell'] = annot_mode == 1
_kwshow['draw_lines'] = annot_mode >= 1
else:
#print('annot_mode = %r' % (annot_mode,))
_kwshow['draw_ell'] = annot_mode == 1
#_kwshow['draw_pts'] = annot_mode >= 1
#_kwshow['draw_lines'] = False
_kwshow['show_query'] = False
def _show_matches_fn(aid, orank, pnum):
""" Helper function for drawing matches to one aid """
aug = 'rank=%r\n' % orank
_kwshow['pnum'] = pnum
_kwshow['title_aug'] = aug
#draw_ell = annot_mode == 1
#draw_lines = annot_mode >= 1
# If we already are showing the query dont show it here
if sidebyside:
# Draw each match side by side the query
if viz_name_score:
cm.show_single_namematch(qreq_, ibs.get_annot_nids(aid),
**_kwshow)
else:
_kwshow['draw_border'] = False
_kwshow['draw_lbl'] = False
_kwshow['notitle'] = True
_kwshow['vert'] = False
cm.show_single_annotmatch(qreq_, aid, **_kwshow)
#viz_matches.show_matches(ibs, cm, aid, qreq_=qreq_, **_kwshow)
else:
# Draw each match by themselves
data_config2_ = None if qreq_ is None else qreq_.get_external_data_config2(
)
#_kwshow['draw_border'] = kwargs.get('draw_border', True)
#_kwshow['notitle'] = ut.get_argflag(('--no-title', '--notitle'))
viz_chip.show_chip(ibs,
aid,
annote=False,
notitle=True,
data_config2_=data_config2_,
**_kwshow)
if DEBUG_SHOW_QRES:
print('[show_qres()] Plotting Chips %s:' %
vh.get_aidstrs(aid_list))
if aid_list is None:
return
# Do lazy load before show
#data_config2_ = None if qreq_ is None else qreq_.get_external_data_config2()
tblhack = getattr(qreq_, 'tablename', None)
# HACK FOR HUMPBACKS
# (Also in viz_matches)
if tblhack == 'vsone' or (qreq_ is not None and not qreq_._isnewreq):
# precompute
pass
#ibs.get_annot_chips(aid_list, config2_=data_config2_, ensure=True)
#ibs.get_annot_kpts(aid_list, config2_=data_config2_, ensure=True)
for ox, aid in enumerate(aid_list):
plotx = ox + plotx_shift + 1
pnum = (rowcols[0], rowcols[1], plotx)
oranks = np.where(ranked_aids == aid)[0]
# This pair has no matches between them.
if len(oranks) == 0:
orank = -1
if aid is None:
pt.imshow_null('Failed to find matches\nfor qaid=%r' %
(cm.qaid),
fnum=fnum,
pnum=pnum,
fontsize=18)
else:
_show_matches_fn(aid, orank, pnum)
#if DEBUG_SHOW_QRES:
# print('skipping pnum=%r' % (pnum,))
continue
if DEBUG_SHOW_QRES:
print('pnum=%r' % (pnum, ))
orank = oranks[0] + 1
_show_matches_fn(aid, orank, pnum)
shift_topN = nGtCells
if nGtSubplts == 1:
nGTCols = 1
if nRows == 0:
pt.imshow_null('[viz_qres] No matches. nRows=0', fnum=fnum)
else:
fig = pt.figure(fnum=fnum,
pnum=(nRows, nGTCols, 1),
docla=True,
doclf=True)
pt.plt.subplot(nRows, nGTCols, 1)
# Plot Query
if show_query:
_show_query_fn(0, (nRows, nGTCols))
# Plot Ground Truth (if given)
_plot_matches_aids(gt_aids, nQuerySubplts, (nRows, nGTCols))
# Plot Results
_plot_matches_aids(top_aids, shift_topN, (nRows, nTopNCols))
figtitle += aug
if failed_to_match:
figtitle += '\n No matches found'
incanvas = kwargs.get('with_figtitle', not vh.NO_LBL_OVERRIDE)
pt.set_figtitle(figtitle, incanvas=incanvas)
# Result Interaction
return fig
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 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.pygraphviz_layout(netx_graph)
#pos = netx.pydot_layout(netx_graph, prog='dot')
#pos = netx.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,
frameon=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 myquery():
r"""
BUG::
THERE IS A BUG SOMEWHERE: HOW IS THIS POSSIBLE?
if everything is weightd ) how di the true positive even get a score
while the true negative did not
qres_copy.filtkey_list = ['ratio', 'fg', 'homogerr', 'distinctiveness']
CORRECT STATS
{
'max' : [0.832, 0.968, 0.604, 0.000],
'min' : [0.376, 0.524, 0.000, 0.000],
'mean' : [0.561, 0.924, 0.217, 0.000],
'std' : [0.114, 0.072, 0.205, 0.000],
'nMin' : [1, 1, 1, 51],
'nMax' : [1, 1, 1, 1],
'shape': (52, 4),
}
INCORRECT STATS
{
'max' : [0.759, 0.963, 0.264, 0.000],
'min' : [0.379, 0.823, 0.000, 0.000],
'mean' : [0.506, 0.915, 0.056, 0.000],
'std' : [0.125, 0.039, 0.078, 0.000],
'nMin' : [1, 1, 1, 24],
'nMax' : [1, 1, 1, 1],
'shape': (26, 4),
# score_diff, tp_score, tn_score, p, K, dcvs_clip_max, fg_power, homogerr_power
0.494, 0.494, 0.000, 73.000, 2, 0.500, 0.100, 10.000
see how seperability changes as we very things
CommandLine:
python -m ibeis.algo.hots.devcases --test-myquery
python -m ibeis.algo.hots.devcases --test-myquery --show --index 0
python -m ibeis.algo.hots.devcases --test-myquery --show --index 1
python -m ibeis.algo.hots.devcases --test-myquery --show --index 2
References:
http://en.wikipedia.org/wiki/Pareto_distribution <- look into
Example:
>>> # DISABLE_DOCTEST
>>> from ibeis.all_imports import * # NOQA
>>> from ibeis.algo.hots.devcases import * # NOQA
>>> ut.dev_ipython_copypaster(myquery) if ut.inIPython() else myquery()
>>> pt.show_if_requested()
"""
from ibeis.algo.hots import special_query # NOQA
from ibeis.algo.hots import distinctiveness_normalizer # NOQA
from ibeis import viz # NOQA
import plottool as pt
index = ut.get_argval('--index', int, 0)
ibs, aid1, aid2, tn_aid = testdata_my_exmaples(index)
qaids = [aid1]
daids = [aid2] + [tn_aid]
qvuuid = ibs.get_annot_visual_uuids(aid1)
cfgdict_vsone = dict(
sv_on=True,
#sv_on=False,
#codename='vsone_unnorm_dist_ratio_extern_distinctiveness',
codename='vsone_unnorm_ratio_extern_distinctiveness',
sver_output_weighting=True,
)
use_cache = False
save_qcache = False
qres_list, qreq_ = ibs.query_chips(qaids, daids, cfgdict=cfgdict_vsone,
return_request=True, use_cache=use_cache,
save_qcache=save_qcache, verbose=True)
qreq_.load_distinctiveness_normalizer()
qres = qres_list[0]
top_aids = qres.get_top_aids() # NOQA
qres_orig = qres # NOQA
def test_config(qreq_, qres_orig, cfgdict):
""" function to grid search over """
qres_copy = copy.deepcopy(qres_orig)
qreq_vsone_ = qreq_
qres_vsone = qres_copy
filtkey = hstypes.FiltKeys.DISTINCTIVENESS
newfsv_list, newscore_aids = special_query.get_extern_distinctiveness(qreq_, qres_copy, **cfgdict)
special_query.apply_new_qres_filter_scores(qreq_vsone_, qres_vsone, newfsv_list, newscore_aids, filtkey)
tp_score = qres_copy.aid2_score[aid2]
tn_score = qres_copy.aid2_score[tn_aid]
return qres_copy, tp_score, tn_score
#[.01, .1, .2, .5, .6, .7, .8, .9, 1.0]),
#FiltKeys = hstypes.FiltKeys
# FIXME: Use other way of doing gridsearch
grid_basis = distinctiveness_normalizer.DCVS_DEFAULT.get_grid_basis()
gridsearch = ut.GridSearch(grid_basis, label='qvuuid=%r' % (qvuuid,))
print('Begin Grid Search')
for cfgdict in ut.ProgressIter(gridsearch, lbl='GridSearch'):
qres_copy, tp_score, tn_score = test_config(qreq_, qres_orig, cfgdict)
gridsearch.append_result(tp_score, tn_score)
print('Finish Grid Search')
# Get best result
best_cfgdict = gridsearch.get_rank_cfgdict()
qres_copy, tp_score, tn_score = test_config(qreq_, qres_orig, best_cfgdict)
# Examine closely what you can do with scores
if False:
qres_copy = copy.deepcopy(qres_orig)
qreq_vsone_ = qreq_
filtkey = hstypes.FiltKeys.DISTINCTIVENESS
newfsv_list, newscore_aids = special_query.get_extern_distinctiveness(qreq_, qres_copy, **cfgdict)
ut.embed()
def make_cm_very_old_tuple(qres_copy):
assert ut.listfind(qres_copy.filtkey_list, filtkey) is None
weight_filters = hstypes.WEIGHT_FILTERS
weight_filtxs, nonweight_filtxs = special_query.index_partition(qres_copy.filtkey_list, weight_filters)
aid2_fsv = {}
aid2_fs = {}
aid2_score = {}
for new_fsv_vsone, daid in zip(newfsv_list, newscore_aids):
pass
break
#scorex_vsone = ut.listfind(qres_copy.filtkey_list, filtkey)
#if scorex_vsone is None:
# TODO: add spatial verification as a filter score
# augment the vsone scores
# TODO: paramaterize
weighted_ave_score = True
if weighted_ave_score:
# weighted average scoring
new_fs_vsone = special_query.weighted_average_scoring(new_fsv_vsone, weight_filtxs, nonweight_filtxs)
else:
# product scoring
new_fs_vsone = special_query.product_scoring(new_fsv_vsone)
new_score_vsone = new_fs_vsone.sum()
aid2_fsv[daid] = new_fsv_vsone
aid2_fs[daid] = new_fs_vsone
aid2_score[daid] = new_score_vsone
return aid2_fsv, aid2_fs, aid2_score
# Look at plot of query products
for new_fsv_vsone, daid in zip(newfsv_list, newscore_aids):
new_fs_vsone = special_query.product_scoring(new_fsv_vsone)
scores_list = np.array(new_fs_vsone)[:, None].T
pt.plot_sorted_scores(scores_list, logscale=False, figtitle=str(daid))
pt.iup()
special_query.apply_new_qres_filter_scores(qreq_vsone_, qres_copy, newfsv_list, newscore_aids, filtkey)
# PRINT INFO
import functools
#ut.rrrr()
get_stats_str = functools.partial(ut.get_stats_str, axis=0, newlines=True, precision=3)
tp_stats_str = ut.align(get_stats_str(qres_copy.aid2_fsv[aid2]), ':')
tn_stats_str = ut.align(get_stats_str(qres_copy.aid2_fsv[tn_aid]), ':')
info_str_list = []
info_str_list.append('qres_copy.filtkey_list = %r' % (qres_copy.filtkey_list,))
info_str_list.append('CORRECT STATS')
info_str_list.append(tp_stats_str)
info_str_list.append('INCORRECT STATS')
info_str_list.append(tn_stats_str)
info_str = '\n'.join(info_str_list)
print(info_str)
# SHOW BEST RESULT
#qres_copy.ishow_top(ibs, fnum=pt.next_fnum())
#qres_orig.ishow_top(ibs, fnum=pt.next_fnum())
# Text Informatio
param_lbl = 'dcvs_power'
param_stats_str = gridsearch.get_dimension_stats_str(param_lbl)
print(param_stats_str)
csvtext = gridsearch.get_csv_results(10)
print(csvtext)
# Paramter visuzliation
fnum = pt.next_fnum()
# plot paramter influence
param_label_list = gridsearch.get_param_lbls()
pnum_ = pt.get_pnum_func(2, len(param_label_list))
for px, param_label in enumerate(param_label_list):
gridsearch.plot_dimension(param_label, fnum=fnum, pnum=pnum_(px))
# plot match figure
pnum2_ = pt.get_pnum_func(2, 2)
qres_copy.show_matches(ibs, aid2, fnum=fnum, pnum=pnum2_(2))
qres_copy.show_matches(ibs, tn_aid, fnum=fnum, pnum=pnum2_(3))
# Add figure labels
figtitle = 'Effect of parameters on vsone separation for a single case'
subtitle = 'qvuuid = %r' % (qvuuid)
figtitle += '\n' + subtitle
pt.set_figtitle(figtitle)
# Save Figure
#fig_fpath = pt.save_figure(usetitle=True)
#print(fig_fpath)
# Write CSV Results
#csv_fpath = fig_fpath + '.csv.txt'
#ut.write_to(csv_fpath, csvtext)
#qres_copy.ishow_top(ibs)
#from matplotlib import pyplot as plt
#plt.show()
#print(ut.list_str()))
# TODO: plot max variation dims
#import plottool as pt
#pt.plot(p_list, diff_list)
"""
def show_ori_image_ondisk():
r"""
Args:
img (ndarray[uint8_t, ndim=2]): image data
ori (?):
gmag (?):
CommandLine:
python -m vtool.histogram --test-show_ori_image_ondisk --show
python -m vtool.histogram --test-show_ori_image_ondisk --show --patch_img_fpath patches/KP_0_PATCH.png --ori_img_fpath patches/KP_0_orientations01.png --weights_img_fpath patches/KP_0_WEIGHTS.png --grady_img_fpath patches/KP_0_ygradient.png --gradx_img_fpath patches/KP_0_xgradient.png --title cpp_show_ori_ondisk
python -m pyhesaff._pyhesaff --test-test_rot_invar --show --rebuild-hesaff --no-rmbuild
Example:
>>> # DISABLE_DOCTEST
>>> from vtool.histogram import * # NOQA
>>> import plottool as pt
>>> import vtool as vt
>>> result = show_ori_image_ondisk()
>>> pt.show_if_requested()
"""
#if img_fpath is not None:
# img_fpath = ut.get_argval('--fpath', type_=str, default=ut.grab_test_imgpath('star.png'))
# img_fpath = ut.get_argval('--fpath', type_=str, default=ut.grab_test_imgpath('star.png'))
# img = vt.imread(img_fpath)
# ori_img_fpath = ut.get_argval('--fpath-ori', type_=str,
# default=ut.augpath(img_fpath, '_ori'))
# weights_img_fpath = ut.get_argval('--fpath-weight', type_=str,
# default=ut.augpath(img_fpath, '_mag'))
# vt.imwrite(ori_img_fpath, vt.patch_ori(*vt.patch_gradient(img)))
# vt.imwrite(weights_img_fpath, vt.patch_mag(*vt.patch_gradient(img)))
import vtool as vt
print('show_ori_image_ondisk')
def parse_img_from_arg(argstr_):
fpath = ut.get_argval(argstr_, type_=str, default='None')
if fpath is not None and fpath != 'None':
img = vt.imread(fpath, grayscale=True)
print('Reading %s with stats %s' % (fpath, ut.get_stats_str(img, axis=None)))
else:
print('Did not read %s' % (fpath))
img = None
return img
patch = parse_img_from_arg('--patch_img_fpath')
gori = parse_img_from_arg('--ori_img_fpath') / 255.0 * TAU
weights = parse_img_from_arg('--weights_img_fpath') / 255.0
gradx = parse_img_from_arg('--gradx_img_fpath') / 255.0
grady = parse_img_from_arg('--grady_img_fpath') / 255.0
gauss = parse_img_from_arg('--gauss_weights_img_fpath') / 255.0
#print(' * ori_img_fpath = %r' % (ori_img_fpath,))
#print(' * weights_img_fpath = %r' % (weights_img_fpath,))
#print(' * gradx_img_fpath = %r' % (gradx_img_fpath,))
#print(' * grady_img_fpath = %r' % (grady_img_fpath,))
#import cv2
#cv2.imread(ori_img_fpath, cv2.IMREAD_UNCHANGED)
show_ori_image(gori, weights, patch, gradx, grady, gauss)
title = ut.get_argval('--title', default='')
import plottool as pt
pt.set_figtitle(title)
def test_rot_invar():
r"""
CommandLine:
python -m pyhesaff test_rot_invar --show --rebuild-hesaff --no-rmbuild
python -m pyhesaff test_rot_invar --show --nocpp
python -m vtool.tests.dummy testdata_ratio_matches --show --ratio_thresh=1.0 --rotation_invariance --rebuild-hesaff
python -m vtool.tests.dummy testdata_ratio_matches --show --ratio_thresh=1.1 --rotation_invariance --rebuild-hesaff
Example:
>>> # DISABLE_DODCTEST
>>> from pyhesaff._pyhesaff import * # NOQA
>>> test_rot_invar()
"""
import cv2
import utool as ut
import vtool as vt
import plottool as pt
TAU = 2 * np.pi
fnum = pt.next_fnum()
NUM_PTS = 5 # 9
theta_list = np.linspace(0, TAU, NUM_PTS, endpoint=False)
nRows, nCols = pt.get_square_row_cols(len(theta_list), fix=True)
next_pnum = pt.make_pnum_nextgen(nRows, nCols)
# Expand the border a bit around star.png
pad_ = 100
img_fpath = ut.grab_test_imgpath('star.png')
img_fpath2 = vt.pad_image_ondisk(img_fpath, pad_, value=26)
for theta in theta_list:
print('-----------------')
print('theta = %r' % (theta,))
#theta = ut.get_argval('--theta', type_=float, default=TAU * 3 / 8)
img_fpath = vt.rotate_image_ondisk(img_fpath2, theta, borderMode=cv2.BORDER_REPLICATE)
if not ut.get_argflag('--nocpp'):
(kpts_list_ri, vecs_list2) = detect_feats(img_fpath, rotation_invariance=True)
kpts_ri = ut.strided_sample(kpts_list_ri, 2)
(kpts_list_gv, vecs_list1) = detect_feats(img_fpath, rotation_invariance=False)
kpts_gv = ut.strided_sample(kpts_list_gv, 2)
# find_kpts_direction
imgBGR = vt.imread(img_fpath)
kpts_ripy = vt.find_kpts_direction(imgBGR, kpts_gv, DEBUG_ROTINVAR=False)
# Verify results stdout
#print('nkpts = %r' % (len(kpts_gv)))
#print(vt.kpts_repr(kpts_gv))
#print(vt.kpts_repr(kpts_ri))
#print(vt.kpts_repr(kpts_ripy))
# Verify results plot
pt.figure(fnum=fnum, pnum=next_pnum())
pt.imshow(imgBGR)
#if len(kpts_gv) > 0:
# pt.draw_kpts2(kpts_gv, ori=True, ell_color=pt.BLUE, ell_linewidth=10.5)
ell = False
rect = True
if not ut.get_argflag('--nocpp'):
if len(kpts_ri) > 0:
pt.draw_kpts2(kpts_ri, rect=rect, ell=ell, ori=True,
ell_color=pt.RED, ell_linewidth=5.5)
if len(kpts_ripy) > 0:
pt.draw_kpts2(kpts_ripy, rect=rect, ell=ell, ori=True,
ell_color=pt.GREEN, ell_linewidth=3.5)
#print('\n'.join(vt.get_ori_strs(np.vstack([kpts_gv, kpts_ri, kpts_ripy]))))
#ut.embed(exec_lines=['pt.update()'])
pt.set_figtitle('green=python, red=C++')
pt.show_if_requested()