def frt_gpu(self, A0: np.ndarray, d1: float, z: float):
"""
Implements propagation using Fresnel diffraction. Runs on a GPU using CuPy with a CUDA backend.
:param A0: Field to propagate
:param d1: Sampling size of the field A0
:param z : Propagation distance in metres
:return: A : Propagated field
"""
wv = self.wavelength
k = 2 * np.pi / wv
N = A0.shape[0]
x = cp.linspace(0, N - 1, N) - (N / 2) * cp.ones(N)
y = cp.linspace(0, N - 1, N) - (N / 2) * cp.ones(N)
d2 = wv * z / (N * d1)
X1, Y1 = d1 * cp.meshgrid(x, y)[0], d1 * cp.meshgrid(x, y)[1]
X2, Y2 = d2 * cp.meshgrid(x, y)[0], d2 * cp.meshgrid(x, y)[1]
R1 = cp.sqrt(X1**2 + Y1**2)
R2 = cp.sqrt(X2**2 + Y2**2)
D = 1 / (1j * wv * abs(z))
Q1 = cp.exp(1j * (k / (2 * z)) * R1**2)
Q2 = cp.exp(1j * (k / (2 * z)) * R2**2)
if z >= 0:
A = D * Q2 * (d1**2) * cp.fft.fftshift(
cp.fft.fft2(cp.fft.ifftshift(A0 * Q1), norm='ortho'))
elif z < 0:
A = D * Q2 * ((N * d1)**2) * cp.fft.fftshift(
cp.fft.ifft2(cp.fft.ifftshift(A0 * Q1), norm='ortho'))
return A
def local_cov_bet_class_NN(self,key,label,nb_class,batchsize,k):
key_broadcast=cp.broadcast_to(key,(batchsize,batchsize,key.shape[1]))
key_broadcast_transpose=cp.transpose(cp.broadcast_to(key,(batchsize,batchsize,key.shape[1])),axes=(1,0,2))
sub_key_broadcast=key_broadcast-key_broadcast_transpose
norm_sub_broadcast=cp.linalg.norm(sub_key_broadcast,axis=2)
sorted_d=cp.sort(norm_sub_broadcast,axis=0)
kth_d=sorted_d[k]
kth_d=kth_d.reshape([batchsize,1])
sigma=cp.matmul(kth_d,cp.transpose(kth_d))
batchsize_per_class=batchsize//nb_class
index=cp.arange(key.shape[0])
xx,yy=cp.meshgrid(index,index)
sub=key[xx]-key[yy]
norm_sub=cp.linalg.norm(sub,axis=2)
a1=cp.exp(-norm_sub*norm_sub/sigma)
lindex=cp.arange(label.shape[0])
lx,ly=cp.meshgrid(lindex,lindex)
l=(label[lx]==label[ly])
a1=a1*l*(1.0/(batchsize*nb_class)-1.0/batchsize_per_class)
l2=(label[lx]!=label[ly])
a2=l2*(1.0/batchsize)
a=a1+a2
a=a.reshape([a.shape[0],a.shape[1],1])
a_sub=a*sub
Sb=cp.einsum('ijk,ijl->kl',a_sub,sub,dtype='float32')*0.5
return Sb
def local_cov_in_class(self,key,label,nb_class,batchsize):
index = cp.arange(key.shape[0])
xx,yy = cp.meshgrid(index,index)
sub = key[xx] - key[yy]
norm_sub = cp.linalg.norm(sub,axis=2)
a = cp.exp(-norm_sub*norm_sub/100)
lindex = cp.arange(label.shape[0])
lx,ly = cp.meshgrid(lindex,lindex)
l = (label[lx]==label[ly])
a = a*l
Sw = cp.einsum('ij,ijk,ijl->kl',a,sub,sub,dtype='float32')*0.5*(1.0/batchsize)
return Sw
def local_cov_in_class(self,key,label,nb_class,batchsize,affinity):
batchsize_per_class=batchsize//nb_class
index = cp.arange(key.shape[0])
xx,yy=cp.meshgrid(index,index)
sub=key[xx]-key[yy]
norm_sub=cp.linalg.norm(sub,axis=2)
a=cp.exp(-norm_sub*norm_sub*affinity)
lindex=cp.arange(label.shape[0])
lx,ly=cp.meshgrid(lindex,lindex)
l=(label[lx]==label[ly])
a=a*l
a=a.reshape([a.shape[0],a.shape[1],1])
a_sub=a*sub
Sw=cp.einsum('ijk,ijl->kl',a_sub,sub,dtype='float32')*0.5*(1.0/batchsize_per_class)
return Sw
def calHampkernel(self):
prefactor = 1 / (4 * math.pi)
dx = self.lcx
dy = self.lcy
dz = self.lcz
a1 = (np.array(range(2 * self.nx - 1)) - self.nx + 1) * dx
a2 = (np.array(range(2 * self.ny - 1)) - self.ny + 1) * dy
a3 = (np.array(range(2 * self.nz - 1)) - self.nz + 1) * dz
a3, a2, a1 = np.meshgrid(a3, a2, a1, sparse=False, indexing='ij')
print('Start calculating demag factors')
Kxy_val = self.Kxy(a1, a2, a3, dx, dy, dz)
Kxz_val = self.Kxz(a1, a2, a3, dx, dy, dz)
Kyz_val = self.Kyz(a1, a2, a3, dx, dy, dz)
print('End calculating demag factors')
self.Ktotxy = prefactor * Kxy_val
self.Ktotxz = prefactor * Kxz_val
self.Ktotyz = prefactor * Kyz_val
self.FKtotxy = np.fft.fftn(self.Ktotxy, axes=(0, 1, 2), norm=None)
self.FKtotxz = np.fft.fftn(self.Ktotxz, axes=(0, 1, 2), norm=None)
self.FKtotyz = np.fft.fftn(self.Ktotyz, axes=(0, 1, 2), norm=None)
def spatial_decode(self, latent, sigmoid=True):
image_size = 128
a = cp.linspace(-1, 1, image_size)
b = cp.linspace(-1, 1, image_size)
x, y = cp.meshgrid(a, b)
x = x.reshape(image_size, image_size, 1)
y = y.reshape(image_size, image_size, 1)
batchsize = len(latent)
xy = cp.concatenate((x, y), axis=-1)
xy_tiled = cp.tile(xy, (batchsize, 1, 1, 1)).astype(cp.float32)
latent_tiled = F.tile(latent, (1, 1, image_size * image_size)).reshape(
batchsize, image_size, image_size, self.latent_n)
latent_and_xy = F.concat((latent_tiled, xy_tiled), axis=-1)
latent_and_xy = F.swapaxes(latent_and_xy, 1, 3)
sp_3_decoded = F.relu(self.sp_dec_3(latent_and_xy))
sp_2_decoded = F.relu(self.sp_dec_2(sp_3_decoded))
sp_1_decoded = F.relu(self.sp_dec_1(sp_2_decoded))
out_img = self.sp_dec_0(sp_1_decoded)
# need the check because the bernoulli_nll has a sigmoid in it
if sigmoid:
return F.sigmoid(out_img)
else:
return out_img
def get_measurement_matrix(self,ix,iy):
shifted_theta = self.theta+self.theta[1]
theta_grid,r_grid = cp.meshgrid(shifted_theta*util.PI/180,self.r) #Because theta will be on the x axis, and r will be on the y axis
# theta_grid = theta_grid[:,::-1]
H = cp.zeros((r_grid.size,ix.size),dtype=cp.complex64)
if not self.use_skimage:
#launch CUDA kernel
if cuda.is_available():
bpg=((H.shape[0]+TPBn-1)//TPBn,(H.shape[1]+TPBn-1)//TPBn)
print("Cuda is available, now running CUDA kernel with Thread perblock = {}, Block Per Grids = {}, and H shape {}".format(TPB,bpg,H.shape))
util._calculate_H_Tomography[bpg,TPB](r_grid.ravel(ORDER),theta_grid.ravel(ORDER),ix,iy,H)
ratio = self.n_r/(2*(self.n_r//2))
H *= ratio
#Some Temporary Fixing
nPart=4
n_theta = self.n_theta
n_r = self.n_r
for i in range(n_theta//nPart):
H[i*n_r:(i+1)*n_r,:] = cp.roll(H[i*n_r:(i+1)*n_r,:],1,axis=0)
# util.calculate_H_Tomography(r_grid.ravel(ORDER),theta_grid.ravel(ORDER),ix,iy,H)
#due to some problem the resulted H is flipped upside down
#hence
# H = cp.flipud(H)
# norm_ratio = (self.n_r/2)/(self.n_r//2)
else:
H_n = cp.asnumpy(H)
util.calculate_H_Tomography_skimage(cp.asnumpy(self.theta),cp.asnumpy(ix),cp.asnumpy(iy),H_n,self.target_image.shape[0])
H = cp.asarray(H_n)
return H.astype(cp.complex64)
def transform_affine(volume, ref_shape, affine, order=1):
ndim = volume.ndim
affine = cupy.asarray(affine)
if True:
out = ndi.affine_transform(
volume,
matrix=affine,
order=order,
mode="constant",
output_shape=tuple(ref_shape),
)
else:
# use map_coordinates instead of affine_transform
xcoords = cupy.meshgrid(
*[cupy.arange(s, dtype=volume.dtype) for s in ref_shape],
indexing="ij",
sparse=True,
)
coords = _apply_affine_to_field(
xcoords,
affine[:ndim, :],
include_translations=True,
coord_axis=0,
)
out = ndi.map_coordinates(volume, coords, order=1)
return out
def spherical_cosmask(n,mask_radius, edge_width, origin=None):
"""mask = spherical_cosmask(n, mask_radius, edge_width, origin)
"""
if type(n) is int:
n = np.array([n])
sz = np.array([1, 1, 1])
sz[0:np.size(n)] = n[:]
szl = -np.floor(sz/2)
szh = szl + sz
x,y,z = np.meshgrid( np.arange(szl[0],szh[0]),
np.arange(szl[1],szh[1]),
np.arange(szl[2],szh[2]), indexing='ij', sparse=True)
r = np.sqrt(x*x + y*y + z*z)
m = np.zeros(sz.tolist())
# edgezone = np.where( (x*x + y*y + z*z >= mask_radius) & (x*x + y*y + z*z <= np.square(mask_radius + edge_width)))
edgezone = np.all( [ (x*x + y*y + z*z >= mask_radius), (x*x + y*y + z*z <= np.square(mask_radius + edge_width))], axis=0)
m[edgezone] = 0.5 + 0.5*np.cos( 2*np.pi*(r[edgezone] - mask_radius) / (2*edge_width))
m[ np.all( [ (x*x + y*y + z*z <= mask_radius*mask_radius) ], axis=0 ) ] = 1
# m[ np.where(x*x + y*y + z*z <= mask_radius*mask_radius)] = 1
return m
def centerCBED(data4D_flat, x_cen, y_cen, chunks=8):
stops = np.zeros(chunks + 1, dtype=np.int)
stops[0:chunks] = np.arange(0, data4D_flat.shape[0],
(data4D_flat.shape[0] / chunks))
stops[chunks] = data4D_flat.shape[0]
max_size = int(np.amax(np.diff(stops)))
centered4D = np.zeros_like(data4D_flat)
image_size = np.asarray(data4D_flat.shape[1:3])
fourier_cal_y = (cp.linspace(
(-image_size[0] / 2),
((image_size[0] / 2) - 1), image_size[0])) / image_size[0]
fourier_cal_x = (cp.linspace(
(-image_size[1] / 2),
((image_size[1] / 2) - 1), image_size[1])) / image_size[1]
[fourier_mesh_x, fourier_mesh_y] = cp.meshgrid(fourier_cal_x,
fourier_cal_y)
move_pixels = np.flip(image_size / 2) - np.asarray((x_cen, y_cen))
move_phase = cp.exp(
(-2) * np.pi * 1j * ((fourier_mesh_x * move_pixels[0]) +
(fourier_mesh_y * move_pixels[1])))
for ii in range(chunks):
startval = stops[ii]
stop_val = stops[ii + 1]
gpu_4Dchunk = cp.asarray(data4D_flat[startval:stop_val, :, :])
FFT_4D = cp.fft.fftshift(cp.fft.fft2(gpu_4Dchunk, axes=(-1, -2)),
axes=(-1, -2))
FFT_4Dmove = cp.absolute(
cp.fft.ifft2(cp.multiply(FFT_4D, move_phase), axes=(-1, -2)))
centered4D[startval:stop_val, :, :] = cp.asnumpy(FFT_4Dmove)
del FFT_4D, gpu_4Dchunk, FFT_4Dmove, move_phase, fourier_cal_y, fourier_cal_x, fourier_mesh_x, fourier_mesh_y
return centered4D
def __init__(self,
file_name,
target_size=128,
stdev=0.1,
relative_location=""):
self.globalprefix = pathlib.Path.cwd() / relative_location
if not self.globalprefix.exists():
self.globalprefix.mkdir()
self.file_name = self.globalprefix / file_name
if target_size > 512:
raise Exception("Target image dimension are too large (" +
str(target_size) + " x " + str(target_size) + ")")
self.dim = target_size
self.stdev = stdev
img = imread(self.file_name.absolute(), as_gray=True)
if (img.shape[0] != img.shape[1]):
raise Exception("Image is not square")
self.target_image = resize(img, (self.dim, self.dim),
anti_aliasing=False,
preserve_range=True,
order=1,
mode='symmetric')
self.target_image = cp.asarray(self.target_image, dtype=cp.float32)
self.corrupted_image = self.target_image + self.stdev * cp.random.randn(
self.target_image.shape[0],
self.target_image.shape[1],
dtype=cp.float32)
self.v = self.target_image.ravel(ORDER) / self.stdev #Normalized
self.y = self.corrupted_image.ravel(ORDER) / self.stdev #Normalized
self.num_sample = self.y.size
temp = cp.linspace(0., 1., num=self.dim, endpoint=True)
ty, tx = cp.meshgrid(temp, temp)
self.ty = ty.ravel(ORDER)
self.tx = tx.ravel(ORDER)
def _sin_flow_gen(image0, max_motion=4.5, npics=5):
"""Generate a synthetic ground truth optical flow with a sinusoid as
first component.
Parameters:
----
image0: ndarray
The base image to be warped.
max_motion: float
Maximum flow magnitude.
npics: int
Number of sinusoid pics.
Returns
-------
flow, image1 : ndarray
The synthetic ground truth optical flow with a sinusoid as
first component and the corresponding warped image.
"""
grid = cp.meshgrid(*[cp.arange(n) for n in image0.shape], indexing='ij')
grid = cp.stack(grid)
# TODO: make upstream scikit-image PR changing gt_flow dtype to float
gt_flow = cp.zeros_like(grid, dtype=float)
gt_flow[0,
...] = max_motion * cp.sin(grid[0] / grid[0].max() * npics * np.pi)
image1 = warp(image0, grid - gt_flow, mode="nearest")
return gt_flow, image1
def getShapeMatrix(ro=1.3, N=1000, gpu=False):
if gpu:
import cupy as np
else:
import numpy as np
def f(ro, N):
''' give the surface map matrix '''
# polar coordinate
theta = np.linspace(0, 2 * np.pi, N)
x = ro * np.cos(theta)
y = ro * np.sin(theta)
u, v = np.meshgrid(x, y)
RO = u**2 + v**2
# map z to u,v
Z = 1 - u / RO - RO
return x, y, Z
x, y, Z = f(ro, N)
# remap z to the grid index
index_x, index_y = np.argsort(x), np.argsort(y)
Y, X = np.meshgrid(
index_x,
index_y) # meshgrid always will use numpy array NOT mxnet NDArray
Z = Z[X, Y]
return Z
def movepixels_3d(self, Iin, Tx):
'''
This function will translate the pixels of an image
according to Tx translation images.
Inputs;
Tx: The transformation image, dscribing the
(backwards) translation of every pixel in the x direction.
Outputs,
Iout : The transformed image
'''
nx, ny, nz = Iin.shape
tmpx = cp.linspace(0, nx - 1, num=nx, dtype=np.float32)
tmpy = cp.linspace(0, ny - 1, num=ny, dtype=np.float32)
tmpz = cp.linspace(0, nz - 1, num=nz, dtype=np.float32)
x, y, z = cp.meshgrid(tmpx, tmpy, tmpz, indexing='ij')
Tlocalx = cp.expand_dims(x + Tx, axis=0)
y = cp.expand_dims(y, axis=0)
z = cp.expand_dims(z, axis=0)
coordinates = cp.vstack((Tlocalx, y, z))
return map_coordinates(Iin, coordinates, order=1, cval=0)
def transform_affine(volume, ref_shape, affine, order=1):
from cupyimg.scipy.ndimage._kernels import interp
ndim = volume.ndim
legacy_mode = interp.const_legacy_mode
interp.const_legacy_mode = False
try:
affine = cupy.asarray(affine)
if True:
out = ndi.affine_transform(
volume,
matrix=affine,
order=order,
mode="constant",
output_shape=tuple(ref_shape),
)
else:
# use map_coordinates instead of affine_transform
xcoords = cupy.meshgrid(
*[cupy.arange(s, dtype=volume.dtype) for s in ref_shape],
indexing="ij",
sparse=True,
)
coords = _apply_affine_to_field(
xcoords,
affine[:ndim, :],
include_translations=True,
coord_axis=0,
)
out = ndi.map_coordinates(volume, coords, order=1)
finally:
interp.const_legacy_mode = legacy_mode
return out
def get_perlin_init(shape=(1000, 1000),
n=100000,
cutoff=None,
repetition=(1000, 1000),
scale=100,
octaves=20.0,
persistence=0.1,
lacunarity=2.0):
"""Returns a tuple of x,y-coordinates sampled from Perlin noise.
This can be used to initialize the starting positions of a physarum-
population, as well as to generate a cloudy feeding-pattern that will
have a natural feel to it. This function wraps the one from the noise-
library from Casey Duncan, and is in parts borrowed from here (see also this for a good explanation of the noise-parameters):
https://medium.com/@yvanscher/playing-with-perlin-noise-generating-realistic-archipelagos-b59f004d8401
The most relevant paramaters for our purposes are:
:param shape: The shape of the area in which the noise is to be generated. Defaults to (1000,1000)
:type shape: Tuple of integers with the form (width, height).
:param n: Number of particles to sample. When used as a feeeding trace,
this translates to the relative strength of the pattern. defaults to 100000.
:param cutoff: value below which noise should be set to zero. Default is None. Will lead to probabilities 'contains NaN-error, if to high'
:param scale: (python-noise parameter) The scale of the noise -- larger or smaller patterns, defaults to 100.
:param repetition: (python-noise parameter) Tuple that denotes the size of the area in which the noise should repeat itself. Defaults to (1000,1000)
"""
import numpy as np
import cupy as cp # vectorized not present in cupy, so for now to conversion at the end
shape = [i - 1 for i in shape]
# make coordinate grid on [0,1]^2
x_idx = np.linspace(0, shape[0], shape[0])
y_idx = np.linspace(0, shape[1], shape[1])
world_x, world_y = np.meshgrid(x_idx, y_idx)
# apply perlin noise, instead of np.vectorize, consider using itertools.starmap()
world = np.vectorize(noise.pnoise2)(
world_x / scale,
world_y / scale,
octaves=int(octaves),
persistence=persistence,
lacunarity=lacunarity,
repeatx=repetition[0],
repeaty=repetition[1],
base=np.random.randint(0, 100),
)
# world = world * 3
# Sample particle init from map:
world[world <= 0.0] = 0.0 # filter negative values
if cutoff is not None:
world[world <= cutoff] = 0.0
linear_idx = np.random.choice(world.size,
size=n,
p=world.ravel() / float(world.sum()))
x, y = np.unravel_index(linear_idx, shape)
x = x.reshape(-1, 1)
y = y.reshape(-1, 1)
return cp.asarray(np.hstack([x, y]))
def initCoords(self):
size=self.vol_dim[0]/2
x, y=np.meshgrid(np.arange(-size+1,size+1),np.arange(-size+1,size+1))
#temp=np.arctan2(y, x)
#temp=np.reshape(temp,(size*2,size*2,1))
#self.radmatrix=np.repeat(temp, size*2, axis=2)
self.radmatrix=np.remainder(np.arctan2(x, y)+2*np.pi,2*np.pi)-2*np.pi
self.zline=np.arange(-size+1,size+1)
def reshape(self, bottom, top): outer_num = bottom[0].data.shape[0] channel = bottom[0].data.shape[1] height,width = bottom[0].data.shape[2],bottom[0].data.shape[3] self.index_0 = cp.arange(outer_num).reshape([outer_num,1,1,1]) self.index_3,self.index_2 = cp.meshgrid(cp.arange(width),cp.arange(height)) top[0].reshape(1)
def test_lab_full_gamut(self):
a, b = cp.meshgrid(cp.arange(-100, 100), cp.arange(-100, 100))
L = cp.ones(a.shape)
lab = cp.dstack((L, a, b))
for value in [0, 10, 20]:
lab[:, :, 0] = value
with expected_warnings(['Color data out of range']):
lab2xyz(lab)
def set_args(self, dtype):
coords = cp.meshgrid(
*[cp.linspace(0, 6 * cp.pi, s) for s in self.shape], sparse=True)
bumps = functools.reduce(operator.add, [cp.sin(c) for c in coords])
h = 0.6
seed = bumps - h
self.args_cpu = (cp.asnumpy(seed), cp.asnumpy(bumps))
self.args_gpu = (seed, bumps)
def adj(self, coeffs, shifts=None):
"""Adjoint operator for GWP decomposition
Parameters
----------
coeffs : [K](Nangles,L0,L1) complex64
Decomposition coefficients for box levels 0:K, angles 0:Nangles,
defined box grids with sizes [L0[k],L1[k]], k=0:K
Returns
-------
f : [N,N] complex64
2D function in the space domain
"""
print('adj transform')
# build spectrum by using gwp coefficients
F = cp.zeros(self.fgridshape, dtype="complex64")
# loop over box orientations
for ang in range(0, self.nangles):
print('angle', ang)
g = cp.zeros(int(np.prod(self.boxshape[-1])), dtype='complex64')
for k in range(self.K):
fcoeffs = cp.array(coeffs[k][ang])
# normalize
fcoeffs /= (np.prod(self.boxshape[-1]))
if(shifts is not None):
# shift wrt region in rectangular grid
fcoeffs = util.checkerboard(cp.fft.fftn(
util.checkerboard(fcoeffs), norm='ortho'), inverse=True)
[py, px] = cp.meshgrid(
self.phasemanyy[k]*shifts[ang, k, 0], self.phasemanyx[k]*shifts[ang, k, 1], indexing='ij')
fcoeffs *= cp.exp(1j*(px+py))
fcoeffs = util.checkerboard(cp.fft.ifftn(
util.checkerboard(fcoeffs), norm='ortho'), inverse=True)
# shift wrt xi_cent
fcoeffs *= cp.exp(1j*self.phase[k])
fcoeffs = util.checkerboard(cp.fft.fftn(
util.checkerboard(fcoeffs), norm='ortho'), inverse=True)
# broadcast values to smaller boxes, multiply by the gwp kernel function
g[self.inds[k]] += self.gwpf[k]*fcoeffs.flatten()
g = g.reshape(self.boxshape[-1])
# 2) Interpolation to the global grid
# Conventional scattering operation from the global to local grid is replaced
# by an equivalent gathering operation.
# calculate global grid coordinates in the space domain
xr = self.coordinates_adj(ang)
# extract ids of the global spectrum subregion contatining the box
[idsy, idsx] = self.subregion_ids(ang)
# gathering to the global grid
F[cp.ix_(idsy, idsx)] += self.U.gather(g, xr,
g.shape).reshape(len(idsy), len(idsx))
# util.mplt(F)
# 3) apply 2D IFFT, compensate for the USFFT kernel function in the space domain
f = self.U.ifftcomp(
F.reshape(self.fgridshape)).get().astype('complex64')
# free cupy pools
# mempool.free_all_blocks()
# pinned_mempool.free_all_blocks()
return f
def calc_theta_tx(self, tx_ant):
x, y = cp.meshgrid(tx_ant.x_position, tx_ant.y_position)
# ブロードキャストを使って30x30に各受信点からの角度(shape=7)を格納
rx_x = self.x_position[cp.newaxis, cp.newaxis, :] # shape=1,1,7
rx_y = self.y_position[cp.newaxis, cp.newaxis, :] # shape=1,1,7
x_diff = rx_x - x[:, :, cp.newaxis] # shape=30,30,7
y_diff = rx_y - y[:, :, cp.newaxis] # shape=30,30,7
theta = cp.arctan(y_diff / x_diff)
return theta
def calc_rad(size, binning, return_float=False):
'''Calculate radius and binned radius of 3D grid of voxels with given size'''
cen = size // 2
ind = np.arange(size, dtype='f4') - cen
x, y, z = np.meshgrid(ind, ind, ind, indexing='ij')
rad = np.sqrt(x * x + y * y + z * z)
if return_float:
return rad
return np.rint(rad / binning).astype('i4')
def local_cov_bet_class(self,key,label,nb_class,batchsize):
index = cp.arange(key.shape[0])
xx,yy = cp.meshgrid(index,index)
sub = key[xx] - key[yy]
norm_sub = cp.linalg.norm(sub,axis=2)
a1= cp.exp(-norm_sub*norm_sub/100)
lindex = cp.arange(label.shape[0])
lx,ly = cp.meshgrid(lindex,lindex)
l = (label[lx]==label[ly])
a1 = a1*l*(1.0/(batchsize*nb_class)-1.0/batchsize)
l2 = (label[lx]!=label[ly])
a2 = l2*(1.0/(nb_class*batchsize))
a=a1+a2
Sb = cp.einsum('ij,ijk,ijl->kl',a,sub,sub,dtype='float32')*0.5
return Sb
def LoadLFs5K():
print("LoadLFs5K...\n")
x = cp.arange(Params.HEIGHT)
y = cp.arange(Params.WIDTH)
TY, TX = cp.meshgrid(x, y)
TX = TX.reshape(-1, 1)
TY = TY.reshape(-1, 1)
LF = [[], []]
for i in range(0, len(LF)):
LF[i] = cp.zeros(3 * Params.LFU_W * Params.HEIGHT * Params.WIDTH * 3,
'uint8')
for n in range(1, Params.LFU_W * 3 + 1):
if (i == 0):
file = '%s/00/%04d.jpeg' % (Params.cur_dir, n)
else:
file = '%s/02/%04d.jpeg' % (Params.cur_dir, n)
#img = Img.imread(file)
#for GPU
img = imresize(Img.imread(file),
output_shape=(Params.HEIGHT, Params.WIDTH))
#img = cv2.UMat(file)
img_C1 = img[:, :, 0]
img_C2 = img[:, :, 1]
img_C3 = img[:, :, 2]
nn = n - 1
img_C1 = img_C1.T
img_C1 = img_C1.reshape(-1, 1)
img_C2 = img_C2.T
img_C2 = img_C2.reshape(-1, 1)
img_C3 = img_C3.T
img_C3 = img_C3.reshape(-1, 1)
TX = TX.astype('int64')
TY = TY.astype('int64')
LF[i][(nn) * (Params.HEIGHT * Params.WIDTH * 3) + (TX) *
(Params.HEIGHT * 3) + (TY) * 3 + 3 - 1] = img_C1[:]
LF[i][(nn) * (Params.HEIGHT * Params.WIDTH * 3) + (TX) *
(Params.HEIGHT * 3) + (TY) * 3 + 2 - 1] = img_C2[:]
LF[i][(nn) * (Params.HEIGHT * Params.WIDTH * 3) + (TX) *
(Params.HEIGHT * 3) + (TY) * 3 + 1 - 1] = img_C3[:]
print(['LF', i, ' - ', n, ', ', nn])
return LF
def test_gaussian(self):
cx, cy = cp.meshgrid(cp.arange(5), cp.arange(5))
c = (cx.flatten(), cy.flatten())
cs_gauss = cp.asnumpy(gaussian_rect(self.som._neigx, self.som._neigy, self.som._std_coeff, c, 1))
for i in range(len(c[0])):
x = cp.asnumpy(c[0][i]).item()
y = cp.asnumpy(c[1][i]).item()
ms_gauss = self.minisom._gaussian((x,y), 1)
np.testing.assert_array_almost_equal(ms_gauss, cs_gauss[i])
def test_mexican_hat(self):
cx, cy = cp.meshgrid(cp.arange(5), cp.arange(5))
c = (cx.flatten(), cy.flatten())
cs_mex = cp.asnumpy(mexican_hat_generic(self.som._xx, self.som._yy, self.som._std_coeff, c, 1))
for i in range(len(c[0])):
x = cp.asnumpy(c[0][i]).item()
y = cp.asnumpy(c[1][i]).item()
ms_mex = self.minisom._mexican_hat((x,y), 1)
np.testing.assert_array_almost_equal(ms_mex, cs_mex[i])
def test_bubble(self):
cx, cy = cp.meshgrid(cp.arange(5), cp.arange(5))
c = (cx.flatten(), cy.flatten())
cs_mex = cp.asnumpy(bubble(self.som._neigx, self.som._neigy, c, 1))
for i in range(len(c[0])):
x = cp.asnumpy(c[0][i]).item()
y = cp.asnumpy(c[1][i]).item()
ms_mex = self.minisom._bubble((x,y), 1)
np.testing.assert_array_almost_equal(ms_mex, cs_mex[i])
def __init__(self,basis_number,extended_basis_number,t_start = 0,t_end=1,mempool=None):
self.basis_number = basis_number
self.extended_basis_number = extended_basis_number
self.basis_number_2D = (2*basis_number-1)*basis_number
self.basis_number_2D_ravel = (2*basis_number*basis_number-2*basis_number+1)
self.basis_number_2D_sym = (2*basis_number-1)*(2*basis_number-1)
self.extended_basis_number_2D = (2*extended_basis_number-1)*extended_basis_number
self.extended_basis_number_2D_sym = (2*extended_basis_number-1)*(2*extended_basis_number-1)
self.t_end = t_end
self.t_start = t_start
self.verbose = True
if mempool is None:
mempool = cp.get_default_memory_pool()
# pinned_mempool = cp.get_default_pinned_memory_pool()
# self.ix = cp.zeros((2*self.basis_number-1,2*self.basis_number-1),dtype=cp.int32)
# self.iy = cp.zeros((2*self.basis_number-1,2*self.basis_number-1),dtype=cp.int32)
temp = cp.arange(-(self.basis_number-1),self.basis_number,dtype=cp.int32)
# for i in range(2*self.basis_number-1):
# self.ix[i,:] = temp
# self.iy[:,i] = temp
self.ix,self.iy = cp.meshgrid(temp,temp)
if self.verbose:
print("Used bytes so far, after creating ix and iy {}".format(mempool.used_bytes()))
self.Ddiag = -(2*util.PI)**2*(self.ix.ravel(ORDER)**2+self.iy.ravel(ORDER)**2)
self.OnePerDdiag = 1/self.Ddiag
self.Dmatrix = cpx.scipy.sparse.diags(self.Ddiag,dtype=cp.float32)
if self.verbose:
print("Used bytes so far, after creating Dmatrix {}".format(mempool.used_bytes()))
# self.Imatrix = cp.eye((2*self.basis_number-1)**2,dtype=cp.int8)
self.Imatrix = cpx.scipy.sparse.identity((2*self.basis_number-1)**2,dtype=cp.float32)
self.Imatrix_dense = cp.eye((2*self.basis_number-1)**2,dtype=cp.float32)
if self.verbose:
print("Used bytes so far, after creating Imatrix {}".format(mempool.used_bytes()))
#K matrix --> 1D fourier index to 2D fourier index
ones_temp = cp.ones_like(temp)
self.Kmatrix = cp.vstack((cp.kron(temp,ones_temp),cp.kron(ones_temp,temp)))
if self.verbose:
print("Used bytes so far, after creating Kmatrix {}".format(mempool.used_bytes()))
#implement fft plan here
self._plan_fft2 = None
# self._fft2_axes = (-2, -1)
self._plan_ifft2 = None
x = np.concatenate((np.arange(self.basis_number)+1,np.zeros(self.basis_number-1)))
toep = sla.toeplitz(x)
self._Umask = cp.asarray(np.kron(toep,toep),dtype=cp.int16)
def _calc_offset(offset_map, region, parent_y, parent_x):
y0, y1, x0, x1 = region
x_area, y_area = offset_map[:, y0:y1, x0:x1]
x_vec = np.power(np.subtract(np.arange(x0, x1), parent_x), 2)
y_vec = np.power(np.subtract(np.arange(y0, y1), parent_y), 2)
xv, yv = np.meshgrid(x_vec, y_vec)
dist = np.sqrt(xv + yv) # sqrt(y^2 + x^2)
xv = np.divide(xv, dist) # normalize x
yv = np.divide(yv, dist) # normalize y
offset_map[0, y0:y1, x0:x1] = np.maximum(x_area, xv)
offset_map[1, y0:y1, x0:x1] = np.maximum(y_area, yv)
