def test_view_as_windows_With_skip():
A = np.arange(20).reshape((5, 4))
B = view_as_windows(A, (2, 2), step=2)
assert_equal(B, [[[[0, 1], [4, 5]], [[2, 3], [6, 7]]], [[[8, 9], [12, 13]], [[10, 11], [14, 15]]]])
C = view_as_windows(A, (2, 2), step=4)
assert_equal(C.shape, (1, 1, 2, 2))
def test_view_as_windows_optimal_step():
A = np.arange(24).reshape((6, 4))
B = view_as_windows(A, (3, 2), optimal_step=True)
assert B.shape == (2, 2, 3, 2)
assert B.size == A.size
A = np.arange(512 * 512).reshape((512, 512))
B = view_as_windows(A, (10, 10), optimal_step=True)
assert B.shape == (56, 56, 10, 10)
assert B.size >= A.size
C = view_as_windows(A, (11, 9), optimal_step=True)
assert C.shape == (51, 63, 11, 9)
assert C.size >= A.size
def perform(self, node, inputs, output_storage):
features, kernel = inputs
strides = self.strides
featshp = features.shape
kshp = kernel.shape
produced_output_sz = (featshp[0], kshp[1], kshp[2] + strides[0] * (featshp[2] - 1), kshp[3] + strides[1] * (featshp[3] - 1))
returned_output_sz = (featshp[0], kshp[1], self.imshp[2], self.imshp[3])
k_rot = kernel[:,:,::-1,::-1]
scipy_output = np.zeros(returned_output_sz,dtype=node.out.dtype)
for im_i in range(featshp[0]):
im_out = np.zeros(produced_output_sz[1:],dtype=node.out.dtype)
im_outr = view_as_windows(im_out,(kshp[1],kshp[2],kshp[3]))[0,::strides[0],::strides[1],...]
im_hatr = np.tensordot(features[im_i,...],k_rot,axes=((0,),(0,)))
for a in range(im_hatr.shape[0]):
for b in range(im_hatr.shape[1]):
im_outr[a,b,...] += im_hatr[a,b,...]
if produced_output_sz[2] <= returned_output_sz[2]:
scipy_output[im_i,:,:im_out.shape[1],:im_out.shape[2]] = im_out
else:
scipy_output[im_i,:,:,:] = im_out[:,:returned_output_sz[2],:returned_output_sz[3]]
#print 'MyCorr, output.shape:', scipy_output.shape, 'strides', strides, 'featshp', featshp, 'kshp', kshp, 'imshp', self.imshp,\
#'produced_output_sz', produced_output_sz, 'returned_output_sz', returned_output_sz, \
#'im_outr.shape', im_outr.shape, 'im_hatr.shape', im_hatr.shape
output_storage[0][0] = scipy_output
def perform(self, node, inputs, output_storage):
image_error, features = inputs
kshp = self.kshp
imshp = image_error.shape
strides = self.strides
# scipy_error_rot = np.transpose(image_error, [1, 0, 2, 3])
# features_rot = np.transpose(features, [1, 0, 2, 3])
#
# feat_expand = np.zeros((features_rot.shape[0],
# features_rot.shape[1],
# image_error.shape[2] - self.kshp[2] + 1,
# image_error.shape[3] - self.kshp[3] + 1), dtype=features.dtype)
# feat_expand[:, :, ::strides[0], ::strides[1]] = features_rot
#
# #scipy_derivative_rot = -scipy_convolve4d(scipy_error_rot[:, :, ::-1, ::-1], feat_expand)
#
# feat_flipped = features_rot[:, :, ::-1, ::-1]
from skimage.util.shape import view_as_windows
image_error_view = view_as_windows(image_error, (imshp[0], kshp[1], kshp[2], kshp[3]))[0,0,::strides[0],::strides[1],...]
# image_error_view.shape = (featszr, featszc, num_im, channels, ksz[2], ksz[3])
# features.shape = (num_im, num_filters, featszr, featszc)
kernel_derivative = - np.tensordot(features,image_error_view, axes=((0, 2, 3), (2, 0, 1)))
# kernel_derivative_temp.shape = (num_filters, channels, ksz[2], ksz[3])
output_storage[0][0] = kernel_derivative[:,:,::-1,::-1]
def get_pooled_features(self, input_feature_map, filter_size=(19,19)):
# assuming square filters and images
filter_side = filter_size[0]
# reshaping incoming features from 2d to 3d i.e. (3249,20) to (57,57,20)
input_feature_map_shape = input_feature_map.shape
if input_feature_map.ndim == 2:
input_feature_map_side = int(np.sqrt(input_feature_map.shape[0]))
input_feature_map = input_feature_map.reshape((input_feature_map_side, input_feature_map_side, input_feature_map_shape[-1]))
assert input_feature_map.ndim == 3, "Input features dimension is %d instead of 3" %input_feature_map.ndim
# get windows (57,57,20) to (3,3,1,19,19,20)
input_feature_map_windows = view_as_windows(input_feature_map,
window_shape=(filter_size[0], filter_size[1], input_feature_map.shape[-1]),
step=filter_size[0])
# reshape windows (3,3,1,19,19,20) to (3**2, 19**2, 20) == (9, 361, 20)
input_feature_map_windows = input_feature_map_windows.reshape((input_feature_map_windows.shape[0]**2,
filter_size[0]**2,
input_feature_map.shape[-1]))
# calculate norms (9, 361, 20) to (9,361)
input_feature_map_window_norms = np.linalg.norm(input_feature_map_windows, ord=2, axis=-1)
# calculate indexes of max norms per window (9,361) to (9,1). One max index per window.
max_norm_indexes = np.argmax(input_feature_map_window_norms, axis=-1)
# max pooled features are the features that have max norm indexes (9, 361, 20) to (9,20). One max index per window.
pooled_features = input_feature_map_windows[np.arange(input_feature_map_windows.shape[0]), max_norm_indexes]
# return pooled feature map
return pooled_features
def stochastic_pooling(self, X, n_layer):
inh = X.shape[0] - self.shape_pool[0] + 1
inw = X.shape[1] - self.shape_pool[1] + 1
n_filter = self.n_filters[n_layer]
filtersize = self.shape_pool[0] * self.shape_pool[1]
randomsamples = random_sample((inh) * (inw) * n_filter).reshape(
(inh), (inw), n_filter
) # generate random values
randomsamples = np.repeat(randomsamples, repeats=filtersize, axis=2).reshape((inh), (inw), n_filter, filtersize)
X_rfi = view_as_windows(X, self.shape_pool + (1,))
sumpool = np.repeat(np.sum(X_rfi, axis=(3, 4, 5)), repeats=filtersize).reshape(
(inh, inw, n_filter, self.shape_pool[0], self.shape_pool[1], 1)
)
probabilities = X_rfi / sumpool
probabilities[np.isnan(probabilities)] = 1 / float(
filtersize
) # get where the sum is zero and replace by one, so the division by zero error do not occur
probabilities = probabilities.reshape((inh, inw, n_filter, filtersize))
if self.training:
bins = np.add.accumulate(probabilities, axis=3)
binsbefore = np.concatenate((np.zeros((inh, inw, n_filter, 1)), bins[:, :, :, :-1]), axis=3)
ret = X_rfi[np.where((((binsbefore <= randomsamples) * (bins > randomsamples))) == True)]
ret = ret.reshape(((inh), (inw), n_filter))[:: self.stride_pool, :: self.stride_pool]
else: # for testing
ret = probabilities * X_rfi
sumpool[sumpool == 0.0] = 1.0
ret = np.sum(ret, axis=(3)) / sumpool[:, :, :, 0, 0, 0]
ret = ret[:: self.stride_pool, :: self.stride_pool]
def lpool4(arr_in, neighborhood,
order=DEFAULT_ORDER,
stride=DEFAULT_STRIDE, arr_out=None):
"""4D Local Pooling Operation
XXX: docstring
"""
assert arr_in.ndim == 4
assert len(neighborhood) == 2
order = np.array([order], dtype=arr_in.dtype)
stride = np.int(stride)
in_imgs, inh, inw, ind = arr_in.shape
nbh, nbw = neighborhood
assert nbh <= inh
assert nbw <= inw
if arr_out is not None:
assert arr_out.dtype == arr_in.dtype
assert arr_out.shape == (in_imgs,
1 + (inh - nbh) / stride,
1 + (inw - nbw) / stride,
ind)
_arr_out = ne.evaluate('arr_in ** order')
_arr_out = view_as_windows(_arr_out, (1, 1, nbw, 1))
_arr_out = ne.evaluate('sum(_arr_out, 6)')[:, :, ::stride, :, 0, 0, 0]
# np.ascontiguousarray(_arr_out) necessary to avoid
# skimage/util/shape.py:237: RuntimeWarning: Cannot provide views on a non-contiguous input array without copying.
# warn(RuntimeWarning("Cannot provide views on a non-contiguous input
_arr_out = np.ascontiguousarray(_arr_out)
_arr_out = view_as_windows(_arr_out, (1, nbh, 1, 1))
_arr_out = ne.evaluate('sum(_arr_out, 5)')[:, ::stride, :, :, 0, 0, 0]
_arr_out = ne.evaluate('_arr_out ** (1 / order)')
if arr_out is not None:
arr_out[:] = _arr_out
else:
arr_out = _arr_out
assert arr_out.shape[0] == in_imgs
assert arr_out.dtype == arr_in.dtype
return arr_out
def similarity3D(self, X, fb):
assert X.ndim == 3
assert fb.ndim == 4
assert X.shape[-1] == fb.shape[2]
Xw = view_as_windows(X, fb.shape[:3])
Xwa = np.abs(Xw - fb)
return Xwa.sum(axis=(3, 4, 5))
def _process_one_op(self, arr, X, Y,
layer_idx, op_idx, kwargs,
op_params,
op_name, nbh, nbw, stride,
pad_apron=False,
interleave_stride=False):
out_l = []
# -- here we compute the pixel coordinates of
# the central pixel in a patch
hc, wc = nbh / 2, nbw / 2
if pad_apron:
arr = filter_pad2d(arr, (nbh, nbw))
X = np.squeeze(filter_pad2d(X[..., np.newaxis], (nbh, nbw),
constant=-1))
Y = np.squeeze(filter_pad2d(Y[..., np.newaxis], (nbh, nbw),
constant=-1))
if interleave_stride:
for i in xrange(stride):
for j in xrange(stride):
arr_out_ij = self._get_feature_map(arr[i::, j::, ...],
layer_idx, op_idx, kwargs,
op_params, op_name)
X_out_ij = view_as_windows(X[i::, j::],
(nbh, nbw))[::stride, ::stride,
hc, wc]
Y_out_ij = view_as_windows(Y[i::, j::],
(nbh, nbw))[::stride, ::stride,
hc, wc]
out_l += [(arr_out_ij, X_out_ij, Y_out_ij)]
else:
arr_out = self._get_feature_map(arr, layer_idx, op_idx, kwargs,
op_params, op_name)
X_out = view_as_windows(X, (nbh, nbw))[::stride, ::stride, hc, wc]
Y_out = view_as_windows(Y, (nbh, nbw))[::stride, ::stride, hc, wc]
out_l += [(arr_out, X_out, Y_out)]
return out_l
def mcconv3(X, W):
X_VAW = view_as_windows(X, W.shape[0:-1])
Y_FPS = X_VAW.shape[0:2]
X_VAW = X_VAW.reshape(Y_FPS[0] * Y_FPS[1], -1)
W = W.reshape(-1, W.shape[-1])
Y = np.dot(X_VAW, W)
Y = Y.reshape(Y_FPS[0], Y_FPS[1], -1)
return Y
def bxfilt2(X, F_SIZ, F_STRD):
for i in reversed(xrange(2)):
W_SIZ = np.ones(np.ndim(X))
S_SIZ = np.ones(2)
W_SIZ[i], S_SIZ[i] = F_SIZ, F_STRD
X = np.squeeze(view_as_windows(X, tuple(W_SIZ)))[::S_SIZ[0], ::S_SIZ[1]] # subsampling before summation
X = np.sum(X, -1)
return X
def lpool4(arr_in, neighborhood,
order=DEFAULT_ORDER,
stride=DEFAULT_STRIDE, arr_out=None):
"""4D Local Pooling Operation
XXX: docstring
"""
assert arr_in.ndim == 4
assert len(neighborhood) == 2
order = np.array([order], dtype=arr_in.dtype)
stride = np.int(stride)
in_imgs, inh, inw, ind = arr_in.shape
nbh, nbw = neighborhood
assert nbh <= inh
assert nbw <= inw
if arr_out is not None:
assert arr_out.dtype == arr_in.dtype
assert arr_out.shape == (in_imgs,
1 + (inh - nbh) / stride,
1 + (inw - nbw) / stride,
ind)
_arr_out = ne.evaluate('arr_in ** order')
_arr_out = view_as_windows(_arr_out, (1, 1, nbw, 1))
_arr_out = ne.evaluate('sum(_arr_out, 6)')[:, :, ::stride, :, 0, 0, 0]
_arr_out = view_as_windows(_arr_out, (1, nbh, 1, 1))
_arr_out = ne.evaluate('sum(_arr_out, 5)')[:, ::stride, :, :, 0, 0, 0]
_arr_out = ne.evaluate('_arr_out ** (1 / order)')
if arr_out is not None:
arr_out[:] = _arr_out
else:
arr_out = _arr_out
assert arr_out.shape[0] == in_imgs
assert arr_out.dtype == arr_in.dtype
return arr_out
def extractPatches(name, patch_shape, dataDir, vector, numberOfPatchesPerImage):
imageName = '{0:s}{1:s}'.format(dataDir, name)
npImage = cv2.imread(imageName)
npImage = np.divide(npImage, vector)
#npImage = cv2.resize(npImage, (65, 65))
patchesSampled = np.empty(shape=(numberOfPatchesPerImage, patch_shape[0] * patch_shape[1], 3))
for derp in range(npImage.shape[2]):
patches = view_as_windows(npImage[:,:,derp], patch_shape)
patches = patches.reshape(-1, patch_shape[0] * patch_shape[1])[::8]
patchesSampled[:,:,derp] = patches[np.random.random_integers(0, patches.shape[0], numberOfPatchesPerImage), :]
return(patchesSampled)
def lpool3(arr_in, neighborhood,
order=DEFAULT_ORDER,
stride=DEFAULT_STRIDE, arr_out=None):
"""3D Local Pooling Operation
XXX: docstring
"""
assert arr_in.ndim == 3
assert len(neighborhood) == 2
order = np.array([order], dtype=arr_in.dtype)
stride = np.int(stride)
inh, inw, ind = arr_in.shape
nbh, nbw = neighborhood
assert nbh <= inh
assert nbw <= inw
if arr_out is not None:
assert arr_out.dtype == arr_in.dtype
assert arr_out.shape == (1 + (inh - nbh) / stride,
1 + (inw - nbw) / stride,
ind)
_arr_out = ne.evaluate('arr_in ** order')
_arr_out = view_as_windows(_arr_out, (1, nbw, 1))
_arr_out = ne.evaluate('sum(_arr_out, 4)')[:, ::stride, :, 0, 0]
_arr_out = view_as_windows(_arr_out, (nbh, 1, 1))
_arr_out = ne.evaluate('sum(_arr_out, 3)')[::stride, :, :, 0, 0]
# Note that you need to use '1' and not '1.0' so that the dtype of
# the exponent does not change (i.e. get promoted)
_arr_out = ne.evaluate('_arr_out ** (1 / order)')
if arr_out is not None:
arr_out[:] = _arr_out
else:
arr_out = _arr_out
assert arr_out.dtype == arr_in.dtype
return arr_out
def test_view_as_windows_1D():
A = np.arange(10)
window_shape = (3,)
B = view_as_windows(A, window_shape)
assert_equal(B, np.array([[0, 1, 2],
[1, 2, 3],
[2, 3, 4],
[3, 4, 5],
[4, 5, 6],
[5, 6, 7],
[6, 7, 8],
[7, 8, 9]]))
def test_view_as_windows_step_tuple():
A = np.arange(24).reshape((6, 4))
B = view_as_windows(A, (3, 2), step=3)
assert B.shape == (2, 1, 3, 2)
assert B.size != A.size
C = view_as_windows(A, (3, 2), step=(3, 2))
assert C.shape == (2, 2, 3, 2)
assert C.size == A.size
assert_equal(C, [[[[0, 1],
[4, 5],
[8, 9]],
[[2, 3],
[6, 7],
[10, 11]]],
[[[12, 13],
[16, 17],
[20, 21]],
[[14, 15],
[18, 19],
[22, 23]]]])
def conv3D(self, X, fb):
assert X.ndim == 3
assert fb.ndim == 4
assert X.shape[-1] == fb.shape[2]
n_filters = fb.shape[-1]
fb2 = fb.copy()
fb2.shape = -1, n_filters
X_rfi = view_as_windows(X, fb.shape[:3])
outh, outw = X_rfi.shape[:2]
X_rfim = X_rfi.reshape(outh * outw, -1)
ret = np.dot(X_rfim, fb2) # -- convolution as matrix multiplication
return ret.reshape(outh, outw, n_filters)
def gen_neg_examples(self):
"""
Generates negative training patches
from the dataset specified in the configuration
"""
negfiles = os.listdir(self.negdatadir)
negpatches = []
for n in negfiles[:10]:
f = self.negdatadir + "/" + n
if "jpg" not in f:
continue
print "Processing image" + f
im = cv2.imread(f)
# gray = self.rgb2gray(im)
gray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
# im =cv2.cvtColor(im,cv2.COLOR_BGR2GRAY)
# Generate the negative patch
# patch = image.extract_patches_2d(im, (256, 256)) # This generalates nultiple patches
print np.shape(im)
patch = view_as_windows(gray, (64, 64), 65)
print np.shape(patch)
# patch = [cv2.resize(x,(64,64)) for x in patch]
# randomly choose 20 patches from all patches for this image
fdimlen = np.shape(patch)[0]
sdimlen = np.shape(patch)[1]
patches = []
# for i in range(len(self.trainpatches)):
for i in range(8): # we are getting too many negative examples, so reducing to 5
randomdim = random.choice(range(fdimlen))
randomsdim = random.choice(range(sdimlen))
# randompatch = patch[randomdim][randomsdim][0] # if color un comment this
randompatch = patch[randomdim][randomsdim]
# randompatch = cv2.resize(randompatch, (64,64))
patches.append(randompatch)
negpatches += patches
self.negpatches = negpatches
def montage_wb_ratio (input_image, patch_shape, n_filters, ele_print = False):
from skimage.util.shape import view_as_windows
from skimage.util.montage import montage2d
from scipy.cluster.vq import kmeans2
patches = view_as_windows(gray_crab, patch_shape)
patches = patches.reshape(-1, patch_shape[0] * patch_shape[1])[::8]
fb, _ = kmeans2(patches, n_filters, minit='points')
fb = fb.reshape((-1,) + patch_shape)
fb_montage = montage2d(fb, fill=False, rescale_intensity=True)
elements = np.split(np.hstack(np.split(fb_montage, 4)), 16, axis=1)
del elements[n_filters:]
wb_ratios = []
bin_elements = []
for element in elements:
thresh = threshold_otsu(element)
binary = element > thresh
ratio = np.sum(binary) / binary.size
wb_ratios.append(ratio)
if ele_print:
bin_elements.append(binary)
wb_ratios = sorted(wb_ratios, reverse = True)
if ele_print:
show_images(elements)
show_images(bin_elements)
return(wb_ratios)
def test_view_as_windows_2D():
A = np.arange(5 * 4).reshape(5, 4)
window_shape = (4, 3)
B = view_as_windows(A, window_shape)
assert_equal(B.shape, (2, 2, 4, 3))
assert_equal(
B,
np.array(
[
[[[0, 1, 2], [4, 5, 6], [8, 9, 10], [12, 13, 14]], [[1, 2, 3], [5, 6, 7], [9, 10, 11], [13, 14, 15]]],
[
[[4, 5, 6], [8, 9, 10], [12, 13, 14], [16, 17, 18]],
[[5, 6, 7], [9, 10, 11], [13, 14, 15], [17, 18, 19]],
],
]
),
)
def scipy_correlate4d_view(features,kernel,stride=1):
#imshp = (3,2,20,20) # num images, channels, szy, szx
#kshp = (10,2,10,10) # features, channels, szy, szx
#featshp = (3,10,11,11) # num images, features, szy, szx
from skimage.util.shape import view_as_windows
featshp = features.shape
kshp = kernel.shape
output_sz = (featshp[0], kshp[1], kshp[2] + stride*featshp[2] - 1, kshp[3] + stride*featshp[3] - 1)
k_rot = kernel[:,:,::-1,::-1]
scipy_output = np.zeros(output_sz)
for im_i in range(featshp[0]):
im_out = np.zeros(output_sz[1:])
im_outr = view_as_windows(im_out,(kshp[1],kshp[2],kshp[3]))[0,::stride,::stride,...]
im_hatr = np.tensordot(np.squeeze(features[im_i,...]),k_rot,axes=((0,),(0,)))
#import IPython; ipshell = IPython.embed; ipshell(banner1='ipshell')
# for a in range(im_hatr.shape[0]):
# im_outr[a,:,...] += im_hatr[a,:,...]
for a in range(im_hatr.shape[0]):
for b in range(im_hatr.shape[1]):
im_outr[a,b,...] += im_hatr[a,b,...]
# for d in range(im_hatr.shape[3]):
# for e in range(im_hatr.shape[4]):
# im_outr[:,:,:,d,e] += im_hatr[:,:,:,d,e]
# for c in range(im_hatr.shape[2]):
# for d in range(im_hatr.shape[3]):
# for e in range(im_hatr.shape[4]):
# im_outr[a,b,c,d,e] += im_hatr[a,b,c,d,e]
# im_outr += im_hatr
scipy_output[im_i,...] = im_out
return scipy_output
def fbcorr4(arr_in, arr_fb, stride=DEFAULT_STRIDE, arr_out=None):
"""4D Filterbank Correlation
XXX: docstring
"""
assert arr_in.ndim == 4
assert arr_fb.ndim == 4
assert arr_fb.dtype == arr_in.dtype
in_imgs, inh, inw, ind = arr_in.shape
fbh, fbw, fbd, fbn = arr_fb.shape
f_size = fbh * fbw * fbd
assert fbn > 1
assert fbh <= inh
assert fbw <= inw
assert fbd == ind
if arr_out is not None:
assert arr_out.dtype == arr_in.dtype
assert arr_out.shape == (in_imgs,
1 + (inh - fbh) / stride,
1 + (inw - fbw) / stride,
fbn)
# -- reshape arr_in
arr_inr = view_as_windows(arr_in, (1, fbh, fbw, fbd))[::stride, ::stride]
n_imgs, outh, outw = arr_inr.shape[:3]
assert n_imgs == in_imgs
arr_inrm = arr_inr.reshape(n_imgs * outh * outw, f_size)
# -- reshape arr_fb
arr_fbm = arr_fb.reshape((f_size, fbn))
# -- correlate!
arr_out = np.dot(arr_inrm, arr_fbm)
arr_out = arr_out.reshape(n_imgs, outh, outw, -1)
return arr_out
def divisive_normalization(self, X, filter_norm):
# -- pre nonlinearities
rf_shape_side = (np.asarray(filter_norm.shape) - 1) / 2
if len(X.shape) == 2:
X.shape = X.shape + (1,)
inh, inw, _ = X.shape
ret = X ** 2
# ret = self.conv3D(ret, filter_norm)
X_rfi = view_as_windows(X, filter_norm.shape[:3])
ret = X_rfi.sum(axis=(2, 3, 4))
# -- post nonlinearities
ret = np.sqrt(ret)
np.maximum(ret, 1.0, ret) # avoids that very small numbers will cause the nominator have an greater value
return X[rf_shape_side[0] : inh - rf_shape_side[0], rf_shape_side[1] : inw - rf_shape_side[1], :] / ret
def convolve4d_view(image,kernel,mode='valid',stride=(1,1)):
from skimage.util.shape import view_as_windows
imshp = image.shape
kshp = kernel.shape
offset = None
if mode=='valid':
featshp = (imshp[0],kshp[0],(imshp[2] - kshp[2])/stride[0] + 1,(imshp[3] - kshp[3])/stride[1] + 1) # num images, features, szy, szx
elif mode == 'same':
assert stride == (1,1)
featshp = (imshp[0],kshp[0],imshp[2],imshp[3]) # num images, features, szy, szx
offset = (kshp[2]/2, kshp[3]/2)
#elif mode == 'full':
# assert stride == (1,1)
# featshp = (imshp[0],kshp[0],imshp[2] + kshp[2] - 1,imshp[3] + kshp[3] - 1) # num images, features, szy, szx
else:
raise NotImplemented, 'Unkonwn mode %s'%mode
kernel_flipped = kernel[:,:,::-1,::-1]
output = np.zeros(featshp)
this_image = None
for im_i in range(imshp[0]):
if mode == 'valid':
this_image = image[im_i,...]
elif mode == 'same':
if this_image is None:
this_image_shp = (imshp[1], imshp[2] + kshp[2] - 1, imshp[3] + kshp[3] - 1)
this_image = np.zeros(this_image_shp,dtype=image.dtype)
this_image[:,offset[0]:(offset[0]+imshp[2]),offset[1]:(offset[1]+imshp[3])] = image[im_i,...]
else:
raise NotImplemented
imager = view_as_windows(this_image,(kshp[1],kshp[2],kshp[3]))[0,::stride[0],::stride[1],...]
# imager.shape = (featszr, featszc, channels, ksz[2], ksz[3])
feat = np.tensordot(kernel_flipped,imager,axes=((1,2,3),(2,3,4)))
output[im_i,...] = feat
return output
def split_into_patches(self,
channel=None,
patch_shape=(256, 256, 3),
overlap=0):
"""
Split an MxNxC image (where C is the number of channels) into patches.
Inputs:
- channel: Image channel as indicated by.
- patch_shape: .
:param patch_shape:
:param channel:
"""
# TODO: determine whether patch all channels at once, or individual channels
# Note: use skimage.util.shape.view_as_windows()
# Stride = shape[0] - overlap
# or if you want overlap in both x and y dimens stride = patch_shape - overlap
# where type(stride)==type(patch_shape)==type(overlap) == tuple of length n dimensions\
# overlap cannot be larger than patch_shape - 1 nor small
# USING view_as_windows(image, patch_shape, step)
# for and MxNx3 image, I want each patch to tilesize x tilesize x 3 patch (3D) patch
# so patch_shape=(tilesize, tilesize, 3)
# for nonoverlapping patches, our step in dims 0 and 1 should be the same as tilesize
# so, step(tilesize, tilesize, 1)
# TODO: LOTS OF ERROR CHECKING!!
if channel:
im = self.images[channel]
else:
im = self.images[Strings.IF]
if patch_shape != im.shape:
patch_shape = (256, 256, im.shape[2])
step = tuple((patch_shape[0] - overlap, patch_shape[1] - overlap, 1))
self.patches = shape.view_as_windows(im, patch_shape, step)
def fbcorr3(arr_in, arr_fb, stride=DEFAULT_STRIDE, arr_out=None):
"""3D Filterbank Correlation
XXX: docstring
"""
assert arr_in.ndim == 3
assert arr_fb.ndim == 4
assert arr_fb.dtype == arr_in.dtype
inh, inw, ind = arr_in.shape
fbh, fbw, fbd, fbn = arr_fb.shape
assert fbn > 1
assert fbh <= inh
assert fbw <= inw
assert fbd == ind
if arr_out is not None:
assert arr_out.dtype == arr_in.dtype
assert arr_out.shape == (1 + (inh - fbh) / stride,
1 + (inw - fbw) / stride,
fbn)
# -- reshape arr_in
arr_inr = view_as_windows(arr_in, (fbh, fbw, fbd))[::stride, ::stride]
outh, outw = arr_inr.shape[:2]
arr_inrm = arr_inr.reshape(outh * outw, -1)
# -- reshape arr_fb
arr_fbm = arr_fb.reshape((fbh * fbw * fbd, fbn))
# -- correlate !
arr_out = np.dot(arr_inrm, arr_fbm)
arr_out = arr_out.reshape(outh, outw, -1)
assert arr_out.dtype == arr_in.dtype # XXX: should go away
return arr_out
def extract_non_faces(output_size):
file_name = "{}_{}_non_faces".format(*(output_size))
new_dir_name = os.path.join(image_save_path, file_name)
i = 0
if not os.path.exists(new_dir_name):
os.makedirs(new_dir_name)
file_paths = []
for path, subdirs, files in os.walk(image_path):
for name in files:
if not fnmatch(name, face_dir_pattern):
file_paths.append(os.path.join(path, name))
window_shape = (32, 32)
for file_path in file_paths:
image = io.imread(file_path)
if len(image.shape) < 3:
continue
if image.shape[2] == 1:
continue
windows = view_as_windows(image, window_shape)
for window in windows:
save_file_string = os.path.join(new_dir_name, "{0:06d}".format(i) + ".jpg")
im = resize(window, output_size)
io.imsave(save_file_string, im)
i += 1
def main():
# global scale_factor
# global TPB
# global dim
# parser = argparse.ArgumentParser(description='GPU Pathfinding')
# parser.add_argument('scale_factor', type=int, help='Scale factor (power of 2)')
# parser.add_argument('TPB', type=int, help='Block width')
# args = parser.parse_args()
# scale_factor = args.scale_factor
# TPB = args.TPB
# dim = int(math.pow(2, scale_factor)), int(math.pow(2, scale_factor))
width, height = dim
print('----- Preparing Grid -----')
# create grid from image dataset
# grid = np.zeros(dim, dtype=np.int32)
# createGridFromDatasetImage('dataset/da2-png', grid, dim)
grid = np.ones(dim, dtype=np.int32)
# generate random start and goal
# start = [-1, -1]
# goal = [-1, -1]
# randomStartGoal(grid, start, goal)
start = [0, 0]
goal = [grid.shape[0] - 1, grid.shape[1] - 1]
start = np.array(start)
goal = np.array(goal)
# debugging purposes: use guide for 1D mapping of indexes
guide = np.arange(dim[0] * dim[1]).reshape(dim).astype(np.int32)
# initialize essential arrays for search algorithm
print('----- Initializing Variables -----')
H_goal = np.empty(dim, dtype=np.int32)
H_goal[:] = UNEXPLORED
H_start = np.empty(dim, dtype=np.int32)
H_start[:] = UNEXPLORED
# compute heuristics towards start and goal
threadsperblock = (TPB, TPB)
blockspergrid_x = math.ceil(grid.shape[0] / threadsperblock[0])
blockspergrid_y = math.ceil(grid.shape[1] / threadsperblock[1])
blockspergrid = (blockspergrid_x, blockspergrid_y)
print('THREADS PER BLOCK: ', threadsperblock)
print('BLOCKS PER GRID: ', blockspergrid)
print('----- Computing Heuristics -----')
computeHeuristics[blockspergrid, threadsperblock](grid, start, goal,
H_start, H_goal)
print(blockspergrid)
# prepare grid blocking guide
block = np.zeros(dim, dtype=np.int32)
block = blockshaped(block, TPB, TPB)
for i in range(block.shape[0]):
block[i, :] = i
block = unblockshaped(block, width, height)
# prepare padded grid, guide, H_goal
padded_grid = np.zeros((width + 2, height + 2), dtype=np.int32)
padded_guide = np.empty((width + 2, height + 2), dtype=np.int32)
padded_guide[:] = -1
padded_block = np.empty((width + 2, height + 2), dtype=np.int32)
padded_block[:] = -1
padded_H_goal = np.empty((width + 2, height + 2), dtype=np.int32)
padded_H_goal[:] = UNEXPLORED
padGrid[blockspergrid, threadsperblock](grid, padded_grid)
padGrid[blockspergrid, threadsperblock](guide, padded_guide)
padGrid[blockspergrid, threadsperblock](block, padded_block)
padGrid[blockspergrid, threadsperblock](H_goal, padded_H_goal)
# print(padded_grid)
# print(padded_guide)
# print(padded_H_goal)
# prepare local grids
grid_blocks = view_as_windows(padded_grid, (TPB + 2, TPB + 2), step=TPB)
grid_blocks = grid_blocks.reshape(
grid_blocks.shape[0] * grid_blocks.shape[1], grid_blocks.shape[2],
grid_blocks.shape[3])
guide_blocks = view_as_windows(padded_guide, (TPB + 2, TPB + 2), step=TPB)
guide_blocks = guide_blocks.reshape(
guide_blocks.shape[0] * guide_blocks.shape[1], guide_blocks.shape[2],
guide_blocks.shape[3])
H_goal_blocks = view_as_windows(padded_H_goal, (TPB + 2, TPB + 2),
step=TPB)
H_goal_blocks = H_goal_blocks.reshape(
H_goal_blocks.shape[0] * H_goal_blocks.shape[1],
H_goal_blocks.shape[2], H_goal_blocks.shape[3])
blocks = view_as_windows(padded_block, (TPB + 2, TPB + 2), step=TPB)
blocks = blocks.reshape(blocks.shape[0] * blocks.shape[1], blocks.shape[2],
blocks.shape[3])
# print(grid_blocks.shape)
print('Start: ', start)
print('Goal: ', goal)
print('Grid')
print(grid)
print('Grid Index Guide: ')
print(guide)
# print('Start H: ')
# print(H_start)
print('Goal H: ')
print(H_goal)
# print('Grid Blocking:')
# print(block)
# print('Padded Grid Blocks:')
# print(grid_blocks)
# print('Padded Guide Blocks:')
# print(guide_blocks)
# print('Padded Goal H Blocks:')
# print(H_goal_blocks)
# print('Padded Block Blocks:')
# print(blocks)
# parents array contains info where tiles came from
parents = np.empty((width, height, TPB + 2, TPB + 2), np.int32)
parents[:] = -1
established_goal = np.zeros(dim, np.int32)
established_local_goal = np.zeros(dim, np.int32)
# print(parents)
# Simultaneous local search
print('----- Simulataneously Searching for SubPaths -----')
x, y = start
# x, y = goal
s = timer()
counter = np.zeros(dim, np.int32)
# GridDecompSearch[blockspergrid, threadsperblock](grid, start, goal, H_goal, block, parents, grid_blocks, guide_blocks, H_goal_blocks, blocks)
GridDecompSearch[blockspergrid,
threadsperblock](grid, H_goal, block, grid_blocks, start,
goal, parents, H_goal_blocks,
guide_blocks, blocks, counter,
established_goal, established_local_goal)
# print(parents)
# print(counter)
print(grid_blocks[block[x, y]])
print(guide_blocks[block[x, y]])
print(H_goal_blocks[block[x, y]])
print(parents[x, y])
print(guide)
print(H_goal)
print(established_goal)
print(established_local_goal)
e = timer()
print('kernel launch (+ compilation) done in ', e - s, 's')
# time_ave = 0
# runs = 10
# for run in range(runs):
# counter[:] = 0
# s = timer()
# GridDecompSearch[blockspergrid, threadsperblock](grid, H_goal, block, grid_blocks, start, goal, parents, H_goal_blocks, guide_blocks, blocks, counter)
# print(counter)
# e = timer()
# time_ave += (e-s)
# print('%dth kernel launch done in ' %(run), e-s, 's')
# time_ave = time_ave/runs
# print('Average runtime in ', runs, ' runs: ', time_ave)
# trying to recreate path
print('----- Reconstructing Path -----')
start_1d_index = start[0] * width + start[1]
goal_1d_index = goal[0] * width + goal[1]
current_index = start_1d_index
print('START IN 1D: ', start_1d_index)
print('GOAL IN 1D: ', goal_1d_index)
path = []
ctr = 0
while current_index != goal_1d_index:
if ctr > width * 2: # just in case there is infinite loop
print('Timeout!')
break
path.append(current_index)
# calculate 2D index from 1D
current_x = int((current_index - (current_index % width)) / width)
current_y = current_index % width
# get the established goal using 2D index
# set current index to established goal (1D) index
current_index = established_goal[current_x, current_y]
ctr += 1
current_x = int((current_index - (current_index % width)) / width)
current_y = current_index % width
current_index = established_goal[current_x, current_y]
path.append(current_index)
print('paths connecting blocks: ', path)
print('----- Reconstructing Subpaths -----')
subpaths = []
for start_index in path:
start_x = int((start_index - (start_index % width)) / width)
start_y = start_index % width
start_block = block[start_x, start_y]
subpath = []
print()
print('BLOCK: ', start_block, 'LOCAL GOAL: ',
established_local_goal[start_x, start_y])
reconstructPathV3(parents[start_x, start_y], guide_blocks[start_block],
established_local_goal[start_x, start_y], subpath)
print('start: ', start_index, 'subpath: ', subpath)
subpaths = subpaths + subpath
print('full path: (w/ duplicates) ', subpaths)
def extract_patches_Step(image, patch_size, step_patches=24):
i_h, i_w = image.shape[:2]
p_h, p_w = patch_size
if p_h > i_h:
raise ValueError("Height of the patch should be less than the height"
" of the image.")
if p_w > i_w:
raise ValueError("Width of the patch should be less than the width"
" of the image.")
print("PATCH SIZE")
print(patch_size)
cnt = 0
cnt_h = 0
cnt_w = 0
patches = []
border_crop = 2
#new_patch= np.zeros( (p_h,p_w,3))
for w in range(i_w - p_w):
if w == 0 or w % step_patches == 0:
if w == 0:
crop_w = 0
else:
crop_w = 0
cnt_h = 0
for h in range(i_h - p_h):
if h == 0 or h % step_patches == 0:
if h == 0:
crop_h = 0
else:
crop_h = 0
#patchul=image[h:h + p_h, w:w + p_w]
patchul = image[h - crop_h:h + p_h + crop_h,
w - crop_w:w + p_w + crop_w]
#patches[cnt]=patchul
patches.append(patchul)
#imgmap[cnt_h,cnt_w]=cnt
#print("Number of patches = %d, Patch Shape h w= (%d, %d)" % (cnt, patchul.shape[0], patchul.shape[1]))
cnt += 1
cnt_h += 1
cnt_w += 1
print(cnt_h)
i = 0
out_patch = np.zeros((cnt, p_h, p_w, 3))
for p in patches:
out_patch[i] = p
i += 1
#return patches , (cnt_h,cnt_w)
#return
#Rebuild part
cnt_bild = 0
#imgageRebuild = np.zeros( (i_h+p_h,i_w+p_w,3))
imgageRebuild = np.zeros((i_h, i_w, 3))
for w in range(cnt_w):
for h in range(cnt_h):
a = imgageRebuild[h * step_patches:h * step_patches + p_h,
w * step_patches:w * step_patches + p_w]
#print("pozitie h w of patches = (%d, %d) , Patch Shape h w= (%d, %d)" % (h*step_patches ,w*step_patches , a.shape[0], a.shape[1]))
print(a.shape)
print(cnt_bild)
imgageRebuild[h * step_patches:h * step_patches + p_h,
w * step_patches:w * step_patches +
p_w] = out_patch[cnt_bild]
cnt_bild += 1
imsave('/home/www/imgsuper/val_images/test.png', imgageRebuild)
return out_patch, (cnt_h, cnt_w)
#B = view_as_windows(image, window_shape)
image = image.reshape((i_h, i_w, -1))
n_colors = image.shape[-1]
patch_shape = (p_h, p_w, n_colors)
print(image.ndim)
print(image.shape)
B = view_as_windows(image, patch_shape, step_patches)
print(B.shape)
patches = B.reshape(-1, p_h, p_w, n_colors)
print('----')
print(patches.shape)
return patches
def get_features(image_list, n_words=256, learn_ratio=50):
# This for loop passes the window "patch_shape" to extract individual 8x8x3
# patches all along the tiles.
# The extracted patches are used to fit the kmeans classifier
features = []
image_list_path = os.path.dirname(image_list[0])
image_list_path = os.path.dirname(image_list_path)
print('Extracting feature from images in '.format(image_list_path))
inertia = []
pdab_list = []
ph_list = []
patch_shape = (8, 8)
print('****')
print('Step 0: Sliding window')
start = time.time()
# Fits k-means in 1/50 of the images
for i in tqdm(range(0, len(image_list), learn_ratio)):
with Image.open(image_list[i]) as image:
image = numpy.asarray(rgb2hed(image))
if (image.shape[0] == image.shape[1]):
im_dab = image[:, :, 2]
im_h = image[:, :, 0]
im_dab = preprocess_input(im_dab)
im_h = preprocess_input(im_h)
im_dab = im_dab.astype(float)
im_h = im_h.astype(float)
p_dab = view_as_windows(im_dab, patch_shape)
p_h = view_as_windows(im_h, patch_shape)
p_dab = get_patch_reshaped(p_dab, patch_shape)
p_h = get_patch_reshaped(p_h, patch_shape)
pdab_list.extend(p_dab)
ph_list.extend(p_h)
end = time.time()
print('Total time Sliding Window: {:.4f} s'.format(end - start))
print()
print('****')
print('Step 1: KMeans fitting (MiniBatchKMeans)')
start = time.time()
kmeans_dab = MiniBatchKMeans(n_clusters=n_words)
kmeans_h = MiniBatchKMeans(n_clusters=n_words)
kmeans_dab.fit(p_dab_list)
kmeans_h.fit(p_h_list)
end = time.time()
print('Inertia DAB: {}'.format(kmeans_dab.inertia_))
print('Inertia H: {}'.format(kmeans_h.inertia_))
print()
print('Total time MiniBatchKMeans fitting: {:.4f} s'.format(end - start))
print()
print('****')
print('Step 1: KMeans fitting (KMeansTF)')
start = time.time()
kmeanstf_dab = KMeansTF(n_clusters=n_words)
kmeanstf_h = KMeansTF(n_clusters=n_words)
kmeanstf_dab.fit(p_dab_list)
kmeanstf_h.fit(p_h_list)
end = time.time()
print('Inertia DAB: {}'.format(kmeanstf_dab.inertia_))
print('Inertia H: {}'.format(kmeanstf_h.inertia_))
print()
print('Total time KMeansTF fitting: {:.4f} s'.format(end - start))
print()
# Generate the filter set for the convolution layer
kernel_in = []
k_shape = (8, 8, 1)
for i in range(k_shape[0]):
for j in range(k_shape[1]):
k = numpy.zeros(k_shape)
k[i, j, :] = 1
kernel_in.append(k)
kernel_in = numpy.asarray(kernel_in)
kernel_in = kernel_in.reshape(
(k_shape[0], k_shape[1], k_shape[2], k_shape[0] * k_shape[1]))
kernel_in = tf.constant(kernel_in, dtype=tf.float32)
inertia = []
pdab_list = []
ph_list = []
patch_shape = (8, 8)
print('****')
print('Step 0: Tensorflow Conv2D')
start = time.time()
# Fits k-means in 1/50 of the images
for i in tqdm(range(0, len(image_list), learn_ratio)):
with Image.open(image_list[i]) as image:
image = numpy.asarray(rgb2hed(image))
if (image.shape[0] == image.shape[1]):
im_dab = image[:, :, 2]
im_h = image[:, :, 0]
im_dab = preprocess_input(im_dab)
im_h = preprocess_input(im_h)
im_dab = im_dab.astype(float)
im_h = im_h.astype(float)
im_dab = im_dab.reshape(1, 224, 224, 1)
im_h = im_h.reshape(1, 224, 224, 1)
im_dab = tf.constant(im_dab, dtype=tf.float32)
im_h = tf.constant(im_h, dtype=tf.float32)
p_dab = tf.nn.conv2d(input=im_dab,
filters=kernel_in,
strides=1,
padding='SAME')
p_h = tf.nn.conv2d(input=im_h,
filters=kernel_in,
strides=1,
padding='SAME')
shape = p_dab.numpy().shape
pdab_list.extend(p_dab.numpy().reshape(
shape[0] * shape[1] * shape[2], shape[3]))
ph_list.extend(p_h.numpy().reshape(
shape[0] * shape[1] * shape[2], shape[3]))
end = time.time()
print('Total time Tensorflow Conv2D: {:.4f} s'.format(end - start))
print()
inertia = []
pdab_list = []
ph_list = []
patch_shape = (8, 8)
print('****')
print('Step 0: Tensorflow ExtractPatches')
start = time.time()
# Fits k-means in 1/50 of the images
for i in tqdm(range(0, len(image_list), learn_ratio)):
with Image.open(image_list[i]) as image:
image = numpy.asarray(rgb2hed(image))
if (image.shape[0] == image.shape[1]):
im_dab = image[:, :, 2]
im_h = image[:, :, 0]
im_dab = preprocess_input(im_dab)
im_h = preprocess_input(im_h)
im_dab = im_dab.astype(float)
im_h = im_h.astype(float)
im_dab = im_dab.reshape(1, 224, 224, 1)
im_h = im_h.reshape(1, 224, 224, 1)
im_dab = tf.constant(im_dab, dtype=tf.float32)
im_h = tf.constant(im_h, dtype=tf.float32)
p_dab = tf.image.extract_patches(
im_dab,
sizes=[1, k_shape[0], k_shape[1], 1],
strides=[1, 1, 1, 1],
rates=[1, 1, 1, 1],
padding='VALID')
p_h = tf.image.extract_patches(
im_h,
sizes=[1, k_shape[0], k_shape[1], 1],
strides=[1, 1, 1, 1],
rates=[1, 1, 1, 1],
padding='VALID')
shape = p_dab.numpy().shape
pdab_list.extend(p_dab.numpy().reshape(
shape[0] * shape[1] * shape[2], shape[3]))
ph_list.extend(p_h.numpy().reshape(
shape[0] * shape[1] * shape[2], shape[3]))
end = time.time()
print('Total time Tensorflow ExtractPatches: {:.4f} s'.format(end - start))
print()
return features, kmeans_dab, kmeans_h, kmeanstf_dab, kmeanstf_h
def max_pooling(self, X, n_layer):
X_rfi = view_as_windows(X, self.filters_pooling[n_layer].shape + (1, ))
X_rfi = X_rfi[::self.stride_pool[n_layer][0], ::self.
stride_pool[n_layer][1], :, :, :, :]
return np.amax(X_rfi, axis=(3, 4, 5))
def prepare(self, image_left, image_right, window_size):
window_shape = (window_size, window_size)
self.window_size = window_size
self.windows_left = view_as_windows(image_left, window_shape)
self.windows_right = view_as_windows(image_right, window_shape)
def pred_ICIAR_test(model_name):
# get test images
test_images_dir = "/global/home/hpc4535/CISC881FinalProject/ICIAR2018_BACH_Challenge_TestDataset/Photos/"
test_images_fnames = os.listdir(test_images_dir)
test_images_fnames.sort(key=lambda f: int("".join(filter(str.isdigit, f))))
# load model
pred_datagen = ImageDataGenerator(rescale=1. / 255)
model_dir = "/global/home/hpc4535/CISC881FinalProject/ICIAR2018classification/4_CNN9layerModel_patches/outputs/"
model = load_model(os.path.join(model_dir, (model_name + ".h5")))
# predict test images by patches
all_images_path = test_images_dir
pred_label_list = []
pred_conf_list = []
for case in range(len(test_images_fnames)):
# print("test #%s label = %d" % (case, test_labels_shuffled[case]))
# print("test #%s fname = %s" % (case, test_images_fnames[case]))
img_BGR = cv2.imread(
os.path.join(all_images_path, test_images_fnames[case]))
print("%s.shape: %s" % (test_images_fnames[case], img_BGR.shape))
window_shape = (1400, 1400)
step = 100
img_patches_B = view_as_windows(img_BGR[:, :, 0],
window_shape,
step=step)
img_patches_G = view_as_windows(img_BGR[:, :, 1],
window_shape,
step=step)
img_patches_R = view_as_windows(img_BGR[:, :, 2],
window_shape,
step=step)
################################################################
# get bkgd and non-bkgd patches
non_bkgd_patches = []
bkgd_patches = []
resize = 300
for i in range(img_patches_B.shape[0]):
for j in range(img_patches_B.shape[1]):
img_patch = np.dstack(
(img_patches_B[i, j], img_patches_G[i,
j], img_patches_R[i,
j]))
img_patch = cv2.resize(img_patch, (resize, resize),
interpolation=cv2.INTER_AREA)
thresh = 200
img_patch_thresh = cv2.threshold(img_patch, thresh, 255,
cv2.THRESH_BINARY)[1]
white_thresh = 254
nwhite_total = img_patch_thresh.shape[
0] * img_patch_thresh.shape[1]
nwhite = 0
for p in range(img_patch_thresh.shape[0]):
for q in range(img_patch_thresh.shape[1]):
if all(pixel > white_thresh
for pixel in list(img_patch_thresh[p, q, :])):
nwhite += 1
# all_patches.append(img_patch)
bkgd_thresh = 0.7
if nwhite / nwhite_total < bkgd_thresh:
non_bkgd_patches.append(img_patch)
else:
bkgd_patches.append(img_patch)
non_bkgd_patches_arr = np.array(non_bkgd_patches)
print("case", test_images_fnames[case],
"non_bkgd_patches_arr.shape = ", non_bkgd_patches_arr.shape)
################################################################
# make prediction of patches
print("predicting patches for case: ", test_images_fnames[case])
pred = model.predict(pred_datagen.flow(non_bkgd_patches_arr))
################################################################
# get prediction labels
pred_argmax = np.array([np.argmax(p) for p in pred])
pred_dict = {}
for i in range(4):
pred_dict[i] = np.count_nonzero(pred_argmax == i)
photo_wide_label = max(pred_dict.items(),
key=operator.itemgetter(1))[0]
pred_label_list.append(photo_wide_label)
pred_conf = max(pred_dict.values()) / non_bkgd_patches_arr.shape[0]
pred_conf_list.append(pred_conf)
print("%spredicted label = %d" %
(test_images_fnames[case], photo_wide_label))
print("%spred_confidence = %.1f" %
(test_images_fnames[case], pred_conf))
print("\n")
# write prediction csv
test_images_fnames_num = [
int("".join(filter(str.isdigit, f))) for f in test_images_fnames
]
zippedList = list(zip(test_images_fnames_num, pred_label_list))
prediction_df = pd.DataFrame(zippedList, columns=["case", "class"])
prediction_df.to_csv("./pred.csv", index=False)
def test_view_as_windows_input_not_array():
A = [1, 2, 3, 4, 5]
view_as_windows(A, (2, ))
user_to_zip = loadFile[1:, 1].astype('int')
num_users_per_grp = 2000
# getting the number of days for each month
month_end_dates = (dates[dates.is_month_end])[::24]
numberDaysMonth = np.array(month_end_dates.day)
# For the case that the last day of the data is not the last day of the month,
# for example: if data has 8760 time stamps and it is leap year, then last day is 7/30
if month_end_dates[-1].month != dates[-1].month:
numberDaysMonth = np.concatenate(
[numberDaysMonth, (np.array([dates[-1].day]))])
sizeFrameMonth = 3 # 3 months train and one extra for test
# Generate 2D arrays representing each training months (Last one does not have test data)
xMonths = view_as_windows(np.arange(numberDaysMonth.size),
(sizeFrameMonth, ))
# Iterate 59 groups
for group_idx in xrange(1, 60):
print 'Starting group ', group_idx
# Read load file for one group
loadPath = data_dir + '/user_grp_' + str(group_idx) + '.csv'
loadFile = np.loadtxt(loadPath, delimiter=',', dtype=np.str)
load = loadFile[1:, 1:].astype('float')
# Remove empty data
idx = np.logical_or(np.isnan(load), np.isinf(load))
load[idx] = 0.0
# Get zip for each user in the group
zipcodes = user_to_zip[num_users_per_grp *
(group_idx - 1):num_users_per_grp * (group_idx)]
def feng_threshold(img, w_size1=15, w_size2=30,
k1=0.15, k2=0.01, alpha1=0.1):
""" Runs the Feng's thresholding algorithm.
Reference:
Algorithm proposed in: Meng-Ling Feng and Yap-Peng Tan, “Contrast adaptive
thresholding of low quality document images”, IEICE Electron. Express,
Vol. 1, No. 16, pp.501-506, (2004).
Modifications: Using integral images to compute the local mean and the
standard deviation
@param img: The input image. Must be a gray scale image
@type img: ndarray
@param w_size1: The size of the primary local window to compute
each pixel threshold. Should be an odd window
@type w_size1: int
@param w_size2: The size of the secondary local window to compute
the dynamic range standard deviation. Should be an odd window
@type w_size2: int
@param k1: Parameter value that lies in the interval [0.15, 0.25].
@type k1: float
@param k2: Parameter value that lies in the interval [0.01, 0.05].
@type k2: float
@param alpha1: Parameter value that lies in the interval [0.15, 0.25].
@type alpha1: float
@return: The estimated local threshold for each pixel
@rtype: ndarray
"""
# Obtaining rows and cols
rows, cols = img.shape
i_rows, i_cols = rows + 1, cols + 1
# Computing integral images
# Leaving first row and column in zero for convenience
integ = np.zeros((i_rows, i_cols), np.float)
sqr_integral = np.zeros((i_rows, i_cols), np.float)
integ[1:, 1:] = np.cumsum(np.cumsum(img.astype(np.float), axis=0), axis=1)
sqr_img = np.square(img.astype(np.float))
sqr_integral[1:, 1:] = np.cumsum(np.cumsum(sqr_img, axis=0), axis=1)
# Defining grid
x, y = np.meshgrid(np.arange(1, i_cols), np.arange(1, i_rows))
# Obtaining local coordinates
hw_size = w_size1 // 2
x1 = (x - hw_size).clip(1, cols)
x2 = (x + hw_size).clip(1, cols)
y1 = (y - hw_size).clip(1, rows)
y2 = (y + hw_size).clip(1, rows)
# Obtaining local areas size
l_size = (y2 - y1 + 1) * (x2 - x1 + 1)
# Computing sums
sums = (integ[y2, x2] - integ[y2, x1 - 1] -
integ[y1 - 1, x2] + integ[y1 - 1, x1 - 1])
sqr_sums = (sqr_integral[y2, x2] - sqr_integral[y2, x1 - 1] -
sqr_integral[y1 - 1, x2] + sqr_integral[y1 - 1, x1 - 1])
# Computing local means
means = sums / l_size
# Computing local standard deviation
stds = np.sqrt(sqr_sums / l_size - np.square(means))
# Obtaining windows
padded_img = np.ones((rows + w_size1 - 1, cols + w_size1 - 1)) * np.nan
padded_img[hw_size: -hw_size, hw_size: -hw_size] = img
winds = view_as_windows(padded_img, (w_size1, w_size1))
# Obtaining maximums and minimums
mins = np.nanmin(winds, axis=(2, 3))
# Obtaining local coordinates for std range calculations
hw_size = w_size2 // 2
x1 = (x - hw_size).clip(1, cols)
x2 = (x + hw_size).clip(1, cols)
y1 = (y - hw_size).clip(1, rows)
y2 = (y + hw_size).clip(1, rows)
# Obtaining local areas size
l_size = (y2 - y1 + 2) * (x2 - x1 + 2)
# Computing sums
sums = (integ[y2, x2] - integ[y2, x1 - 1] -
integ[y1 - 1, x2] + integ[y1 - 1, x1 - 1])
sqr_sums = (sqr_integral[y2, x2] - sqr_integral[y2, x1 - 1] -
sqr_integral[y1 - 1, x2] + sqr_integral[y1 - 1, x1 - 1])
# Computing local means2
means2 = sums / l_size
# Computing standard deviation range
std_ranges = np.sqrt(sqr_sums / l_size - np.square(means2))
# Computing normalized standard deviations and extra alpha parameters
n_stds = stds / std_ranges
n_sqr_std = np.square(n_stds)
alpha2 = k1 * n_sqr_std
alpha3 = k2 * n_sqr_std
thresholds = ((1 - alpha1) * means + alpha2 * n_stds
* (means - mins) + alpha3 * mins)
return thresholds
def test_view_as_windows_negative_window_length():
A = np.arange(10)
view_as_windows(A, (-1, ))
def test_view_as_windows_wrong_window_dimension():
A = np.arange(10)
view_as_windows(A, (2, 2))
def lcdnorm4(arr_in,
neighborhood,
contrast=DEFAULT_CONTRAST,
divisive=DEFAULT_DIVISIVE,
stretch=DEFAULT_STRETCH,
threshold=DEFAULT_THRESHOLD,
stride=DEFAULT_STRIDE,
arr_out=None):
"""4D Local Contrast Divisive Normalization
XXX: docstring
"""
assert arr_in.ndim == 4
assert len(neighborhood) == 2
assert isinstance(contrast, bool)
assert isinstance(divisive, bool)
assert contrast or divisive
in_imgs, inh, inw, ind = arr_in.shape
nbh, nbw = neighborhood
assert nbh <= inh
assert nbw <= inw
nb_size = 1. * nbh * nbw * ind
if arr_out is not None:
assert arr_out.dtype == arr_in.dtype
assert arr_out.shape == (in_imgs, 1 + (inh - nbh) / stride,
1 + (inw - nbw) / stride, ind)
# -- prepare arr_out
lys = nbh / 2
lxs = nbw / 2
rys = (nbh - 1) / 2
rxs = (nbw - 1) / 2
_arr_out = arr_in[:, lys:inh - rys, lxs:inw - rxs][::stride, ::stride]
# -- Contrast Normalization
if contrast:
# -- local sums
arr_sum = arr_in.sum(-1)
arr_sum = view_as_windows(arr_sum, (1, 1, nbw)).sum(-1)[:, :, ::stride,
0, 0]
arr_sum = view_as_windows(arr_sum, (1, nbh, 1)).sum(-2)[:, ::stride, :,
0]
# -- remove the mean
_arr_out = _arr_out - arr_sum / nb_size
# -- Divisive (gain) Normalization
if divisive:
# -- local sums of squares
arr_ssq = (arr_in**2.0).sum(-1)
arr_ssq = view_as_windows(arr_ssq, (1, 1, nbw)).sum(-1)[:, :, ::stride,
0, 0]
arr_ssq = view_as_windows(arr_ssq, (1, nbh, 1)).sum(-2)[:, ::stride, :,
0]
# -- divide by the euclidean norm
if contrast:
l2norms = (arr_ssq - (arr_sum**2.0) / nb_size)
else:
l2norms = arr_ssq
np.putmask(l2norms, l2norms < 0., 0.)
l2norms = np.sqrt(l2norms) + EPSILON
if stretch != 1:
_arr_out *= stretch
l2norms *= stretch
np.putmask(l2norms, l2norms < (threshold + EPSILON), 1.0)
_arr_out = _arr_out / l2norms
if arr_out is not None:
arr_out[:] = _arr_out
else:
arr_out = _arr_out
assert arr_out.shape[0] == in_imgs
return arr_out
def test_view_as_windows_step_below_one():
A = np.arange(10)
view_as_windows(A, (11,), step=0.9)
for nid, img in enumerate(neg_img):
print "cas_lv ", cascade_lv, " ", nid+1,"/",len(neg_img), "th image...", "neg_db size: ", neg_db_num, "thr_12: ", thr_12, "thr_24: ", thr_24
pyramid = tuple(pyramid_gaussian(img, downscale = etc.downscale))
neg_db_for_scale = [0 for _ in xrange(len(pyramid))]
for scale in xrange(len(pyramid)):
X = pyramid[scale]
img_row = np.shape(X)[0]
img_col = np.shape(X)[1]
if img_row < etc.img_size_12 or img_col < etc.img_size_12:
break
if etc.img_size_12 * (etc.downscale ** scale) < etc.face_minimum:
continue
win_list = view_as_windows(X, (etc.img_size_12, etc.img_size_12, etc.input_channel), etc.window_stride)
win_col = np.shape(win_list)[1]
win_list = np.reshape(win_list, (-1, etc.input_channel * etc.img_size_12 * etc.img_size_12))
result = h_fc2_12.eval(feed_dict={x_12:win_list})
result_id = np.where(result > thr_12)[0]
detected_box = [0 for _ in xrange(len(result_id))]
for id_, rid in enumerate(result_id):
lt_x = (rid % win_col) * etc.window_stride
lt_y = (rid / win_col) * etc.window_stride
rb_x = lt_x + etc.img_size_12
rb_y = lt_y + etc.img_size_12
lt_x *= etc.downscale ** scale
lt_y *= etc.downscale ** scale
rb_x *= etc.downscale ** scale
def test_view_as_windows_window_not_tuple():
A = np.arange(10)
view_as_windows(A, [2])
def testImage(imagePath,
decisionThreshold=cfg.decision_threshold,
applyNMS=True):
file = open(cfg.modelPath, 'rb')
svc = pickle.load(file)
image = io.imread(imagePath, as_grey=True)
image = util.img_as_ubyte(
image) #Read the image as bytes (pixels with values 0-255)
rows, cols = image.shape
pyramid = tuple(pyramid_gaussian(image, downscale=cfg.downScaleFactor))
scale = 0
boxes = None
scores = None
for p in pyramid[0:]:
#We now have the subsampled image in p
#Add padding to the image, using reflection to avoid border effects
if cfg.padding > 0:
p = pad(p, cfg.padding, 'reflect')
try:
views = view_as_windows(p, cfg.window_shape, step=cfg.window_step)
except ValueError:
#block shape is bigger than image
break
num_rows, num_cols, width, height = views.shape
for row in range(0, num_rows):
for col in range(0, num_cols):
#Get current window
subImage = views[row, col]
#Extract features
feats = feature_extractor.extractFeatures(subImage)
#Obtain prediction score
# print(feats)
# print(feats[0].shape)
# print(len(feats))
decision_func = svc.decision_function(
np.reshape(feats, (1, -1)))
if decision_func > decisionThreshold:
# Pedestrian found!
h, w = cfg.window_shape
scaleMult = math.pow(cfg.downScaleFactor, scale)
x1 = int(scaleMult * (col * cfg.window_step - cfg.padding +
cfg.window_margin))
y1 = int(scaleMult * (row * cfg.window_step - cfg.padding +
cfg.window_margin))
x2 = int(x1 + scaleMult * (w - 2 * cfg.window_margin))
y2 = int(y1 + scaleMult * (h - 2 * cfg.window_margin))
bbox = (x1, y1, x2, y2)
score = decision_func[0]
if boxes is not None:
boxes = np.vstack((bbox, boxes))
scores = np.hstack((score, scores))
else:
boxes = np.array([bbox])
scores = np.array([score])
scale += 1
if applyNMS:
#From all the bounding boxes that are overlapping, take those with maximum score.
boxes, scores = nms.non_max_suppression_fast(boxes, scores,
cfg.nmsOverlapThresh)
return boxes, scores
def compute_Iw(I0, I1, Id, patch_size=None, mode='constant', isophase=np.pi):
'''Computes weighted sum of image pair (I0,I1).
Parameters
----------
I0 : array_like
1st of pair of diagonal images (relative phase cycle of 0).
I1 : array_like
2nd of pair of diagonal images (relative phase cycle of 180
deg).
Id : array_like
result of regularized direct solution.
patch_size : tuple, optional
size of patches in pixels (x, y). Defaults to (5, 5).
mode : {'contant', 'edge'}, optional
mode of numpy.pad. Probably choose 'constant' or 'edge'.
isophase : float
Only neighbours with isophase max phase difference contribute.
Returns
-------
Iw : array_like
The weighted sum of image pair (I0,I1), equation [14]
Notes
-----
Image pair (I0,I1) are phase cycled bSSFP images that are
different by 180 degrees. Id is the image given by the direct
method (Equation [13]) after regularization by the complex sum.
This function solves for the weights by regional differential
energy minimization. The 'regional' part means that the image is
split into patches of size patch_size with edge boundary
conditions (pads with the edge values given by mode option). The
weighted sum of the image pair is returned.
The isophase does not appear in the paper, but appears in Hoff's
MATLAB code. It appears that we only want to consider pixels in
the patch that have similar tissue properties - in other words,
have similar phase. The default isophase is pi as in Hoff's
implementation.
This function implements Equations [14,18], or steps 4--5 from
Fig. 2 in [1]_.
'''
# Make sure we have a patch size
if patch_size is None:
patch_size = (5, 5)
# Expressions for the numerator and denominator
numerator = np.conj(I1 - Id) * (I1 - I0) + np.conj(I1 - I0) * (I1 - Id)
den = np.conj(I0 - I1) * (I0 - I1)
# We'll have trouble with a 1d input if we don't do this
numerator = np.atleast_2d(numerator)
den = np.atleast_2d(den)
# Pad the image so we can generate patches where we need them
edge_pad = [int(p / 2) for p in patch_size]
numerator = np.pad(numerator, pad_width=edge_pad, mode=mode)
den = np.pad(den, pad_width=edge_pad, mode=mode)
# Separate out into patches of size patch_size
numerator_patches = view_as_windows(numerator, patch_size)
den_patches = view_as_windows(den, patch_size)
# Make sure the phase difference is below a certan bound to
# include point in weights
mask = mask_isophase(numerator_patches, patch_size, isophase)
numerator_patches *= mask
den_patches *= mask
numerator_weights = np.sum(numerator_patches, axis=(-2, -1))
den_weights = np.sum(den_patches, axis=(-2, -1))
# Equation [18]
weights = numerator_weights / (2 * den_weights + np.finfo(float).eps)
# Find Iw, the weighted sum of image pair (I0,I1), equation [14]
Iw = I0 * weights + I1 * (1 - weights)
return Iw
kernel_params = []
for theta in (0, 1, 2, 3, 4, 5, 6, 7):
theta = theta / 4.0 * np.pi
for frequency in (0.1, 0.4):
kernel = gabor_kernel(frequency, theta=theta)
params = "theta=%d,\nfrequency=%.2f" % (theta * 180 / np.pi, frequency)
kernel_params.append(params)
# Save kernel and the power image for each image
results.append((kernel, [power(image_gray, kernel)]))
output = power(image_gray, kernel)
# astro = color.rgb2gray(data.astronaut())
astro = output
# -- filterbank1 on original image
patches3 = view_as_windows(astro, patch_shape)
patches1 = patches3.reshape(-1, patch_shape[0] * patch_shape[1])[::8]
fb3, _ = kmeans2(patches1, n_filters, minit="points")
fb1 = fb3.reshape((-1,) + patch_shape)
fb1_montage = montage2d(fb1, rescale_intensity=True)
# -- filterbank2 LGN-like image
astro_dog = ndi.gaussian_filter(astro, 0.5) - ndi.gaussian_filter(astro, 1)
patches2 = view_as_windows(astro_dog, patch_shape)
patches2 = patches2.reshape(-1, patch_shape[0] * patch_shape[1])[::8]
fb2, _ = kmeans2(patches2, n_filters, minit="points")
fb2 = fb2.reshape((-1,) + patch_shape)
fb2_montage = montage2d(fb2, rescale_intensity=True)
# --
fig, axes = plt.subplots(2, 2, figsize=(7, 6))
for voice in all_voice_files:
print("Sample", indexer, "|", "Mean:", np.mean(voice), "|", "Max:", np.max(voice), "|", \
"Min:", np.min(voice), "|", "Std Dev:", np.std(voice))
indexer += 1
"""
Find all 200ms samples that have clear audio data in them
"""
#in each sample, find 200ms chunks that have a mean over the total average + standard deviation
window_shape = 48000 / 5
voice_data = []
voice_labels = []
voice_number = 0
for voice in all_voice_files:
positive_full_array = view_as_windows(np.absolute(voice), window_shape)
positive_full_array = positive_full_array[::int(
window_shape /
2)] #keep every nth row, where n is window_shape/2 (For some overlap)
temp_full_array = view_as_windows(voice, window_shape)
temp_full_array = temp_full_array[::int(window_shape / 2)]
for window_index in range(len(temp_full_array)):
if np.mean(positive_full_array[window_index]) > (np.mean(voice) +
np.std(voice)):
voice_data.append(temp_full_array[window_index])
voice_labels.append(voice_number)
voice_number += 1
voice_data = np.array(voice_data)
import numpy as np from skimage.util.shape import view_as_windows A = np.arange(4 * 4 * 4).reshape(4, 4, 4) B = np.arange(10).reshape(10, 1) print(B) C = B[0:9] print(B[9]) print(A[1, 0, 0]) window_shape = (1, 2, 2) B = view_as_windows(A, window_shape) B = np.reshape(B, (9, 4, 2, 2)) print(B.shape) print(B)
def convertFile(inFile, outFile):
# Open file and extract events
oldFile = h5.File(inFile)
newFile = h5.File(outFile, "w")
ECAL = oldFile["ECAL"][()]
HCAL = oldFile["HCAL"][()]
# copy ECAL and HCAL cell info to new file
newFile.create_dataset("ECAL", data=ECAL, compression='gzip')
newFile.create_dataset("HCAL", data=HCAL, compression='gzip')
# if 'GAN' in inFile: # match Geant units
# ECAL = ECAL/100
# HCAL = HCAL/100
# copy over all other existing arrays from the old file
for key in oldFile.keys():
if key in ['ECAL', 'HCAL']: continue
newFile.create_dataset(key, data=oldFile[key][()], compression='gzip')
oldFile.close()
# Calorimeter total energy and number of hits
ECAL_E = np.sum(np.sum(np.sum(ECAL, axis=1), axis=1), axis=1)
ECAL_nHits = np.sum(np.sum(np.sum(ECAL > 0.1, axis=1), axis=1), axis=1)
newFile.create_dataset("ECAL_E", data=ECAL_E, compression='gzip')
newFile.create_dataset("ECAL_nHits", data=ECAL_nHits, compression='gzip')
HCAL_E = np.sum(np.sum(np.sum(HCAL, axis=1), axis=1), axis=1)
HCAL_nHits = np.sum(np.sum(np.sum(HCAL > 0.1, axis=1), axis=1), axis=1)
newFile.create_dataset("HCAL_E", data=HCAL_E, compression='gzip')
newFile.create_dataset("HCAL_nHits", data=HCAL_nHits, compression='gzip')
# Ratio of HCAL/ECAL energy, and other ratios
newFile.create_dataset("HCAL_ECAL_ERatio",
data=safeDivide(HCAL_E, ECAL_E),
compression='gzip')
newFile.create_dataset("HCAL_ECAL_nHitsRatio",
data=safeDivide(HCAL_nHits, ECAL_nHits),
compression='gzip')
ECAL_E_firstLayer = np.sum(np.sum(ECAL[:, :, :, 0], axis=1), axis=1)
HCAL_E_firstLayer = np.sum(np.sum(HCAL[:, :, :, 0], axis=1), axis=1)
newFile.create_dataset("ECAL_ratioFirstLayerToTotalE",
data=safeDivide(ECAL_E_firstLayer, ECAL_E),
compression='gzip')
newFile.create_dataset("HCAL_ratioFirstLayerToTotalE",
data=safeDivide(HCAL_E_firstLayer, HCAL_E),
compression='gzip')
ECAL_E_secondLayer = np.sum(np.sum(ECAL[:, :, :, 1], axis=1), axis=1)
HCAL_E_secondLayer = np.sum(np.sum(HCAL[:, :, :, 1], axis=1), axis=1)
newFile.create_dataset("ECAL_ratioFirstLayerToSecondLayerE",
data=safeDivide(ECAL_E_firstLayer,
ECAL_E_secondLayer),
compression='gzip')
newFile.create_dataset("HCAL_ratioFirstLayerToSecondLayerE",
data=safeDivide(HCAL_E_firstLayer,
HCAL_E_secondLayer),
compression='gzip')
# ECAL moments
ECALprojX = np.sum(np.sum(ECAL, axis=3), axis=2)
ECALprojY = np.sum(np.sum(ECAL, axis=3), axis=1)
ECALprojZ = np.sum(np.sum(ECAL, axis=1), axis=1) # z = direction into calo
totalE = np.sum(ECALprojX, axis=1)
nEvents, ECAL_sizeX, ECAL_sizeY, ECAL_sizeZ = ECAL.shape
# ECAL_midX = (ECAL_sizeX-1)/2
# ECAL_midY = (ECAL_sizeY-1)/2
# ECAL_midZ = (ECAL_sizeZ-1)/2
ECAL_midX = np.zeros(nEvents)
ECAL_midY = np.zeros(nEvents)
ECAL_midZ = np.zeros(nEvents)
for i in range(6):
relativeIndices = np.tile(np.arange(ECAL_sizeX), (nEvents, 1))
moments = np.power(
(relativeIndices.transpose() - ECAL_midX).transpose(), i + 1)
ECAL_momentX = safeDivide(umath.inner1d(ECALprojX, moments), totalE)
if i == 0: ECAL_midX = ECAL_momentX.transpose()
newFile.create_dataset("ECALmomentX" + str(i + 1),
data=ECAL_momentX,
compression='gzip')
for i in range(6):
relativeIndices = np.tile(np.arange(ECAL_sizeY), (nEvents, 1))
moments = np.power(
(relativeIndices.transpose() - ECAL_midY).transpose(), i + 1)
ECAL_momentY = safeDivide(umath.inner1d(ECALprojY, moments), totalE)
if i == 0: ECAL_midY = ECAL_momentY.transpose()
newFile.create_dataset("ECALmomentY" + str(i + 1),
data=ECAL_momentY,
compression='gzip')
for i in range(6):
relativeIndices = np.tile(np.arange(ECAL_sizeZ), (nEvents, 1))
moments = np.power(
(relativeIndices.transpose() - ECAL_midZ).transpose(), i + 1)
ECAL_momentZ = safeDivide(umath.inner1d(ECALprojZ, moments), totalE)
if i == 0: ECAL_midZ = ECAL_momentZ.transpose()
newFile.create_dataset("ECALmomentZ" + str(i + 1),
data=ECAL_momentZ,
compression='gzip')
# HCAL moments
HCALprojX = np.sum(np.sum(HCAL, axis=3), axis=2)
HCALprojY = np.sum(np.sum(HCAL, axis=3), axis=1)
HCALprojZ = np.sum(np.sum(HCAL, axis=1), axis=1)
totalE = np.sum(HCALprojX, axis=1)
HCAL_sizeX, HCAL_sizeY, HCAL_sizeZ = HCAL[0].shape
# HCAL_midX = (HCAL_sizeX-1)/2
# HCAL_midY = (HCAL_sizeY-1)/2
# HCAL_midZ = (HCAL_sizeZ-1)/2
HCAL_midX = np.zeros(nEvents)
HCAL_midY = np.zeros(nEvents)
HCAL_midZ = np.zeros(nEvents)
for i in range(6):
relativeIndices = np.tile(np.arange(HCAL_sizeX), (nEvents, 1))
moments = np.power(
(relativeIndices.transpose() - HCAL_midX).transpose(), i + 1)
HCAL_momentX = safeDivide(umath.inner1d(HCALprojX, moments), totalE)
if i == 0: HCAL_midX = HCAL_momentX.transpose()
newFile.create_dataset("HCALmomentX" + str(i + 1),
data=HCAL_momentX,
compression='gzip')
for i in range(6):
relativeIndices = np.tile(np.arange(HCAL_sizeY), (nEvents, 1))
moments = np.power(
(relativeIndices.transpose() - HCAL_midY).transpose(), i + 1)
HCAL_momentY = safeDivide(umath.inner1d(HCALprojY, moments), totalE)
if i == 0: HCAL_midY = HCAL_momentY.transpose()
newFile.create_dataset("HCALmomentY" + str(i + 1),
data=HCAL_momentY,
compression='gzip')
for i in range(6):
relativeIndices = np.tile(np.arange(HCAL_sizeZ), (nEvents, 1))
moments = np.power(
(relativeIndices.transpose() - HCAL_midZ).transpose(), i + 1)
HCAL_momentZ = safeDivide(umath.inner1d(HCALprojZ, moments), totalE)
if i == 0: HCAL_midZ = HCAL_momentZ.transpose()
newFile.create_dataset("HCALmomentZ" + str(i + 1),
data=HCAL_momentZ,
compression='gzip')
# R9
ECAL_z = np.sum(ECAL, axis=3) # sum in z
R9 = [
view_as_windows(event, (3, 3)).sum(axis=(-2, -1)).max() /
event.sum() if event.sum() > 0 else 0 for event in ECAL_z
]
newFile.create_dataset("R9", data=np.array(R9), compression='gzip')
newFile.close()
def rms_profile(my_signal, w_window, w_move, method=1):
"""
Compute the rms profile for a sampled waveform through sliding windows.
Given a sampled waveform, the correspoding rms profile is computed through sliding windows with user-specified length and
time resolution. Two computation methods are implemented in this fuction: method 1 is a vectorized version using window
views provided in the library skimage and, therefore, present high speed optimization; on the other hand, method 2 is a
naive implementation through Python loops. This is the most general function for rms profile computation.
Parameters
----------
my_signal: 1D numpy array
Input sampled waveform.
w_window: integer
Length of each sliding window, in samples. In general, it should represent an integer number of full cycles.
w_move: integer
Step size between successive sliding windows, in samples (i.e., it represents the time resolution of the output rms
profile).
method: integer (either 1 or 2) [optional; default: 1]
Selector for the computation method employed in obtaining the rms profile. Option 1 is a vectorized version where
Python loops are avoided, so that it has a better computational performance.
Returns
-------
rms_profile: 1D numpy array
Output rms profile correspoding to the input sampled waveform.
idx_rms_profile: 1D numpy array
Indices corresponding to the rms update instants.
Latest update: Jul 20, 2019 by Alvaro Furlani Bastos
"""
# Compute the square value for each input sample (it avoids repetitive computation when adjacent windows overlap)
my_signal_2 = my_signal**2
w_move = int(w_move)
# Method 1: using views of rolling windows (package scikit-image)
if method == 1:
# Create array with window views and compute the rms value for each window
array_windows = view_as_windows(my_signal_2, window_shape=(w_window,), step=w_move)
rms_profile = np.sqrt(np.mean(array_windows, axis=1))
# Method 2: naive implementation through loops
elif method == 2:
# Initialize array for storing the rms profile
rms_profile = []
# Range of indices for the currently selected sliding window
range_aux = np.arange(0, w_window)
# Run through the entire signal and store the rms values
while len(my_signal) > range_aux[-1]:
rms_profile.append(np.sqrt(np.mean(my_signal_2[range_aux])))
range_aux += w_move
# Determine the time indices for each rms update operation
idx_rms_profile = np.arange(w_window-1, w_window+(len(rms_profile)-1)*w_move, w_move)
# Return the desired profiles (as 1D numpy arrays)
return np.array(rms_profile), idx_rms_profile
def gsn(data_path,
data_name,
tail,
fs,
duration,
overlap,
channel,
sample_ratio,
result_path,
randseed,
bad_channel=None,
bad_sample_ratio=None,
packet=1,
regularizer_weight=1.0,
batch_size=128,
epochs=1200,
harmonic_wavelet_interval=16,
loss_weight_rate=32):
#%% 1 Load data and prepare file and folder names
data_raw = hdf5storage.loadmat(data_path + data_name + tail)
data_all = data_raw[data_name]
del data_raw
if channel == 'all':
channel = np.arange(0, data_all.shape[1])
channel_num = len(channel)
channel_str_abbr = tidy_name(abbr(channel))
if bad_channel is None:
result_folder = data_name + '_' + str(duration) + '_' + str(packet) + '_[' + channel_str_abbr + ']_' + \
'%.2f' % sample_ratio + '_' + str(randseed) + \
'_rw_' + str(regularizer_weight) + '_bs_' + str(batch_size) + '_epo_' + str(epochs) + \
'_hw_interval_' + str(hw_interval) + \
'_lw_rate_' + '%03d' % loss_weight_rate + '/'
result_file = data_name + '_' + str(duration) + '_' + str(packet) + '_[' + channel_str_abbr + ']_' + \
'%.2f' % sample_ratio + '_' + str(randseed) + \
'_rw_' + str(regularizer_weight) + '_bs_' + str(batch_size) + '_epo_' + str(epochs) + \
'_hw_interval_' + str(hw_interval) + \
'_lw_rate_' + '%03d' % loss_weight_rate
else:
bad_channel_str = [str(i) for i in bad_channel]
bad_channel_str_stack = '_'.join(bad_channel_str)
bad_sample_ratio_str = ['%.2f' % i for i in bad_sample_ratio]
bad_sample_ratio_str_stack = '_'.join(bad_sample_ratio_str)
result_folder = data_name + '_' + str(duration) + '_' + str(packet) + '_[' + channel_str_abbr + ']_' + \
'%.2f' % sample_ratio + '_' + str(randseed) + \
'_rw_' + str(regularizer_weight) + '_bs_' + str(batch_size) + '_epo_' + str(epochs) + \
'_hw_interval_' + str(hw_interval) + \
'_lw_rate_' + '%03d' % loss_weight_rate + \
'__[' + bad_channel_str_stack + ']_' + bad_sample_ratio_str_stack + '/'
result_file = data_name + '_' + str(duration) + '_' + str(packet) + '_[' + channel_str_abbr + ']_' + \
'%.2f' % sample_ratio + '_' + str(randseed) + \
'_rw_' + str(regularizer_weight) + '_bs_' + str(batch_size) + '_epo_' + str(epochs) + \
'_hw_interval_' + str(hw_interval) + \
'_lw_rate_' + '%03d' % loss_weight_rate + \
'__[' + bad_channel_str_stack + ']_' + bad_sample_ratio_str_stack
create_folder(result_path + result_folder)
channel_str = ['ch %d' % (i + 1) for i in channel]
#%% 2 Preprocess data
data_all = data_all[:, channel]
data_split = view_as_windows(np.ascontiguousarray(data_all),
(duration, data_all.shape[1]),
duration - overlap)
data_split = np.squeeze(data_split, axis=1)
slice_num = data_split.shape[0] # number of sections, split by duration
print('Shape of data_split: ', data_split.shape)
data_split_offset = np.nanmean(data_split, axis=1)
data_split_norm = np.zeros(data_split_offset.shape)
data_split_normalized = np.zeros(data_split.shape)
for slice in range(slice_num):
data_split_norm[slice] = np.nanmax(
np.abs(data_split[slice] -
data_split_offset[slice].reshape((1, channel_num))),
axis=0)
data_split_normalized[slice] = np.true_divide(
data_split[slice] - data_split_offset[slice].reshape(
(1, channel_num)), data_split_norm[slice].reshape(
(1, channel_num)))
data_hat = np.zeros(data_split.shape, dtype=np.complex128)
data_masked_ignore_zero_all = np.zeros(data_split.shape)
mask_matrix_all = np.zeros(data_split.shape)
weights_complex = np.zeros(data_split.shape, dtype=np.complex128)
recon_error_time_domain = np.zeros([slice_num, len(channel)])
recon_error_freq_domain = np.zeros([slice_num, len(channel)])
for slice in range(slice_num):
start_time = time.time()
data_time = data_split_normalized[slice]
print('shape of data:\n', data_time.shape)
dt = 1. / fs
t = np.arange(0., duration / fs, dt)
for f in range(len(channel)):
fig = plt.figure(figsize=(18, 4))
plt.plot(t, data_time[:, f])
ax = plt.gca()
ax.tick_params(axis='both', which='major', labelsize=12)
ax.tick_params(axis='both', which='minor', labelsize=12)
plt.legend([channel_str[f]], loc=1, fontsize=12)
plt.xlabel('Time (s)', fontsize=12)
plt.ylabel(data_unit(data_name), fontsize=12)
plt.xlim(0, max(t))
# plt.show()
plt.tight_layout()
result_folder_signal = 'signal_%02d/' % (channel[f] + 1)
create_folder(result_path + result_folder + result_folder_signal)
fig.savefig(result_path + result_folder + result_folder_signal +
'signal_%d_slice-%02d.png' %
(channel[f] + 1, slice + 1))
plt.close()
time.sleep(0.1)
fig = plt.figure(figsize=(18, 4))
plt.plot(t, data_time)
# matplotlib.rcParams.update({'font.size': 12})
ax = plt.gca()
ax.tick_params(axis='both', which='major', labelsize=12)
ax.tick_params(axis='both', which='minor', labelsize=12)
# matplotlib.rc('xtick', labelsize=12)
# matplotlib.rc('ytick', labelsize=12)
plt.legend(channel_str, loc=1, fontsize=12)
plt.xlabel('Time (s)', fontsize=12)
plt.ylabel(data_unit(data_name), fontsize=12)
plt.xlim(0, max(t))
plt.tight_layout()
# plt.show()
fig.savefig(result_path + result_folder + 'signal_all_slice-%02d.png' %
(slice + 1))
time.sleep(0.1)
plt.close('all')
#%% 3 Generate mask matrix
mask_matrix = ~np.isnan(data_time) * 1
np.random.seed(randseed + slice) # generate random seed
# if packet > 1:
# remain = np.mod(duration, packet)
# if bad_channel is None:
# mask_matrix_condensed = np.random.choice([0, 1],
# size=(data_time.shape[0] // packet, data_time.shape[1]),
# p=[1 - sample_ratio, sample_ratio])
# mask_matrix = np.vstack(
# (np.repeat(mask_matrix_condensed, packet, axis=0), np.ones((remain, data_time.shape[1]))))
# else:
# mask_matrix_condensed = np.random.choice([0, 1],
# size=(data_time.shape[0] // packet, data_time.shape[1]),
# p=[1 - sample_ratio, sample_ratio])
# for b in range(len(bad_channel)):
# mask_col = np.random.choice([0, 1], size=(data_time.shape[0] // packet),
# p=[1 - bad_sample_ratio[b], bad_sample_ratio[b]])
# mask_matrix_condensed[:, bad_channel[b]] = mask_col
# mask_matrix = np.vstack(
# (np.repeat(mask_matrix_condensed, packet, axis=0), np.ones((remain, data_time.shape[1]))))
# else:
# if bad_channel is None:
# mask_matrix = np.random.choice([0, 1], size=data_time.shape, p=[1 - sample_ratio, sample_ratio])
# else:
# mask_matrix = np.random.choice([0, 1], size=data_time.shape, p=[1 - sample_ratio, sample_ratio])
# for b in range(len(bad_channel)):
# mask_col = np.random.choice([0, 1], size=(data_time.shape[0]),
# p=[1 - bad_sample_ratio[b], bad_sample_ratio[b]])
# mask_matrix[:, bad_channel[b]] = mask_col
mask_matrix_all[slice] = mask_matrix
print('shape of mask_matrix:', mask_matrix.shape, '\n')
#%% 4 Make masked data
data_masked = np.nan_to_num(data_time) * mask_matrix
#%% 5 Generate basis matrix
basis_folder = 'basis_matrix/'
basis_file = 'basis_' + str(duration) + '.npy'
print('\nGenerating basis matrix...\n')
m = 0
n = hw_interval
basis_matrix = harmonic_wavelet(duration, m, n)
# basis_matrix = dft2d(duration)
create_folder(result_path + basis_folder)
print('\nShape of basis_matrix:\n', basis_matrix.shape, '\n')
print('\nBasis_matrix:\n', basis_matrix, '\n')
#%% 6 Construct neural network
data_input1 = np.real(basis_matrix)
data_input2 = np.imag(basis_matrix)
data_input3 = mask_matrix
data_output1 = np.real(data_masked.astype(complex))
data_output2 = np.imag(data_masked.astype(complex))
# Expand input dimension for CNN
data_input1 = np.expand_dims(data_input1, 0)
data_input1 = np.expand_dims(data_input1, -1)
data_input2 = np.expand_dims(data_input2, 0)
data_input2 = np.expand_dims(data_input2, -1)
data_input3 = np.expand_dims(data_input3, 0)
data_input3 = np.expand_dims(data_input3, -1)
data_output1 = np.expand_dims(data_output1, 0)
data_output1 = np.expand_dims(data_output1, -1)
data_output2 = np.expand_dims(data_output2, 0)
data_output2 = np.expand_dims(data_output2, -1)
np.random.seed(randseed)
tf.set_random_seed(randseed)
class Regularizer(object):
"""Regularizer base class.
"""
def __call__(self, x):
return 0.
@classmethod
def from_config(cls, config):
return cls(**config)
class GroupSparseRegularizer(Regularizer):
def __init__(self, regularizer_weight):
self.regularizer_weight = regularizer_weight
def __call__(self, weight_matrix):
return self.regularizer_weight * K.sum(
tf.norm(weight_matrix, ord='euclidean',
axis=3)) # Frobenius norm
def get_config(self):
return {'regularizer_weight': float(self.regularizer_weight)}
def model(data_input1, data_input2, data_input3, data_output1,
data_output2, duration, num_channel):
# input layer
basis_real = Input(shape=(duration, duration, 1),
name='Basis_real')
basis_imag = Input(shape=(duration, duration, 1),
name='Basis_imag')
# Convolutional layer
coeff_real = Conv2D(
num_channel,
kernel_size=(1, duration),
activation='linear',
input_shape=(duration, duration, 1),
name='Coeff_real',
use_bias=False,
# kernel_regularizer=GroupSparseRegularizer(regularizer_weight=regularizer_weight))
kernel_regularizer=regularizers.l1(
regularizer_weight)) # regularizers.l1(0.1)
coeff_imag = Conv2D(
num_channel,
kernel_size=(1, duration),
activation='linear',
input_shape=(duration, duration, 1),
name='Coeff_imag',
use_bias=False,
# kernel_regularizer=GroupSparseRegularizer(regularizer_weight=regularizer_weight))
kernel_regularizer=regularizers.l1(regularizer_weight))
mask = Input(shape=(duration, num_channel, 1), name='Mask')
# Feature maps as intermediate layer (need permute dimensions)
item_ac = coeff_real(basis_real)
item_ad = coeff_imag(basis_real)
item_bc = coeff_real(basis_imag)
item_bd = coeff_imag(basis_imag)
item_ac_permuted = Lambda(
lambda x: K.permute_dimensions(x, (0, 1, 3, 2)))(item_ac)
item_ad_permuted = Lambda(
lambda x: K.permute_dimensions(x, (0, 1, 3, 2)))(item_ad)
item_bc_permuted = Lambda(
lambda x: K.permute_dimensions(x, (0, 1, 3, 2)))(item_bc)
item_bd_permuted = Lambda(
lambda x: K.permute_dimensions(x, (0, 1, 3, 2)))(item_bd)
# Recovery
signal_real = Subtract(name='Signal_real')(
[item_ac_permuted, item_bd_permuted])
signal_imag = Add(name='Signal_imag')(
[item_ad_permuted, item_bc_permuted])
# masking
signal_real_masked = Multiply(name='Sparse_signal_real')(
[signal_real, mask])
signal_imag_masked = Multiply(name='Sparse_signal_imag')(
[signal_imag, mask])
model = Model(inputs=[basis_real, basis_imag, mask],
outputs=[signal_real_masked, signal_imag_masked])
return model
model = model(data_input1, data_input2, data_input3, data_output1,
data_output2, duration, data_input3.shape[2])
model.summary()
if not os.path.exists(result_path + result_folder + 'model_v6.png'):
plot_model(model,
to_file='model_v6.png',
show_shapes=True,
show_layer_names=True)
#%% 7 Solving
opt = Adam(lr=0.0001)
##
lw_real = K.variable(1.)
lw_imag = K.variable(1.)
model.compile(optimizer=opt,
loss='mean_squared_error',
loss_weights=[lw_real, lw_imag],
metrics=['mae'])
class LossWeightsScheduler(Callback):
def __init__(self, lw_real, lw_imag, epochs, loss_weight_rate):
self.lw_real = lw_real
self.lw_imag = lw_imag
self.epochs = epochs
self.loss_weight_rate = loss_weight_rate
def on_epoch_begin(self, epoch, logs={}):
if epoch <= self.epochs:
K.set_value(
self.lw_real,
math.pow(
2,
(epoch / self.epochs * self.loss_weight_rate + 1)))
K.set_value(
self.lw_imag,
math.pow(
2,
(epoch / self.epochs * self.loss_weight_rate + 1)))
class LossHistory(Callback):
def on_train_begin(self, logs={}):
self.losses = []
def on_batch_end(self, batch, logs={}):
self.losses.append(logs.get('loss'))
loss_history = LossHistory()
weights_folder = 'weights_history/'
weights_slice_folder = 'slice_%02d/' % (slice + 1)
create_folder(result_path + result_folder + weights_folder +
weights_slice_folder)
file_path_of_weights = result_path + result_folder + weights_folder + weights_slice_folder + \
'weights_slice-%02d-{epoch:03d}.hdf5' % (slice + 1)
checkpoint = ModelCheckpoint(file_path_of_weights,
monitor='loss',
verbose=0,
save_best_only=False,
save_weights_only=True,
mode='auto',
period=50)
history = model.fit(x=[data_input1, data_input2, data_input3],
y=[data_output1, data_output2],
epochs=epochs,
batch_size=batch_size,
callbacks=[
loss_history,
LossWeightsScheduler(lw_real, lw_imag, epochs,
loss_weight_rate),
checkpoint
])
#%% 8 Check results
# Plot training history
print(history.history.keys())
# print(len(loss_history.losses))
# summarize history for loss
fig = plt.figure(figsize=(6, 4))
plt.semilogy(history.history['Sparse_signal_real_loss'],
linestyle='-',
color='red')
plt.semilogy(history.history['Sparse_signal_imag_loss'],
linestyle='--',
color='blue')
ax = plt.gca()
ax.tick_params(axis='both', which='major', labelsize=12)
ax.tick_params(axis='both', which='minor', labelsize=12)
# plt.title('Model loss')
plt.xlabel('Epoch', fontsize=12)
plt.ylabel('Loss', fontsize=12)
plt.legend(['real part', 'imaginary part'],
loc='upper right',
fontsize=12)
plt.tight_layout()
plt.show()
file_name = result_path + result_folder + 'training_history_slice-%02d' % (
slice + 1)
fig.savefig(file_name + '.png')
fig.savefig(file_name + '.svg')
fig.savefig(file_name + '.eps')
fig.savefig(file_name + '.pdf')
subprocess.call('C:/Program Files/Inkscape/inkscape.exe ' + file_name +
'.svg '
'--export-emf=' + file_name + '.emf')
time.sleep(0.1)
# Get basis coeffs
weights_real = np.squeeze(model.get_weights()[0])
print('shape of weights_real:', weights_real.shape, '\n')
weights_imag = np.squeeze(model.get_weights()[1])
print('shape of weights_imag:', weights_imag.shape, '\n')
weights_complex[slice] = weights_real + weights_imag * 1j
print('shape of weights_complex:', weights_complex.shape, '\n')
# Plot heatmap for the real part of coefficients
fig = plt.figure(figsize=(3, 60)) # figsize=(6, 6)
ax = sns.heatmap(weights_imag,
cmap='coolwarm',
square=True,
xticklabels=1,
yticklabels=128)
sns.set(font_scale=1.0)
# cbar_axes = ax.figure.axes[-1]
# ax.figure.axes[-1].yaxis.label.set_size(12)
# ax.tick_params(axis='both', which='major', labelsize=12)
# ax.tick_params(axis='both', which='minor', labelsize=12)
# plt.title('Imaginary part of basis coefficients') # , fontsize=12
# plt.xlabel('Column')
# plt.ylabel('Row')
# plt.xticks(np.arange(0, 2048, 32))
plt.tight_layout()
# plt.show()
fig.savefig(result_path + result_folder +
'basis_coeffs_signal_all_imag_slice-%02d_heatmap.pdf' %
(slice + 1))
plt.close()
sns.reset_orig()
# Plot heatmap for the imaginary part of coefficients for all channels
fig = plt.figure(figsize=(3, 60)) # figsize=(6, 6)
ax = sns.heatmap(weights_real,
cmap='coolwarm',
square=True,
xticklabels=1,
yticklabels=128)
# sns.set(font_scale=0.05)
# cbar_axes = ax.figure.axes[-1]
# ax.figure.axes[-1].yaxis.label.set_size(12)
# ax.tick_params(axis='both', which='major', labelsize=12)
# ax.tick_params(axis='both', which='minor', labelsize=12)
# plt.title('Real part of basis coefficients') # , fontsize=12
# plt.xlabel('Column')
# plt.ylabel('Row')
# plt.xticks(np.arange(0, 2048, 32))
plt.tight_layout()
# plt.show()
fig.savefig(result_path + result_folder +
'basis_coeffs_signal_all_real_slice-%02d_heatmap.pdf' %
(slice + 1))
plt.close()
sns.reset_orig()
# Plot real-part coefficients for all channels
fig = plt.figure(figsize=(17, 4))
plt.plot(weights_real)
ax = plt.gca()
ax.tick_params(axis='both', which='major', labelsize=12)
ax.tick_params(axis='both', which='minor', labelsize=12)
plt.title('Real part', fontsize=12)
plt.xlabel('Point', fontsize=12)
plt.ylabel('Amplitude', fontsize=12)
plt.legend(channel_str, loc=9, ncol=len(channel_str), fontsize=12)
plt.tight_layout()
# plt.show()
fig.savefig(result_path + result_folder +
'basis_coeffs_signal_all_real_slice-%02d.png' %
(slice + 1))
time.sleep(0.1)
# Plot imaginary-part coefficients for all channels
fig = plt.figure(figsize=(17, 4))
plt.plot(weights_imag)
ax = plt.gca()
ax.tick_params(axis='both', which='major', labelsize=12)
ax.tick_params(axis='both', which='minor', labelsize=12)
plt.title('Imaginary part', fontsize=12)
plt.xlabel('Point', fontsize=12)
plt.ylabel('Amplitude', fontsize=12)
plt.legend(channel_str, loc=9, ncol=len(channel_str), fontsize=12)
plt.tight_layout()
# plt.show()
fig.savefig(result_path + result_folder +
'basis_coeffs_signal_all_imag_slice-%02d.png' %
(slice + 1))
time.sleep(0.1)
# Plot coefficients of each channel respectively
for f in range(len(channel)):
fig = plt.figure(figsize=(12, 8))
plt.subplot(2, 1, 1)
plt.plot(weights_real[:, f])
ax = plt.gca()
ax.tick_params(axis='both', which='major', labelsize=12)
ax.tick_params(axis='both', which='minor', labelsize=12)
plt.title('Real part', fontsize=12)
plt.legend([channel_str[f]], loc=1, fontsize=12)
plt.xlabel('Point', fontsize=12)
plt.ylabel('Amplitude', fontsize=12)
plt.xlim(0, duration)
plt.subplot(2, 1, 2)
plt.plot(weights_imag[:, f])
ax = plt.gca()
ax.tick_params(axis='both', which='major', labelsize=12)
ax.tick_params(axis='both', which='minor', labelsize=12)
plt.title('Imaginary part', fontsize=12)
plt.legend([channel_str[f]], loc=1, fontsize=12)
plt.xlabel('Point', fontsize=12)
plt.ylabel('Amplitude', fontsize=12)
plt.xlim(0, duration)
# plt.show()
plt.tight_layout()
result_folder_signal = 'signal_%02d/' % (channel[f] + 1)
create_folder(result_path + result_folder + result_folder_signal)
fig.savefig(result_path + result_folder + result_folder_signal +
'basis_coeffs_signal_%d_slice-%02d.png' %
(channel[f] + 1, slice + 1))
plt.close()
time.sleep(0.1)
#%% Check reconstructed data
data_hat_time = np.matmul(basis_matrix, weights_complex[slice])
data_hat_time = data_hat_time * data_split_norm[
slice] + data_split_offset[slice]
data_time = data_time * data_split_norm[slice] + data_split_offset[
slice]
data_masked = data_masked * data_split_norm[slice] + data_split_offset[
slice]
data_hat[slice] = data_hat_time
print('shape of data_hat_time:', data_hat_time.shape)
recon_error_time_domain[slice] = np.linalg.norm((np.real(data_hat_time - data_time)), ord=2, axis=0) / \
np.linalg.norm(np.real(data_time), ord=2, axis=0)
print('\nrecon_error_time_domain:', recon_error_time_domain[slice])
#%% Time domain:
data_masked_ignore_zero = np.array(data_masked)
data_masked_ignore_zero[data_masked_ignore_zero ==
0] = np.nan # data ignored zero for plotting
data_masked_ignore_zero_all[slice] = data_masked_ignore_zero
for f in channel:
print('\nPlotting signal ' + str(f) + '\n')
fig = plt.figure(figsize=(17, 4))
plot_origin = plt.plot(t,
np.real(data_time[:,
list(channel).index(f)]),
'red') # xkcd:lightish green
plot_recover = plt.plot(
t, np.real(data_hat_time[:, list(channel).index(f)]), 'blue')
# plot background
p = 0
while p < duration:
if mask_matrix[p, list(channel).index(f)] == 0:
plot_section = plt.axvspan(p / fs, (p + packet) / fs,
facecolor='red',
alpha=0.08)
p = p + packet
else:
p = p + 1
ax = plt.gca()
ax.tick_params(axis='both', which='major', labelsize=12)
ax.tick_params(axis='both', which='minor', labelsize=12)
plt.title('Signal %s - Slice %03d - Comparison' %
(f + 1, slice + 1),
fontsize=12)
plt.xlabel('Time (sec)', fontsize=12)
plt.ylabel(data_unit(data_name), fontsize=12)
plt.legend(['Original', 'Recovered'], fontsize=12)
plt.xlim(0, max(t))
plt.grid(True)
plt.tight_layout()
result_folder_signal = 'signal_%02d/' % (f + 1)
create_folder(result_path + result_folder + result_folder_signal)
fig.savefig(result_path + result_folder + result_folder_signal +
'compare_time_signal_' + str(f + 1) +
'_slice-%03d.png' % (slice + 1))
fig.savefig(result_path + result_folder + result_folder_signal +
'compare_time_signal_' + str(f + 1) +
'_slice-%03d.pdf' % (slice + 1))
time.sleep(0.1)
plt.close('all')
#%% Frequency domain:
data_freq = np.fft.fft(np.real(data_time), axis=0)
data_hat_freq = np.fft.fft(np.real(data_hat_time), axis=0)
recon_error_freq_domain[slice] = np.linalg.norm((data_hat_freq - data_freq), ord=2, axis=0) / \
np.linalg.norm(data_freq, ord=2, axis=0)
x_axis_freq = np.arange(0, fs, fs / duration)
for f in channel:
print('\nPlotting signal ' + str(f) + '\n')
fig = plt.figure(figsize=(17, 4))
plt.plot(x_axis_freq, np.abs(data_freq[:,
list(channel).index(f)]),
'red') # xkcd:lightish green
plt.plot(x_axis_freq,
np.abs(data_hat_freq[:, list(channel).index(f)]), 'blue')
ax = plt.gca()
ax.tick_params(axis='both', which='major', labelsize=12)
ax.tick_params(axis='both', which='minor', labelsize=12)
plt.title('Signal %s - Slice %03d - Comparison' %
(f + 1, slice + 1),
fontsize=12)
plt.xlabel('Frequency (Hz)', fontsize=12)
plt.ylabel(data_unit(data_name), fontsize=12)
plt.legend(['Original', 'Recovered'], fontsize=12)
plt.xlim(0, fs / 2 + 1)
plt.grid(True)
plt.tight_layout()
result_folder_signal = 'signal_%02d/' % (f + 1)
create_folder(result_path + result_folder + result_folder_signal)
fig.savefig(result_path + result_folder + result_folder_signal +
'compare_freq_signal_' + str(f + 1) +
'_slice-%03d.png' % (slice + 1))
fig.savefig(result_path + result_folder + result_folder_signal +
'compare_freq_signal_' + str(f + 1) +
'_slice-%03d.pdf' % (slice + 1))
time.sleep(0.1)
plt.close('all')
elapsed_time = time.time() - start_time
print(
time.strftime('Elapsed time: %H:%M:%S\n',
time.gmtime(elapsed_time)))
#%% Combine segments
if overlap == 0:
linked_data_time = data_split[:, :, :].reshape(-1, data_split.shape[2])
linked_data_hat_time = data_hat[:, :, :].reshape(-1, data_hat.shape[2])
linked_data_masked_ignore_zero_all = data_masked_ignore_zero_all[:, :, :].reshape(
-1, data_masked_ignore_zero_all.shape[2])
linked_mask_matrix_all = mask_matrix_all[:, :, :].reshape(
-1, mask_matrix_all.shape[2])
else:
linked_data_time = data_split[:,
int(overlap /
2):int(-overlap / 2), :].reshape(
-1, data_split.shape[2])
linked_data_hat_time = data_hat[:,
int(overlap /
2):int(-overlap / 2), :].reshape(
-1, data_hat.shape[2])
linked_data_masked_ignore_zero_all = \
data_masked_ignore_zero_all[:, int(overlap / 2):int(-overlap / 2), :].reshape(-1, data_masked_ignore_zero_all.shape[2])
linked_mask_matrix_all = mask_matrix_all[:,
int(overlap /
2):int(-overlap /
2), :].reshape(
-1,
mask_matrix_all
.shape[2])
#%% 9 Save results
results = {
'data_split': data_split,
'data_hat': data_hat,
'data_masked_ignore_zero_all': data_masked_ignore_zero_all,
'mask_matrix_all': mask_matrix_all,
'weights_complex': weights_complex,
'recon_error_time_domain': recon_error_time_domain,
'recon_error_freq_domain': recon_error_freq_domain,
'linked_data_time': linked_data_time,
'linked_data_hat_time': linked_data_hat_time,
'linked_data_masked_ignore_zero_all':
linked_data_masked_ignore_zero_all,
'linked_mask_matrix_all': linked_mask_matrix_all
}
# Collect metrics for parallel plot
collect_results_folder = 'collect_results/'
collect_results_file = 'collect_results'
create_folder(result_path + collect_results_folder)
recon_error_time_domain_mean_all = float(np.mean(recon_error_time_domain))
with open(
result_path + collect_results_folder + collect_results_file +
'.txt', 'a+') as f:
f.write('%5.2f, %03d, %03d, %02d, %04d, %7.5f\n' %
(regularizer_weight, batch_size, harmonic_wavelet_interval,
loss_weight_rate, epochs, recon_error_time_domain_mean_all))
f.close()
# Save metrics in txt locally
np.savetxt(result_path + result_folder + result_file + '.txt',
recon_error_time_domain * 100,
fmt='%.2f',
header='row: slice, column: channel')
print('\nResults metrics saved in: ' + result_file + '.txt')
# Save results file locally
with open(result_path + result_folder + result_file + '.pickle',
'wb') as f:
pickle.dump(results, f)
f.close()
print('\nResults saved in: ' + result_file + '.pickle')
hdf5storage.savemat(result_path + result_folder + result_file + '.mat',
results)
print('\nResults saved in: ' + result_file + '.mat')
K.clear_session()
# Remove empty data
idx = np.logical_or(np.isnan(load), np.isinf(load))
load[idx] = 0.0
idx = load < 0.0
load[idx] = 0.0
# Get zip for each user in the group
zipcodes = user_to_zip[num_users_per_grp * (group_idx - 1):num_users_per_grp * (group_idx)]
print 'calculating xTemp for all zipcodes.'
xTemp_by_hour = {}
for h in hours:
xTemp_by_hour[h] = {}
for zipcode in df_tempByZip.keys():
serie = np.array(df_tempByZip[zipcode][:])
matrixTemp = view_as_windows(serie, window_shape)
for h in hours:
xTemp_by_hour[h][int(zipcode)] = matrixTemp[:-h, :]
print 'finished all xTemp'
for typeModel in typeModels:
pathForecast = join(working_dir,
typeModel,
str(dates[-1].month) + '_' + str(dates[-1].year),
'user_grp_' + str(group_idx))
if not os.path.exists(pathForecast):
os.makedirs(pathForecast)
truePath = join(working_dir,
def test_view_as_windows_window_too_large():
A = np.arange(10)
view_as_windows(A, (11, ))
train_images, train_labels, test_images, test_labels, class_list = data.import_data(F.useclasses)
GetKernel(train_images, train_labels, class_list,
'./weight/pca_params_compact_inv.pkl')
'''
fr = open('./weight/pca_params_compact_inv.pkl', 'rb')
pca_params = pickle.load(fr)
fr.close()
k0 = np.array(pca_params['Layer_0/kernel'])
k1 = np.array(pca_params['Layer_1/kernel'])
b1 = pca_params['Layer_1/bias'].astype(np.float32)
# read image and get features
img = cv2.imread('4.png', 0)
patch = view_as_windows(img, (4, 4), step=(4, 4)).reshape(8, 8, 1 * 4 * 4)
patch = np.dot(patch, np.transpose(k0))
patch = view_as_windows(patch.copy(), (4, 4, 1), step=(4, 4, 1))
patch = patch.reshape(2, 2, s1 * 16)
patch = patch + 1 / np.sqrt(s1 * s2) * b1
patch = np.dot(patch, np.transpose(k1))
# inverse transforation
ipatch = np.dot(patch, LA.pinv(np.transpose(k1)))
ipatch = ipatch - 1 / np.sqrt(s1 * s2) * b1
ipatch = ipatch.reshape(2, 2, s1, 16)
ipatch = np.moveaxis(ipatch, 2, 3)
xx = np.zeros((8, 8, s1))
for i in range(0, 2):
for j in range(0, 2):
for k in range(0, 16):
nUsers = words.shape[0]
window_shape = (window_size,)
stepAhead = 24
ini_users=int(sys.argv[1])
end_users = int(sys.argv[2])
sizeSerie = words.shape[1] - (window_size + stepAhead - 1)
# in order to run it in many instances
#meterToXTest = np.empty((nUsers, sizeTest, window_size), dtype=np.int16)
meterToXTest = np.empty((end_users-ini_users, sizeTest, window_size), dtype=np.int16)
for u in xrange(ini_users,end_users):
serie = words[u, :]
xLoad = (view_as_windows(serie, window_shape))[:-stepAhead, :]
yLoad24 = np.empty((serie.size - (window_size + stepAhead - 1), stepAhead), dtype=np.int16)
yLoad24[:, -1] = serie[(window_size + stepAhead - 1):]
for i in xrange(stepAhead - 1):
yLoad24[:, i] = serie[(window_size + i):-(stepAhead - (i + 1))]
#meterToXTest[u] = xLoad[yTrain_idx == 0, :]
meterToXTest[u-ini_users] = xLoad[yTrain_idx==0, :]
#-----------------------------
print('removing words from memory')
del words
#-----------------------------
# test
print('starting test...')
#shapeYtest=(nUsers, sizeTest, stepAhead)
shapeYtest=(end_users-ini_users, sizeTest, stepAhead)
meterToYTest_pred=np.empty(shapeYtest,dtype=np.int16)
import matplotlib.pyplot as plt from skimage import data from skimage import color from skimage.util.shape import view_as_windows from skimage.util import montage np.random.seed(42) patch_shape = 8, 8 n_filters = 49 astro = color.rgb2gray(data.astronaut()) # -- filterbank1 on original image patches1 = view_as_windows(astro, patch_shape) patches1 = patches1.reshape(-1, patch_shape[0] * patch_shape[1])[::8] fb1, _ = kmeans2(patches1, n_filters, minit='points') fb1 = fb1.reshape((-1,) + patch_shape) fb1_montage = montage(fb1, rescale_intensity=True) # -- filterbank2 LGN-like image astro_dog = ndi.gaussian_filter(astro, .5) - ndi.gaussian_filter(astro, 1) patches2 = view_as_windows(astro_dog, patch_shape) patches2 = patches2.reshape(-1, patch_shape[0] * patch_shape[1])[::8] fb2, _ = kmeans2(patches2, n_filters, minit='points') fb2 = fb2.reshape((-1,) + patch_shape) fb2_montage = montage(fb2, rescale_intensity=True) # -- plotting fig, axes = plt.subplots(2, 2, figsize=(7, 6))
def testImage(imagePath, decisionThreshold = cfg.decision_threshold, applyNMS=True):
fileList = os.listdir(cfg.modelRootPath)
# Filter all model files
modelsList = filter(lambda element: '.model' in element, fileList)
# Filter our specific feature method
currentModel = cfg.model+'_'+cfg.modelFeatures
currentModelsList = filter(lambda element: currentModel in element, modelsList)
models = []
subImages = [] #To save backgorund crops
for modelname in currentModelsList:
file = open(cfg.modelRootPath + modelname, 'r')
svc = pickle.load(file)
models.append(svc)
file.close()
image = io.imread(imagePath, as_grey=True)
image = util.img_as_ubyte(image) #Read the image as bytes (pixels with values 0-255)
rows, cols = image.shape
pyramid = tuple(pyramid_gaussian(image, downscale=cfg.downScaleFactor))
scale = 0
boxes = None
scores = None
for p in pyramid[0:]:
#We now have the subsampled image in p
window_shape = (32,32)
#Add padding to the image, using reflection to avoid border effects
if cfg.padding > 0:
p = pad(p,cfg.padding,'reflect')
try:
views = view_as_windows(p, window_shape, step=cfg.window_step)
except ValueError:
#block shape is bigger than image
break
num_rows, num_cols, width, height = views.shape
for row in range(0, num_rows):
for col in range(0, num_cols):
#Get current window
subImage = views[row, col]
# subImages.append(subImage) #To save backgorund crops: Accumulate them in an array
#Extract features
feats = feature_extractor.extractFeatures(subImage)
#Obtain prediction score for each model
for model in models:
decision_func = model.decision_function(feats)
# if decision_func > decisionThreshold:
if decision_func > 0.2: #For bootstrapping
# Signal found!
h, w = window_shape
scaleMult = math.pow(cfg.downScaleFactor, scale)
x1 = int(scaleMult * (col*cfg.window_step - cfg.padding + cfg.window_margin))
y1 = int(scaleMult * (row*cfg.window_step - cfg.padding + cfg.window_margin))
x2 = int(x1 + scaleMult*(w - 2*cfg.window_margin))
y2 = int(y1 + scaleMult*(h - 2*cfg.window_margin))
#bootstrapping: Save image (if positive)
subImages.append(subImage)
bbox = (x1, y1, x2, y2)
score = decision_func[0]
if boxes is not None:
boxes = np.vstack((bbox, boxes))
scores = np.hstack((score, scores))
else:
boxes = np.array([bbox])
scores = np.array([score])
break
scale += 1
# To save backgorund crops
# numSubImages = len(subImages)
# for x in range(0,10): #Save 10 crops for each background image
# randomIndex = random.randint(1,numSubImages-1) #Get a random window index
# imageName = imagePath.split('/') #Working on the crop name...
# imageName = imageName[len(imageName)-1]
# filename = (imageName[:-4]+'-'+str(x)+'.jpg')
# io.imsave('Results/'+filename, subImages[randomIndex]) #Save the crop
#end To save backgorund crops
# To save bootstrapping windows
numSubImages = len(subImages)
length = min(10, len(subImages))
for x in range(0,length) : #Save windows with detections (max 10)
if numSubImages == 1:
randomIndex = 0
else:
randomIndex = random.randint(1, numSubImages-1) #Get a random window index
imageName = imagePath.split('/') #Working on the crop name...
imageName = imageName[len(imageName)-1]
filename = (imageName[:-4]+'-'+str(x)+'.jpg')
io.imsave('Bootstrapping/'+filename, subImages[randomIndex]) #Save the crop
#end To save bootstrapping windows
if applyNMS:
#From all the bounding boxes that are overlapping, take those with maximum score.
boxes, scores = nms.non_max_suppression_fast(boxes, scores, cfg.nmsOverlapThresh)
return boxes, scores
# im_, gt_ = 'PaviaU', 'PaviaU_gt'
# im_, gt_ = 'Salinas_corrected', 'Salinas_gt'
# im_, gt_ = 'Botswana', 'Botswana_gt'
# im_, gt_ = 'KSC', 'KSC_gt'
img_path = root + im_ + '.mat'
gt_path = root + gt_ + '.mat'
print(img_path)
p = Processor()
img, gt = p.prepare_data(img_path, gt_path)
# Img, Label = Img[:256, :, :], Label[:256, :]
n_row, n_column, n_band = img.shape
X_img = minmax_scale(img.reshape(n_row * n_column, n_band)).reshape(
(n_row, n_column, n_band))
img_block = view_as_windows(X_img, (7, 7, n_band), step=1)
# img_block_2 = view_as_windows(X_img, (32, 32, n_band), step=6)
img_block = img_block.reshape(
(-1, img_block.shape[-3], img_block.shape[-2], img_block.shape[-1]))
# img_block_2 = img_block_2.reshape((-1, img_block_2.shape[-3], img_block_2.shape[-2], img_block_2.shape[-1]))
print('img block shape: ', img_block.shape)
# img_blocks_nonzero, gt_blocks_nonzero = p.divide_img_blocks(X_img, gt, block_size=(8, 8))
# img_blocks_nonzero = np.transpose(img_blocks_nonzero, [0, 2, 3, 1]).astype('float32')
# print(img_blocks_nonzero.shape)
LR, BATCH_SIZE, EPOCH = 0.0005, 16, 100
N_BAND = 25
time_start = time.clock()
acnn = BS_Net_Conv(LR, BATCH_SIZE, EPOCH, N_BAND)