def __init__(self, filename, blockSizeX, blockSizeY, overlap, cellSizeX, cellSizeY, oBins):
"""Constructor from an input image.
Args:
filename: Filename of input image e.g. 'test.png'.
It can also takes a numpy array
blockSizeX: The number of cells on the x axis of the Blocks. The
size in pixels is blockSizeX*cellSizeX
blockSizeY: The number of cells on the y axis of the Blocks. The
size in pixels is blockSizeY*cellSizeY
overlap: Fraction of overlap between Blocks.
cellSizeX: The number of pixels on the x axis of the Cells within
this Block.
cellSizeY: The number of pixels on the y axis of the Cells within
this Block.
oBins: Number of orientation bins
"""
if type(filename) == str:
# load the image
self._inputImage = misc.imread(filename)
elif type(filename) == np.ndarray:
self._inputImage = filename
else:
raise TypeError("That is not a valid input")
# plt.imshow(self._inputImage, cmap=plt.cm.gray, interpolation="nearest")
# plt.show()
# Calculate gradient and magnitude arrays and then create Blocks for each of them
gx, gy = self._create_gradient_images(self._inputImage)
# Create block objects for each the magnitude and gradient images.
self.gradBlock = Block(self.grad, blockSizeX, blockSizeY, overlap, cellSizeX, cellSizeY)
self.magBlock = Block(self.mag, blockSizeX, blockSizeY, overlap, cellSizeX, cellSizeY)
# Create histogram object - which takes the gradient Block object and the
# magnitude Block object
self.histogram = Histogram(self.gradBlock, self.magBlock, oBins)
self.output = self.histogram.histArray
# Draw an output
self.histogramPlotter = HistogramPlotter(self._inputImage, self.output)
self.histogramPlotter.plot()
def main():
# build a simple dummy analysis to test the composition of Morphisms
ana = Analysis("ana")
ana_t = Analysis("ana_t")
m0 = DummyMorphism("m0") # always put a dummy morphism at the beginning
m1 = ExpGeneratorMorphism("m1", pars = {"scale": 1.0})
m2 = ConvMorphism("m2", pars = {"loc": 1.0, "scale": 1.6}, kern = np.random.normal)
m3 = TransfMorphism("m3", transf = lambda x: x - 0.05 * x**2 + 0.01 * x**3)
m4 = DummyMorphism("m4")
m5 = DummyMorphism("m5")
# this is the modified morphism
m1_t = ExpGeneratorMorphism("m1_t", pars = {"scale": 2.0})
ana.add_morphisms([m0, m1, m2, m3, m4, m5])
ana_t.add_morphisms([m0, m1_t, m2, m3, m4, m5])
nsamp = 1000000
dummy_data = pd.DataFrame.from_dict({"datacol": np.random.rand(nsamp)})
# run both analyses on the same data
out = ana.run(dummy_data)
out_t = ana_t.run(dummy_data)
# compute the resulting distributions
binning = np.linspace(-2, 20, 30)
hist = Histogram.from_data(name = r'$p(x_3|\theta_1,\theta_2,\theta_3)$', data = out, binning = binning)
hist_t = Histogram.from_data(name = r'$p(x_3|\tilde{\theta_1},\theta_2,\theta_3)$', data = out_t, binning = binning)
# play a bit with the likelihood ratio that should be propagated
source_hist = Histogram.from_data(r'$p(x_1|\theta_1)$', data = m1(dummy_data), binning = binning)
source_hist_t = Histogram.from_data(r'$p(x_1|\tilde{\theta_1})$', data = m1_t(dummy_data), binning = binning)
HistogramPlotter.plot_histograms([source_hist, source_hist_t], color = ["black", "salmon"], outfile = "/home/philipp/OX/thesis/FastProp/run/source.pdf", xlabel = r'$x_1$', ylabel = "events")
# also get the weights and compare the result
# first, create the profile of this analysis
prof = Profiler(ana)
prof.profile(dummy_data)
est = HistogramLREstimator(nbins = 30)
est.build_estimate(data_num = m1_t(dummy_data), data_den = m1(dummy_data))
prop = Propagator("prop")
prop.generate_propagator("m1", "m5", prof, est)
hist_rw = HistogramReweighter.reweight_to(hist, prop)
hist_rw.name = r'$p(x_3|\theta_1,\theta_2,\theta_3)\cdot R(x_3; \tilde{\theta_1}, \theta_1)$'
# plot the final histograms
HistogramPlotter.plot_histograms([hist, hist_t, hist_rw], show_ratio = True, color = ["black", "salmon", "mediumseagreen"], ratio_reference = hist_t, xlabel = r'$x_3$', ylabel = "events", outfile = "/home/philipp/OX/thesis/FastProp/run/target_rw.pdf")
HistogramPlotter.plot_histograms([hist, hist_t], show_ratio = True, color = ["black", "salmon"], ratio_reference = hist_t, xlabel = r'$x_3$', ylabel = "events", outfile = "/home/philipp/OX/thesis/FastProp/run/target.pdf")
# plot both the original reweighting factor, and the final one
finebinning = np.linspace(-2, 10, 300)
finebinning = np.expand_dims(finebinning, axis = 1)
source_reweighting = est.evaluate(finebinning)
target_reweighting = prop.predict(finebinning)
FunctionPlotter.plot_function(finebinning, source_reweighting, outfile = "/home/philipp/OX/thesis/FastProp/run/source_reweighting.pdf", xlabel = r'$x_1$', ylabel = r'$R(x_1; \tilde{\theta_1}, \theta_1)$', color = "black")
FunctionPlotter.plot_function(finebinning, target_reweighting, outfile = "/home/philipp/OX/thesis/FastProp/run/target_reweighting.pdf", xlabel = r'$x_3$', ylabel = r'$R(x_3; \tilde{\theta_1}, \theta_1)$', color = "black")
class Hog:
"""A container object to manage the HOG algorithm.
Attributes:
_inputImage (numpy.ndarray): The raw unprocessed input image.
grad
mag
gradBlock
magBlock
"""
def __init__(self, filename, blockSizeX, blockSizeY, overlap, cellSizeX, cellSizeY, oBins):
"""Constructor from an input image.
Args:
filename: Filename of input image e.g. 'test.png'.
It can also takes a numpy array
blockSizeX: The number of cells on the x axis of the Blocks. The
size in pixels is blockSizeX*cellSizeX
blockSizeY: The number of cells on the y axis of the Blocks. The
size in pixels is blockSizeY*cellSizeY
overlap: Fraction of overlap between Blocks.
cellSizeX: The number of pixels on the x axis of the Cells within
this Block.
cellSizeY: The number of pixels on the y axis of the Cells within
this Block.
oBins: Number of orientation bins
"""
if type(filename) == str:
# load the image
self._inputImage = misc.imread(filename)
elif type(filename) == np.ndarray:
self._inputImage = filename
else:
raise TypeError("That is not a valid input")
# plt.imshow(self._inputImage, cmap=plt.cm.gray, interpolation="nearest")
# plt.show()
# Calculate gradient and magnitude arrays and then create Blocks for each of them
gx, gy = self._create_gradient_images(self._inputImage)
# Create block objects for each the magnitude and gradient images.
self.gradBlock = Block(self.grad, blockSizeX, blockSizeY, overlap, cellSizeX, cellSizeY)
self.magBlock = Block(self.mag, blockSizeX, blockSizeY, overlap, cellSizeX, cellSizeY)
# Create histogram object - which takes the gradient Block object and the
# magnitude Block object
self.histogram = Histogram(self.gradBlock, self.magBlock, oBins)
self.output = self.histogram.histArray
# Draw an output
self.histogramPlotter = HistogramPlotter(self._inputImage, self.output)
self.histogramPlotter.plot()
def _create_gradient_images(self,pixelArray):
"""Creates gradient images in x and y directions.
Args:
pixelArray: The array of pixels
Returns:
grad: gradient image
mag: gradient in the y direction
"""
# Create the column and row vectors to convolve
ker = np.array([1,0,-1])
column = ker.reshape((3,1))
row = ker.reshape((1,3))
# mode = constant ensures that the edges of the image ar padded with
# constant values in this case the default is 0 - perfect for our purposes.
# The array is then restored to its original dimensions.
# Convolve the vectors to create gradients in x and y directions
#TODO: for colour images: np.array([row, row, row])
gx = ndimage.filters.convolve(pixelArray, row, mode = "constant")
gy = ndimage.filters.convolve(pixelArray, column, mode = "constant")
# Create gradient image using arctan2 (remember its in radians!)
self.grad = np.arctan2(gy,gx)
# The square of each element is just matrix^2 in python
self.mag = np.sqrt(gx**2 + gy**2)
return gx, gy
import numpy as np import matplotlib.pyplot as plt from scipy import ndimage from scipy import misc from HistogramPlotter import HistogramPlotter img = np.zeros((100, 100), dtype=np.uint8) histogram = np.zeros((200, 100, 9), dtype=np.uint8) plotter = HistogramPlotter(img, histogram) plotter.drawLine(50,50,30, 48, 1) plt.imshow(plotter.getOutput(), cmap=plt.cm.gray, interpolation="nearest") plt.show()
