def setUp(self):
# n1 -- n2 -- n3 -- n4
# \_ n3bis
self.n1 = Node("n1")
self.n3bis = self.n1.data("n3", None)
self.n2 = self.n1.data("n2", None)
self.n3 = self.n2.data("n3", None)
self.n4 = self.n3.data("n4", None)
self.all = [self.n1, self.n2, self.n3, self.n4, self.n3bis]
def create_report_affine(state, report_id):
y_dot_mean = state.result.y_dot_stats.mean
y_dot_cov = state.result.y_dot_stats.covariance
y_dot_inf = state.result.y_dot_stats.information
y_dot_min = state.result.y_dot_stats.minimum
y_dot_max = state.result.y_dot_stats.maximum
y_mean = state.result.y_stats.mean
y_cov = state.result.y_stats.covariance
y_inf = state.result.y_stats.information
y_min = state.result.y_stats.minimum
y_max = state.result.y_stats.maximum
u_mean = state.result.u_stats.mean
u_inf = state.result.u_stats.information
u_cov = state.result.u_stats.covariance
N = state.result.N.get_value()
report_y_dot = create_report_var(
name="y_dot", mean=y_dot_mean, cov=y_dot_cov, inf=y_dot_inf, minimum=y_dot_min, maximum=y_dot_max
)
report_y = create_report_var(name="y", mean=y_mean, cov=y_cov, inf=y_inf, minimum=y_min, maximum=y_max)
report_u = create_report_var(name="u", mean=u_mean, cov=u_cov, inf=u_inf)
T = state.result.T.get_value()
report_T = create_report_figure_tensors(T, report_id="T", caption="Learned T")
Nreport = Node("n-report")
with Nreport.data("N", N).data_file("N", "image/png") as filename:
pylab.figure()
for i in range(N.shape[1]):
v = N[:, i].squeeze()
pylab.plot(v)
pylab.savefig(filename)
pylab.close()
f = Nreport.figure("nfig")
f.sub("N/N")
bT = state.result.bT.get_value()
report_bT = create_report_figure_tensors(bT, report_id="bT", caption="Learned bT")
bTn = state.result.bTn.get_value()
report_bTn = create_report_figure_tensors(bTn, report_id="bTn", caption="Learned bTn")
node = Node(id=report_id, children=[report_y, report_y_dot, report_u, report_T, Nreport, report_bT, report_bTn])
return node
def create_report_tensors(state, report_id):
T = state.result.T
vname = "" #TODO
caption = '%s learned tensors, %d iterations' % \
(vname, state.total_iterations)
A = create_report_figure_tensors(T, same_scale=False, report_id='tensors',
caption=caption)
B = create_report_figure_tensors(T, same_scale=True, report_id='tensors-ss',
caption='%s (on the same scale)' % caption)
report = Node(report_id)
report.add_child(A)
report.add_child(B)
return report
def create_report_var(name, mean, cov, inf, minimum=None, maximum=None):
report = Node(id=name)
report.data("covariance", cov)
report.data("information", inf)
node_mean = report.data("mean", mean)
with node_mean.data_file("bounds", "image/png") as filename:
e = 3 * sqrt(cov.diagonal())
pylab.ioff()
f = pylab.figure()
x = range(len(mean))
pylab.errorbar(x, mean, yerr=e)
if minimum is not None:
pylab.plot(x, minimum, "b-")
if maximum is not None:
pylab.plot(x, maximum, "b-")
pylab.savefig(filename)
pylab.close(f)
f = report.figure(name)
f.sub("mean/bounds", caption="Mean")
f.sub("covariance", caption="Covariance", display="posneg")
f.sub("information", caption="Information", display="posneg")
return report
def create_report_figure_tensors(T, report_id, same_scale=False, caption=None):
report = Node(report_id)
f = report.figure('tensors', caption=caption)
if same_scale:
max_value = abs(T).max()
else:
max_value = None
components = [(0, 'Tx', '$T_x$'),
(1, 'Ty', '$T_y$'),
(2, 'Ttheta', '$T_{\\theta}$')]
for component, slice, caption in components:
report.data(slice, T[component, :, :].squeeze())
f.sub(slice, display='posneg', max_value=max_value)
return report
def setUp(self):
# n1 -- n2 -- n3 -- n4
# \_ n3bis
self.n1 = Node("n1")
self.n3bis = self.n1.data("n3", None)
self.n2 = self.n1.data("n2", None)
self.n3 = self.n2.data("n3", None)
self.n4 = self.n3.data("n4", None)
self.all = [self.n1, self.n2, self.n3, self.n4, self.n3bis]
def node_from_hdf_group_v1(hf, group):
major = group._v_attrs["reprep_format_version"][0]
if major != 1:
raise ValueError("I can oly read v1, not %s" % major)
nid = group._v_name
caption = group._v_title
cgroups = [
child for child in group._f_listNodes("Group")
if "reprep_format_version" in child._v_attrs
]
cgroups.sort(key=lambda x: x._v_attrs["reprep_order"])
children = [node_from_hdf_group_v1(hf, child) for child in cgroups]
nodetype = group._v_attrs["reprep_node_type"]
if nodetype == "Node":
return Node(nid=nid, children=children, caption=caption)
elif nodetype == "Figure":
cols = group.ncols.read()
if cols == 0:
cols = None
figure = Figure(nid=nid, caption=caption, cols=cols)
nsubs = len(group.subfigures._f_listNodes())
for i in range(nsubs):
s = group.subfigures._v_children["sub%d" % i]
sub = SubFigure(
resource=s.resource.read(),
image=s.image.read(),
web_image=s.web_image.read(),
caption=s.caption.read(),
)
figure.subfigures.append(sub)
figure.children = children
return figure
elif nodetype == "Table":
table_data = group.table_data.read()
rows = group.rows.read()
cols = group.cols.read()
table = Table(nid,
data=table_data,
cols=cols,
rows=rows,
caption=caption)
table.children = children
return table
elif nodetype == "DataNode":
mime, raw_data = read_python_data(group, "data")
res = DataNode(nid=nid, data=raw_data, mime=mime, caption=caption)
res.children = children
return res
else:
raise ValueError("Unknown node_type %r" % nodetype)
def create_report_covariance(state, report_id):
covariance = state.result.cov_sensels
report = Node(report_id)
report.data('covariance', covariance)
report.data('correlation', cov2corr(covariance))
report.data('information', pinv(covariance, rcond=1e-2))
f = report.figure('matrices')
f.sub('covariance', caption='Covariance matrix', display='posneg')
f.sub('correlation', caption='Correlation matrix', display='posneg')
f.sub('information', caption='Information matrix', display='posneg')
return report
class Test(unittest.TestCase):
def setUp(self):
# n1 -- n2 -- n3 -- n4
# \_ n3bis
self.n1 = Node("n1")
self.n3bis = self.n1.data("n3", None)
self.n2 = self.n1.data("n2", None)
self.n3 = self.n2.data("n3", None)
self.n4 = self.n3.data("n4", None)
self.all = [self.n1, self.n2, self.n3, self.n4, self.n3bis]
def test_normal(self):
""" Testing normal cases of resolve_url """
self.assertEqual(self.n1, self.n2.resolve_url(".."))
self.assertEqual(self.n1, self.n3.resolve_url("../.."))
self.assertEqual(self.n1, self.n4.resolve_url("../../.."))
self.assertEqual(self.n2, self.n4.resolve_url("../../../n2"))
self.assertEqual(self.n2, self.n1.resolve_url("n2"))
self.assertEqual(self.n3, self.n1.resolve_url("n2/n3"))
def test_smart(self):
""" Testing smart cases of resolve_url """
self.assertEqual(self.n1.resolve_url("n3"), self.n3bis)
self.assertEqual(self.n2.resolve_url("n3"), self.n3)
self.assertEqual(self.n3.resolve_url("n3"), self.n3)
self.assertEqual(self.n2.resolve_url("n1/n3"), self.n3bis)
self.assertEqual(self.n3.resolve_url("n1/n3"), self.n3bis)
self.assertEqual(self.n4.resolve_url("n4"), self.n4)
self.assertEqual(self.n3.resolve_url("n4"), self.n4)
self.assertEqual(self.n2.resolve_url("n4"), self.n4)
self.assertEqual(self.n1.resolve_url("n4"), self.n4)
for n in self.all:
self.assertEqual(n.resolve_url("n4"), self.n4)
def test_relative(self):
for A in self.all:
for B in self.all:
if A == B:
continue
url = A.get_relative_url(B)
self.assertEqual(A.resolve_url_dumb(url), B)
def test_not_existent(self):
""" Testing that we warn if not existent """
self.assertRaises(NotExistent, self.n1.resolve_url, "x")
def test_not_found(self):
self.assertRaises(NotExistent, self.n1.resolve_url, "..")
def test_well_formed(self):
""" Testing that we can recognize invalid urls """
self.assertRaises(InvalidURL, self.n1.resolve_url, "")
self.assertRaises(InvalidURL, self.n2.resolve_url, "//")
class Test(unittest.TestCase):
def setUp(self):
# n1 -- n2 -- n3 -- n4
# \_ n3bis
self.n1 = Node("n1")
self.n3bis = self.n1.data("n3", None)
self.n2 = self.n1.data("n2", None)
self.n3 = self.n2.data("n3", None)
self.n4 = self.n3.data("n4", None)
self.all = [self.n1, self.n2, self.n3, self.n4, self.n3bis]
def test_normal(self):
""" Testing normal cases of resolve_url """
self.assertEqual(self.n1, self.n2.resolve_url(".."))
self.assertEqual(self.n1, self.n3.resolve_url("../.."))
self.assertEqual(self.n1, self.n4.resolve_url("../../.."))
self.assertEqual(self.n2, self.n4.resolve_url("../../../n2"))
self.assertEqual(self.n2, self.n1.resolve_url("n2"))
self.assertEqual(self.n3, self.n1.resolve_url("n2/n3"))
def test_smart(self):
""" Testing smart cases of resolve_url """
self.assertEqual(self.n1.resolve_url("n3"), self.n3bis)
self.assertEqual(self.n2.resolve_url("n3"), self.n3)
self.assertEqual(self.n3.resolve_url("n3"), self.n3)
self.assertEqual(self.n2.resolve_url("n1/n3"), self.n3bis)
self.assertEqual(self.n3.resolve_url("n1/n3"), self.n3bis)
self.assertEqual(self.n4.resolve_url("n4"), self.n4)
self.assertEqual(self.n3.resolve_url("n4"), self.n4)
self.assertEqual(self.n2.resolve_url("n4"), self.n4)
self.assertEqual(self.n1.resolve_url("n4"), self.n4)
for n in self.all:
self.assertEqual(n.resolve_url("n4"), self.n4)
def test_relative(self):
for A in self.all:
for B in self.all:
if A == B:
continue
url = A.get_relative_url(B)
self.assertEqual(A.resolve_url_dumb(url), B)
def test_not_existent(self):
""" Testing that we warn if not existent """
self.assertRaises(NotExistent, self.n1.resolve_url, "x")
def test_not_found(self):
self.assertRaises(NotExistent, self.n1.resolve_url, "..")
def test_well_formed(self):
""" Testing that we can recognize invalid urls """
self.assertRaises(InvalidURL, self.n1.resolve_url, "")
self.assertRaises(InvalidURL, self.n2.resolve_url, "//")
def main():
"""
Prepare data with:
average_logs_results --dir . --experiment laser_bgds_boot
"""
print "Loading first..."
results = my_pickle_load('out/average_logs_results/laser_bgds_boot.pickle')
report = Node('laser_bgds_boot')
manual = my_figures(results)
write_figures_for_paper(manual)
report.add_child(manual)
k = 1
variants = sorted(results.keys())
# FIXME: this was uncommented (Was I in a hurry?)
# variants = []
for variant in variants:
data = results[variant]
G = data['G']
B = data['B']
# gy_mean = data['gy_mean']
# y_mean = data['y_mean']
# one_over_y_mean = data['one_over_y_mean']
y_dot_var = data['y_dot_var']
y_dot_svar = data['y_dot_svar']
gy_var = data['gy_var']
gy_svar = data['gy_svar']
print 'Considering %s' % variant
n = report.node(variant)
#readings = range(360, G.shape[0])
readings = range(0, G.shape[0])
N = len(readings)
G = G[readings, :]
B = B[readings, :]
y_dot_var = y_dot_var[readings]
y_dot_svar = y_dot_svar[readings]
gy_var = gy_var[readings]
gy_svar = gy_svar[readings]
for k in [0, 2]:
var = 'G[%s]' % k
G_k = n.data(var, G[:, k])
G_k_n = G[:, k] / gy_var
with G_k.data_pylab('original') as pylab:
pylab.plot(G[:, k])
pylab.title(var + ' original')
M = abs(G[:, k]).max()
pylab.axis([0, N, -M, M])
with G_k.data_pylab('normalized') as pylab:
pylab.plot(G_k_n)
pylab.title(var + ' normalized')
M = abs(G_k_n).max()
pylab.axis([0, N, -M, M])
for k in [0, 2]:
var = 'B[%s]' % k
B_k = n.data(var, B[:, k])
B_k_n = B[:, k] / gy_var
with B_k.data_pylab('original') as pylab:
pylab.plot(B[:, k])
pylab.title(var + ' original')
M = abs(B[:, k]).max()
pylab.axis([0, N, -M, M])
with B_k.data_pylab('normalized') as pylab:
pylab.plot(B_k_n)
pylab.title(var + ' normalized')
M = abs(B_k_n).max()
pylab.axis([0, N, -M, M])
n.figure('obtained', sub=['B[0]/normalized', 'B[2]/normalized',
'G[0]/normalized', 'G[2]/normalized', ])
n.figure('G', sub=['G[0]/original', 'G[0]/normalized',
'G[2]/original', 'G[2]/normalized'])
n.figure('B', sub=['B[0]/original', 'B[0]/normalized',
'B[2]/original', 'B[2]/normalized'])
theta = linspace(0, 2 * math.pi, N) - math.pi / 2
with n.data_pylab('B_v') as pylab:
pylab.plot(-cos(theta))
pylab.axis([0, N, -2, 2])
with n.data_pylab('B_omega') as pylab:
pylab.plot(0 * theta)
pylab.axis([0, N, -2, 2])
with n.data_pylab('G_v') as pylab:
pylab.plot(-sin(theta))
pylab.axis([0, N, -2, 2])
with n.data_pylab('G_omega') as pylab:
pylab.plot(numpy.ones((N)))
pylab.axis([0, N, -2, 2])
n.figure('expected', sub=['B_v', 'B_omega', 'G_v', 'G_omega'])
norm = lambda x: x / x.max()
# norm = lambda x : x
with n.data_pylab('y_dot_var') as pylab:
pylab.plot(norm(y_dot_var), 'b', label='y_dot_var')
pylab.plot(norm(y_dot_svar ** 2), 'g', label='y_dot_svar')
pylab.axis([0, N, 0, 1])
pylab.legend()
with n.data_pylab('gy_var') as pylab:
pylab.plot(norm(gy_var) , 'b', label='gy_var')
pylab.plot(norm(gy_svar ** 2), 'g', label='gy_svar')
pylab.axis([0, N, 0, 1])
pylab.legend()
f = n.figure('stats')
f.sub('y_dot_var')
f.sub('gy_var')
for var in ['y_dot_mean', 'gy_mean', 'y_mean', 'y_var', 'one_over_y_mean']:
with n.data_pylab(var) as pylab:
pylab.plot(data[var][readings])
f.sub(var)
with n.data_pylab('y_mean+var') as pylab:
y = data['y_mean'][readings]
var = data['y_var'][readings]
pylab.errorbar(range(0, N), y, yerr=3 * numpy.sqrt(var), fmt='ro')
f.sub('y_mean+var')
print variant
if True: #variant == 'GS_DS':
s = {'variant': variant,
'Gl':G[:, 0] / gy_var,
'Ga':G[:, 2] / gy_var,
'Bl':B[:, 0] / gy_var,
'Ba':B[:, 2] / gy_var }
filename = "out/laser_bgds_boot/%s:GB.pickle" % variant.replace('/', '_')
make_sure_dir_exists(filename)
my_pickle_dump(s, filename)
print 'Written on %s' % filename
node_to_html_document(report, 'out/laser_bgds_boot/report.html')
def my_figures(results):
r = Node('myfigures')
sick_indices = range(342, 704)
N = len(sick_indices)
theta = linspace(0, 2 * math.pi, N) - math.pi / 2
theta_deg = theta * 180 / math.pi
variants = ['GI_DI', 'GS_DS']
xlabel = 'ray direction (deg)'
ylabel = 'normalized tensor (unitless)'
a = 0.9
figparams = { 'mime': 'application/pdf', 'figsize': (4 * a, 3 * a) }
def adjust_axes(pylab):
# left, bottom, right, top
#borders = [0.15, 0.15, 0.03, 0.05]
borders = [0.2, 0.17, 0.05, 0.05]
w = 1 - borders[0] - borders[2]
h = 1 - borders[1] - borders[3]
pylab.axes([borders[0], borders[1], w, h])
def set0axis(pylab):
a = pylab.axis()
pylab.axis([-91, +271, 0, a[3]])
pylab.xticks([-90, 0, 90, 180, 270])
with r.data_pylab('report_y_mean', **figparams) as pylab:
adjust_axes(pylab)
pylab.plot(theta_deg, results[variants[0]]['y_mean'][sick_indices], 'k-')
pylab.xlabel(xlabel)
pylab.ylabel('distance (m)')
set0axis(pylab)
with r.data_pylab('report_y_var', **figparams) as pylab:
adjust_axes(pylab)
var = results[variants[0]]['y_var'][sick_indices]
pylab.plot(theta_deg, numpy.sqrt(var), 'k-')
pylab.xlabel(xlabel)
pylab.ylabel('std-dev (m)')
set0axis(pylab)
norm = lambda x: x / x.mean()
with r.data_pylab('report_gy_var', **figparams) as pylab:
adjust_axes(pylab)
for variant in variants:
x = results[variant]['gy_var'][sick_indices]
x /= numpy.max(abs(x))
pylab.plot(theta_deg, numpy.sqrt(x) , label=variant)
pylab.legend(loc='lower right')
pylab.xlabel(xlabel)
pylab.ylabel('norm. std-dev (unitless)')
set0axis(pylab)
with r.data_pylab('report_y_dot_var', **figparams) as pylab:
adjust_axes(pylab)
for variant in variants:
x = results[variant]['y_dot_var'][sick_indices]
x /= numpy.max(abs(x))
pylab.plot(theta_deg, numpy.sqrt(x) , label=variant)
pylab.legend(loc='lower right')
pylab.xlabel(xlabel)
pylab.ylabel('norm. std-dev (unitless)')
set0axis(pylab)
def set_x_axis(pylab):
a = pylab.axis()
pylab.axis([-91, +271, a[2], a[3]])
pylab.xticks([-90, 0, 90, 180, 270])
with r.data_pylab('report_Gv', **figparams) as pylab:
adjust_axes(pylab)
for variant in variants:
gy_var = results[variant]['gy_var'][sick_indices]
x = results[variant]['G'][sick_indices, 0] / gy_var
#x /= normG[variant]
x /= numpy.max(abs(x))
pylab.plot(theta_deg, x , label=variant)
pylab.plot(theta_deg, -sin(theta), label='expected')
pylab.plot(theta_deg, 0 * theta, 'k--')
#pylab.axis([0, N, -2, 2])
#pylab.legend(loc='lower right')
pylab.xlabel(xlabel)
pylab.ylabel(ylabel)
set_x_axis(pylab)
with r.data_pylab('report_Gomega', **figparams) as pylab:
adjust_axes(pylab)
for variant in variants:
gy_var = results[variant]['gy_var'][sick_indices]
x = results[variant]['G'][sick_indices, 2] / gy_var
#x /= normG[variant]
x /= numpy.mean(abs(x))
pylab.plot(theta_deg, x, label=variant)
pylab.plot(theta_deg, norm(numpy.ones((N))), label='expected')
pylab.plot(theta_deg, 0 * theta, 'k--')
#pylab.axis([0, N, 0, 1.5])
pylab.legend(loc='lower right')
pylab.xlabel(xlabel)
pylab.ylabel(ylabel)
set_x_axis(pylab)
with r.data_pylab('report_Bv', **figparams) as pylab:
adjust_axes(pylab)
for variant in variants:
gy_var = results[variant]['gy_var'][sick_indices]
x = results[variant]['B'][sick_indices, 0] / gy_var
#x /= normB[variant]
x /= numpy.max(abs(x))
pylab.plot(theta_deg, x, label=variant)
pylab.plot(theta_deg, -cos(theta), label='expected')
pylab.plot(theta_deg, 0 * theta, 'k--')
#pylab.axis([0, N, -2, 2])
#pylab.legend(loc='lower right')
pylab.xlabel(xlabel)
pylab.ylabel(ylabel)
set_x_axis(pylab)
with r.data_pylab('report_Bomega', **figparams) as pylab:
adjust_axes(pylab)
for variant in variants:
gy_var = results[variant]['gy_var'][sick_indices]
x = norm(results[variant]['B'][sick_indices, 2]) / gy_var
# /= normB[variant]
x /= numpy.max(abs(x)) * 10
pylab.plot(theta_deg, x, label=variant)
pylab.plot(theta_deg, 0 * theta, label='expected')
#pylab.axis([0, N, -2, 2])
#pylab.legend(loc='lower right')
pylab.xlabel(xlabel)
pylab.ylabel(ylabel)
set_x_axis(pylab)
r.figure(sub=['report_y_mean', 'report_y_var', 'report_gy_var', 'report_y_dot_var'])
r.figure(sub=['report_Gv', 'report_Gomega', 'report_Bv', 'report_Bomega'])
return r
def testImageRGB(self):
rgb = numpy.zeros((4, 4, 3), 'uint8')
report = Node('test')
report.data_rgb('rgb', rgb)
def analyze_olfaction_covariance(covariance, receptors):
''' Covariance: n x n covariance matrix.
Positions: list of n positions '''
positions = [pose.get_2d_position() for pose, sens in receptors] #@UnusedVariable
positions = array(positions).transpose().squeeze()
require_shape(square_shape(), covariance)
n = covariance.shape[0]
require_shape((2, n), positions)
distances = create_distance_matrix(positions)
correlation = cov2corr(covariance)
flat_distances = distances.reshape(n * n)
flat_correlation = correlation.reshape(n * n)
# let's fit a polynomial
deg = 4
poly = polyfit(flat_distances, flat_correlation, deg=deg)
knots = linspace(min(flat_distances), max(flat_distances), 2000)
poly_int = polyval(poly, knots)
poly_fder = polyder(poly)
fder = polyval(poly_fder, distances)
Ttheta = create_olfaction_Ttheta(positions, fder)
Tx, Ty = create_olfaction_Txy(positions, fder, distances)
report = Node('olfaction-theory')
report.data('flat_distances', flat_distances)
report.data('flat_correlation', flat_correlation)
with report.data_file('dist_vs_corr', 'image/png') as filename:
pylab.figure()
pylab.plot(flat_distances, flat_correlation, '.')
pylab.plot(knots, poly_int, 'r-')
pylab.xlabel('distance')
pylab.ylabel('correlation')
pylab.title('Correlation vs distance')
pylab.legend(['data', 'interpolation deg = %s' % deg])
pylab.savefig(filename)
pylab.close()
with report.data('fder', fder).data_file('fder', 'image/png') as filename:
pylab.figure()
pylab.plot(knots, polyval(poly_fder, knots), 'r-')
pylab.title('f der')
pylab.savefig(filename)
pylab.close()
report.data('distances', distances)
report.data('correlation', correlation)
report.data('covariance', covariance)
report.data('f', polyval(poly, distances))
f = report.figure(id='cor-vs-distnace', caption='Estimated kernels',
shape=(3, 3))
f.sub('dist_vs_corr')
f.sub('fder')
f.sub('f', display='scale')
f.sub('distances', display='scale')
f.sub('correlation', display='posneg')
f.sub('covariance', display='posneg')
T = numpy.zeros(shape=(3, Tx.shape[0], Tx.shape[1]))
T[0, :, :] = Tx
T[1, :, :] = Ty
T[2, :, :] = Ttheta
T_report = create_report_figure_tensors(T, report_id='tensors',
caption="Predicted learned tensors")
report.add_child(T_report)
return report
def main():
"""
Prepare data with: ::
be_average_logs_results --dir . --experiment camera_bgds_boot -v gray/GI_DI -v contrast/GS_DS
be_average_logs_results --dir . --experiment camera_bgds_stats -v gray/GI_DI -v contrast/GS_DS
Reads: ::
out/average_logs_results/camera_bgds_boot.pickle
out/average_logs_results/camera_bgds_stats.pickle
Writes: ::
out/camera_bgds_boot/report.html
out/camera_bgds_boot/report.pickle
out/camera_bgds_boot/<variant>:G.pickle
moreover, it calls camera_figures() that creates
output_pattern = 'out/camera_figures/{variant}.tex'
"""
input1 = 'out/average_logs_results/camera_bgds_boot.pickle'
input2 = 'out/average_logs_results/camera_bgds_stats.pickle'
variant_pattern = "out/camera_bgds_boot/{variant}:G.pickle"
out_html = 'out/camera_bgds_boot/report.html'
out_pickle = 'out/camera_bgds_boot/report.pickle'
results = my_pickle_load(input1)
print 'Found variants: %s' % results.keys()
stats = my_pickle_load(input2)
print 'Found variants: %s' % stats.keys()
print "Creating report..."
report = Node('camera_bgds_boot')
k = 1
variants = sorted(results.keys())
for variant_id in variants:
variant = variant_id.replace('/', '_')
print 'Considering %s' % variant
data = results[variant_id]
data2 = stats[variant_id]
print data2.keys()
#if not variant in ['gray_GI_DI', 'contrast_GS_DS']:
# continue
n = report.node(variant)
f1 = n.figure('value')
f2 = n.figure('sign')
f3 = n.figure('abs')
for variable, value in data.items():
v = n.data(variable, value)
if len(value.shape) == 3:
f1.sub(variable, display='rgb')
else:
v.data('sign', numpy.sign(value), desc='sign of %s' % variable)
v.data('abs', numpy.abs(value), desc='abs of %s' % variable)
f1.sub(variable, display='posneg', skim=1)
f2.sub('%s/sign' % variable, display='posneg')
f3.sub('%s/abs' % variable, display='scale', min_value=0)
f4 = n.figure('stats')
for variable, value in data2.items():
if len(value.shape) == 3:
v = n.data(variable, value.astype('uint8'))
f1.sub(variable, display='rgb')
else:
v = n.data(variable, value)
#f4.sub(variable, display='scale', skim=1)
f4.sub(variable, display='scale', skim=1, min_value=0)
Gxl = data['Gxl']
Gyl = data['Gyl']
Gxa = data['Gxa']
Gya = data['Gya']
def set_zeros_to_one(x):
x = x.copy()
zeros, = nonzero(x.flat == 0)
x.flat[zeros] = 1
print "%d/%d of data were 0" % (len(zeros), len(x.flat))
return x
norm_gx = set_zeros_to_one (data2['gx_abs'])
norm_gy = set_zeros_to_one (data2['gy_abs'])
Gxl_norm = Gxl / norm_gx
Gyl_norm = Gyl / norm_gy
Gxa_norm = Gxa / norm_gx
Gya_norm = Gya / norm_gy
n.data('Gxl_norm', Gxl_norm)
n.data('Gyl_norm', Gyl_norm)
n.data('Gxa_norm', Gxa_norm)
n.data('Gya_norm', Gya_norm)
f5 = n.figure('normalized')
display = {'display': 'posneg', 'skim': 2}
f5.sub('Gxl_norm', **display)
f5.sub('Gyl_norm', **display)
f5.sub('Gxa_norm', **display)
f5.sub('Gya_norm', **display)
k += 1
if k > 1:
pass
# break # tmp
if True:
s = {'variant': variant,
'Gxl':Gxl_norm,
'Gyl':Gyl_norm,
'Gxa':Gxa_norm,
'Gya':Gya_norm }
filename = variant_pattern.format(variant=variant)
dir = os.path.dirname(filename)
if not os.path.exists(dir):
os.makedirs(dir)
my_pickle_dump(s, filename)
print 'Written on %s' % filename
print "Writing on %s" % out_html
report.to_html(out_html)
#print "Writing on %s" % out_pickle
my_pickle_dump(report, out_pickle)
def main():
def find_in_path(path, pattern):
for root, dirs, files in os.walk(path): #@UnusedVariable
for f in files:
if fnmatch.fnmatch(f, pattern):
yield os.path.join(root, f)
dir = 'Bicocca_2009-02-25a/out/camera_bgds_predict/gray_GI_DI/'
files = list(find_in_path(dir, '*.??.pickle*'))
if not files:
raise Exception('No files found.')
for f in files:
print 'Loading {0}'.format(f)
data = my_pickle_load(f)
basename = os.path.splitext(f)[0]
out_html = basename + '/report.html'
#out_pickle = basename + '/report.pickle'
if not os.path.exists(basename):
os.makedirs(basename)
logdir = data['logdir']
time = data['time']
y = data['y']
y_dot = data['y_dot']
y_dot_pred = data['y_dot_pred']
y_dot_s = data['y_dot_s']
y_dot_pred_s = data['y_dot_pred_s']
report = Node('{logdir}-{time:.2f}'.format(logdir=logdir, time=time))
prod = -numpy.minimum(0, y_dot_s * y_dot_pred_s)
report.data('y', y)
report.data('y_dot', y_dot)
report.data('y_dot_pred', y_dot_pred)
report.data('y_dot_s', y_dot_s)
report.data('y_dot_pred_s', y_dot_pred_s)
report.data('prod', prod)
f = report.figure('display')
f.sub('y', display='rgb')
f.sub('y_dot', display='posneg')
f.sub('y_dot_pred', display='posneg')
f.sub('y_dot_s', display='posneg')
f.sub('y_dot_pred_s', display='posneg')
f.sub('prod', display='scale')
zones = [
('ZoneA', range(95, 181), range(55, 140)),
('ZoneB', range(80, 111), range(480, 510)),
('ZoneC', range(50, 181), range(330, 460))
]
for zone in zones:
name, y, x = zone
zr = report.node(name)
zf = zr.figure()
for var in ['y', 'y_dot', 'y_dot_pred', 'y_dot_s', 'y_dot_pred_s',
'prod']:
zd = data[var][y, :][:, x]
zr.data(var, zd)
if var == 'y':
disp = {'display': 'rgb'}
elif var == 'prod':
disp = {'display': 'scale'}
else:
disp = {'display': 'posneg'}
zf.sub(var, **disp)
outdir = basename + '/' + name
id = "%s:%.2f:%s" % (logdir, time, name)
print id
if not os.path.exists(outdir):
os.makedirs(outdir)
create_latex_frag(os.path.join(outdir, 'conf.tex'), outdir, zr, id, True)
create_latex_frag(os.path.join(outdir, 'report.tex'), outdir, zr, id, False)
print 'Writing on %s' % out_html
node_to_html_document(report, out_html)
def testImage(self):
C = numpy.random.rand(50, 50)
information = pinv(C)
T = numpy.random.rand(50, 50, 3)
report = Node("rangefinder")
report.data("Tx", T[:, :, 0])
report.data("Ty", T[:, :, 1])
report.data("Tz", T[:, :, 2])
cov = report.data("covariance", C)
report.data("information", information)
pylab = get_pylab_instance()
with cov.data_file("plot", MIME_PNG) as f:
pylab.figure()
pylab.plot(C)
pylab.savefig(f)
pylab.close()
report.table("results", cols=["One", "Two"], data=[[1, 2], [3, 4]])
f = report.figure(caption="Covariance and information matrix", cols=3)
f.sub("covariance", "should default to plot")
f.sub("covariance/plot", "Same as <-")
f = report.figure("Tensors", cols=3)
f.sub("Tx", display="posneg")
f.sub("Ty", display="posneg")
f.sub("Tz", display="posneg")
self.node_serialization_ok(report)
def testImageRGB(self):
rgb = numpy.zeros((4, 4, 3), "uint8")
report = Node("test")
report.data_rgb("rgb", rgb)
def testImage(self):
C = numpy.random.rand(50, 50)
information = pinv(C)
T = numpy.random.rand(50, 50, 3)
report = Node('rangefinder')
report.data('Tx', T[:, :, 0])
report.data('Ty', T[:, :, 1])
report.data('Tz', T[:, :, 2])
cov = report.data('covariance', C)
report.data('information', information)
pylab = get_pylab_instance()
with cov.data_file('plot', 'image/png') as f:
pylab.figure()
pylab.plot(C)
pylab.savefig(f)
pylab.close()
report.table('results',
cols=['One', 'Two'],
data=[[1, 2], [3, 4]])
f = report.figure(caption='Covariance and information matrix', cols=3)
f.sub('covariance', 'should default to plot')
f.sub('covariance/plot', 'Same as <-')
f = report.figure('Tensors', cols=3)
f.sub('Tx', display='posneg')
f.sub('Ty', display='posneg')
f.sub('Tz', display='posneg')
self.node_serialization_ok(report)
