def graphs(request):
with NamedTemporaryFile(mode="w+", suffix=".csv") as graph_tf:
graph_tf.writelines(request.param)
graph_tf.seek(0)
nx_G = nx.read_weighted_edgelist(graph_tf.name, delimiter=',')
cudf_df = cudf.read_csv(graph_tf.name,
names=["src", "dst", "data"],
delimiter=",",
dtype=["int32", "int32", "float64"])
cugraph_G = cugraph.Graph()
cugraph_G.from_cudf_edgelist(cudf_df,
source="src",
destination="dst",
edge_attr="data")
# construct cupy coo_matrix graph
i = []
j = []
weights = []
for index in range(cudf_df.shape[0]):
vertex1 = cudf_df.iloc[index]["src"]
vertex2 = cudf_df.iloc[index]["dst"]
weight = cudf_df.iloc[index]["data"]
i += [vertex1, vertex2]
j += [vertex2, vertex1]
weights += [weight, weight]
i = cupy.array(i)
j = cupy.array(j)
weights = cupy.array(weights)
largest_vertex = max(cupy.amax(i), cupy.amax(j))
cupy_df = cupy_coo_matrix(
(weights, (i, j)), shape=(largest_vertex + 1, largest_vertex + 1))
yield cugraph_G, nx_G, cupy_df
def multigrid(H):
global N
global vcCnt
global rConv
global pAnlt
global pData, rData
rData[0] = H
chMat = cp.zeros(N[0])
rConv = cp.zeros(vcCnt)
for i in range(vcCnt):
v_cycle()
chMat = laplace(pData[0])
resVal = float(cp.amax(cp.abs(H[1:-1, 1:-1, 1:-1] - chMat)))
rConv[i] = resVal
print("Residual after V-Cycle {0:2d} is {1:.4e}".format(i + 1, resVal))
errVal = float(
cp.amax(cp.abs(pAnlt[1:-1, 1:-1, 1:-1] - pData[0][1:-1, 1:-1, 1:-1])))
print("Error after V-Cycle {0:2d} is {1:4e}\n".format(i + 1, errVal))
return pData[0]
def scf_per_batch(Np, L, xs): # xs shape (bs,1024,2)
B = Np//2
s = scd_fam(xs, Np, L) # shape (batch, alpha, f_k)
f = cp.absolute(s)
alpha = cp.amax(cp.absolute(s), axis=-1)
freq = cp.amax(cp.absolute(s), axis=-2)
(bs, my, mx) = f.shape
freq = freq[:, (mx//2-B):(mx//2 + B)]
return alpha, freq # should be (bs,Np) (bs,Np)
def __init__(self,
xx,
yy,
minimum=xp.nan,
maximum=xp.nan,
name=None,
latex_label=None,
unit=None,
boundary=None):
self.xx = xp.asarray(xx)
self.min_limit = float(xp.amin(self.xx))
self.max_limit = float(xp.amax(self.xx))
# In order to use np/cp.interp, we need to make sure that xx is ordered
sorted_idxs = xp.argsort(self.xx)
self.xx = self.xx[sorted_idxs]
self._yy = xp.asarray(yy)[sorted_idxs]
if self._yy.ndim != 1:
raise TypeError("yy must be 1D. A {}-D array given.".format(
self.yy.dim))
self.YY = None
self.probability_density = None
self.cumulative_distribution = None
self.inverse_cumulative_distribution = None
self.__all_interpolated = Interp(self.xx, self._yy)
minimum = float(xp.nanmax(xp.array([self.min_limit, minimum])))
maximum = float(xp.nanmin(xp.array([self.max_limit, maximum])))
bilby.core.prior.Prior.__init__(self,
name=name,
latex_label=latex_label,
unit=unit,
minimum=minimum,
maximum=maximum,
boundary=boundary)
self._update_instance()
def softmax(x, axis=None):
"""Softmax function.
The softmax function transforms each element of a
collection by computing the exponential of each element
divided by the sum of the exponentials of all the elements.
Parameters
----------
x : array-like
The input array
axis : int or tuple of ints, optional
Axis to compute values along. Default is None
Returns
-------
s : cupy.ndarray
Returns an array with same shape as input. The result
will sum to 1 along the provided axis
"""
x_max = cupy.amax(x, axis=axis, keepdims=True)
exp_x_shifted = cupy.exp(x - x_max)
return exp_x_shifted / cupy.sum(exp_x_shifted, axis=axis, keepdims=True)
def forward(self, inputs, target_array):
# Get hidden units
self.n_h = np.dot(inputs, self.w_h)
# Sigmoid
self.n_h = self.activate(self.n_h)
# Add bias
self.n_h = np.hstack((self.n_h, 1))
#self.n_h = np.append(self.n_h, 1)
# Get outputs
n_o = np.dot(self.n_h, self.w_o)
# 1 Activate max of outputs by storing activations of n_o in predictions array.
# * predictions array is used to compute confusion matrix.
# Init predictions array to shape of output neurons
predictions = np.empty((n_o.shape))
predictions = self.activate(n_o)
# 2 Activate on output neurons.
n_o = self.activate(n_o)
# 3 Find the max of each sample in predictions and give it a 1 there, 0 otherwise.
predictions = np.where(predictions>=np.amax(predictions),1,0)
target_k = predictions * target_array
# 4 Turn target array into array of 0.9s and 0.1s.
# * for calculating deltas.
target_k = np.where(target_k==1,0.9,0.1)
return n_o, target_k, predictions
def max_pool(inp, kernel_size, stride, padding) -> 'Tensor':
_check_tensors(inp)
engine = _get_engine(inp)
def save_mask(x, cords):
mask = engine.zeros_like(x)
n, c, h, w = x.shape
x = x.reshape(n, h * w, c)
idx = engine.argmax(x, axis=1)
n_idx, c_idx = engine.indices((n, c))
mask.reshape((n, h * w, c))[n_idx, idx, c_idx] = 1
cache[cords] = mask
cache = {}
padded_input_array = engine.pad(inp.data, ((0, 0), (0, 0), (padding[0], padding[0]), (padding[1], padding[1])), mode='constant')
_, _, output_height, output_width = _calculate_output_dims(inp.shape, (0, 0, kernel_size[0], kernel_size[1]), padding, stride)
kernel_height, kernel_width = kernel_size
batch_size, channels, _, _ = padded_input_array.shape
output_array = engine.zeros((batch_size, channels, output_height, output_width))
for row in range(output_height):
for column in range(output_width):
padded_input_slice = padded_input_array[:, :, row * stride:row * stride + kernel_height, column * stride:column * stride + kernel_width]
save_mask(x=padded_input_slice, cords=(row, column))
output_array[:, :, row, column] = engine.amax(padded_input_slice, axis=(2, 3))
return _create_tensor(
inp,
data=output_array,
func=wrapped_partial(max_pool_backward, inp=inp, kernel_size=kernel_size, stride=stride, padding=padding, cache=cache)
)
def compute_psnr(diff_img):
"""takes diff Image as inout and returns PSNR and Minimum SNR for each color channel"""
diff = np.asarray(diff_img)
diff = diff.reshape(3, diff_img.width * diff_img.height)
mse_rgb = np.mean(diff**2, axis = 1)
psnr_rgb = 10 * np.log10(255**2 / mse_rgb)
min_mse_rgb = np.amax(diff, axis = 1)
min_snr_rgb = 10 * np.log10(255**2 / min_mse_rgb)
return psnr_rgb[0], psnr_rgb[1], psnr_rgb[2], min_snr_rgb[0], min_snr_rgb[1], min_snr_rgb[2]
def logsumexp(x):
if _GPU_ENABLED:
# NOTE This is a quick-and-dirty implementation
# FIXME Should contribute to the cupy codebase
xmax = cp.amax(x)
t = cp.exp(x - xmax)
return cp.asnumpy(cp.log(cp.sum(t)) + xmax)
else:
return scipy.special.logsumexp(x)
def cg_ptycho(self, data, init, h, lamd, rho, piter, model):
# minimization functional
def minf(psi, fpsi):
if model == 'gaussian':
f = cp.linalg.norm(cp.abs(fpsi) - cp.sqrt(data))**2
elif model == 'poisson':
f = cp.sum(
cp.abs(fpsi)**2 - 2 * data * self.mlog(cp.abs(fpsi)))
f += rho * cp.linalg.norm(h - psi + lamd / rho)**2
return f
psi = init.copy()
gamma = 2 # init gamma as a large value
for i in range(piter):
fpsi = self.fwd_ptycho(psi)
if model == 'gaussian':
grad = self.adj_ptycho(fpsi - cp.sqrt(data) *
cp.exp(1j * cp.angle(fpsi)))
elif model == 'poisson':
grad = self.adj_ptycho(fpsi - data * fpsi /
(cp.abs(fpsi)**2 + 1e-32))
grad -= rho * (h - psi + lamd / rho)
# Dai-Yuan direction
if i == 0:
d = -grad
else:
d = -grad+cp.linalg.norm(grad)**2 / \
((cp.sum(cp.conj(d)*(grad-grad0))))*d
grad0 = grad
# line search
fd = self.fwd_ptycho(d)
gamma = self.line_search(minf, gamma, psi, fpsi, d, fd)
psi = psi + gamma * d
##print(gamma,minf(psi, fpsi))
if (cp.amax(cp.abs(cp.angle(psi))) > 3.14):
print('possible phase wrap, max computed angle',
cp.amax(cp.abs(cp.angle(psi))))
return psi
def forward(self, data, is_training=True):
# print(data[0])
if (len(data.shape) != 2):
raise ValueError(
'data have shape is not compatible. Expect [batch_size, nums_score]'
)
logits = np.exp(data - np.amax(data, axis=1, keepdims=True))
logits = logits / np.sum(logits, axis=1, keepdims=True)
if is_training:
self.cache['logits'] = np.copy(logits)
# print(logits[0])
return logits
def amax(a, axis=None, out=None, keepdims=None, initial=None, where=None):
'''Try first to run as CuPy array, if not run as numpy'''
try:
z = cp.amax(a, axis, out, keepdims)
except:
z = np.amax(a, axis, out, keepdims, initial, where)
'''Synchronize all GPU cores as preventative measure against race condition'''
cp.cuda.Stream.null.synchronize()
if out is not None:
return out
return z
def constructLocalMat(self, src_pts, grids, scale_factor):
'''
This function
src_pts : A N by 2 matrix. N is number of matching pairs.
grids : A instance of Grids class.
'''
gamma = 0.0025
src_pts = cp.asarray(src_pts)
grids_center_coordi = cp.asarray(
grids.center_lst) # A M by 2 matrix, M is number of grids.
grid_num = len(grids.center_lst)
A = cp.asarray(self.A)
C1 = cp.asarray(self.C1)
C2 = cp.asarray(self.C2)
matchingPairNum = src_pts.shape[0]
skip = 0
global_H = cp.asarray(np.copy(self.globalHomoMat))
local_homo_mat_lst = cp.zeros((grid_num, 3, 3))
change_mask = []
for idx in range(grid_num):
grid_coordi = grids_center_coordi[idx]
weight = cp.exp((-1) * cp.sum(
(src_pts - grid_coordi)**2, axis=1) / scale_factor**2)
print(
f'SVD {idx+1:8d}/{grid_num}({(idx+1)/(grid_num)*100:8.1f}%) Current skip {skip} times. Current Skip rate is {skip/grid_num:5.3%}',
end='\r')
if cp.amax(weight) < gamma:
skip += 1
local_homo_mat_lst[idx, :, :] = global_H
continue
weight = cp.repeat(weight, 2)
weight[weight < gamma] = gamma
weight = weight.reshape((2 * matchingPairNum, 1))
weighted_A = cp.multiply(weight, A)
u, s, v = cp.linalg.svd(weighted_A)
H = v[-1, :].reshape((3, 3))
H = cp.linalg.inv(C2) @ H @ C1
H = H / H[-1, -1]
local_homo_mat_lst[idx, :, :] = H
change_mask.append(idx)
print()
self.non_global_homo_mat_lst = change_mask
self.localHomoMat_lst = cp.asnumpy(local_homo_mat_lst)
def predict_log_proba(self, X):
"""
Return log-probability estimates for the test vector X.
Parameters
----------
X : array-like of shape (n_samples, n_features)
Returns
-------
C : array-like of shape (n_samples, n_classes)
Returns the log-probability of the samples for each class in the
model. The columns correspond to the classes in sorted order, as
they appear in the attribute classes_.
"""
if isinstance(X, np.ndarray) or isinstance(X, cp.ndarray):
X = cp.asarray(X, X.dtype)
elif scipy.sparse.isspmatrix(X) or cp.sparse.isspmatrix(X):
X = X.tocoo()
rows = cp.asarray(X.row, dtype=X.row.dtype)
cols = cp.asarray(X.col, dtype=X.col.dtype)
data = cp.asarray(X.data, dtype=X.data.dtype)
X = cp.sparse.coo_matrix((data, (rows, cols)), shape=X.shape)
jll = self._joint_log_likelihood(X)
# normalize by P(X) = P(f_1, ..., f_n)
# Compute log(sum(exp()))
# Subtract max in exp to prevent inf
a_max = cp.amax(jll, axis=1, keepdims=True)
exp = cp.exp(jll - a_max)
logsumexp = cp.log(cp.sum(exp, axis=1))
a_max = cp.squeeze(a_max, axis=1)
log_prob_x = a_max + logsumexp
if log_prob_x.ndim < 2:
log_prob_x = log_prob_x.reshape((1, log_prob_x.shape[0]))
return jll - log_prob_x.T
def _terrain_cupy(data: cupy.ndarray, seed: int, x_range_scaled: tuple,
y_range_scaled: tuple, zfactor: int) -> cupy.ndarray:
data = data * 0
data[:] = _terrain_gpu(data,
seed,
x_range=x_range_scaled,
y_range=y_range_scaled)
minimum = cupy.amin(data)
maximum = cupy.amax(data)
data[:] = (data - minimum) / (maximum - minimum)
data[data < 0.3] = 0 # create water
data *= zfactor
return data
def predict_log_proba(self, X):
"""
Return log-probability estimates for the test vector X.
"""
out_type = self._get_output_type(X)
if has_scipy():
from scipy.sparse import isspmatrix as scipy_sparse_isspmatrix
else:
from cuml.common.import_utils import dummy_function_always_false \
as scipy_sparse_isspmatrix
# todo: use a sparse CumlArray style approach when ready
# https://github.com/rapidsai/cuml/issues/2216
if scipy_sparse_isspmatrix(X) or cupyx.scipy.sparse.isspmatrix(X):
X = X.tocoo()
rows = cp.asarray(X.row, dtype=X.row.dtype)
cols = cp.asarray(X.col, dtype=X.col.dtype)
data = cp.asarray(X.data, dtype=X.data.dtype)
X = cupyx.scipy.sparse.coo_matrix((data, (rows, cols)),
shape=X.shape)
else:
X = input_to_cuml_array(X, order='K').array.to_output('cupy')
jll = self._joint_log_likelihood(X)
# normalize by P(X) = P(f_1, ..., f_n)
# Compute log(sum(exp()))
# Subtract max in exp to prevent inf
a_max = cp.amax(jll, axis=1, keepdims=True)
exp = cp.exp(jll - a_max)
logsumexp = cp.log(cp.sum(exp, axis=1))
a_max = cp.squeeze(a_max, axis=1)
log_prob_x = a_max + logsumexp
if log_prob_x.ndim < 2:
log_prob_x = log_prob_x.reshape((1, log_prob_x.shape[0]))
result = jll - log_prob_x.T
return CumlArray(result).to_output(out_type)
def _perlin_cupy(data: cupy.ndarray, freq: tuple, seed: int) -> cupy.ndarray:
# cupy.random.seed(seed)
# p = cupy.random.permutation(2**20)
# use numpy.random then transfer data to GPU to ensure the same result
# when running numpy backed and cupy backed data array.
np.random.seed(seed)
p = cupy.asarray(np.random.permutation(2**20))
p = cupy.append(p, p)
griddim, blockdim = cuda_args(data.shape)
_perlin_gpu[griddim, blockdim](p, 0, freq[0], 0, freq[1], 1, data)
minimum = cupy.amin(data)
maximum = cupy.amax(data)
data[:] = (data - minimum) / (maximum - minimum)
return data
def pinv(a, rcond=1e-15):
"""Compute the Moore-Penrose pseudoinverse of a matrix.
It computes a pseudoinverse of a matrix ``a``, which is a generalization
of the inverse matrix with Singular Value Decomposition (SVD).
Note that it automatically removes small singular values for stability.
Args:
a (cupy.ndarray): The matrix with dimension ``(..., M, N)``
rcond (float or cupy.ndarray): Cutoff parameter for small singular
values. For stability it computes the largest singular value
denoted by ``s``, and sets all singular values smaller than
``rcond * s`` to zero. Broadcasts against the stack of matrices.
Returns:
cupy.ndarray: The pseudoinverse of ``a`` with dimension
``(..., N, M)``.
.. warning::
This function calls one or more cuSOLVER routine(s) which may yield
invalid results if input conditions are not met.
To detect these invalid results, you can set the `linalg`
configuration to a value that is not `ignore` in
:func:`cupyx.errstate` or :func:`cupyx.seterr`.
.. seealso:: :func:`numpy.linalg.pinv`
"""
_util._assert_cupy_array(a)
if a.size == 0:
_, out_dtype = _util.linalg_common_type(a)
m, n = a.shape[-2:]
if m == 0 or n == 0:
out_dtype = a.dtype # NumPy bug?
return cupy.empty(a.shape[:-2] + (n, m), dtype=out_dtype)
u, s, vt = _decomposition.svd(a.conj(), full_matrices=False)
# discard small singular values
cutoff = rcond * cupy.amax(s, axis=-1)
leq = s <= cutoff[..., None]
cupy.reciprocal(s, out=s)
s[leq] = 0
return cupy.matmul(vt.swapaxes(-2, -1), s[..., None] * u.swapaxes(-2, -1))
def takexi(self, psi, phi, lamd, mu, rho, tau):
# bg subtraction parameters
r = self.prb.shape[0] / 2
m1 = cp.mean(cp.angle(psi[:, :, r:2 * r]))
m2 = cp.mean(cp.angle(psi[:, :,
psi.shape[2] - 2 * r:psi.shape[2] - r]))
pshift = (m1 + m2) / 2
t = psi - lamd / rho
t *= cp.exp(-1j * pshift)
logt = self.mlog(t)
# K, xi0, xi1
K = 1j * self.voxelsize * self.wavenumber() * t / self.coeftomo
K = K / cp.amax(cp.abs(K)) # normalization
xi0 = K * (-1j * (logt) /
(self.voxelsize * self.wavenumber())) * self.coeftomo
xi1 = phi - mu / tau
return xi0, xi1, K, pshift
def smear(f, fb, pairs):
"""
build smear matrix B for bp
Parameters
----------
f : NDArray
potential on nodes
fb : NDArray
potential on adjacent electrodes
pairs : NDArray
electrodes numbering pairs
Returns
-------
NDArray
back-projection matrix
"""
#b_matrix = np.empty(size=(len(pairs), len(f)))
#t1 = time()
#b_matrix = []
f = cp.array(f)
fb = cp.array(fb)
pairs = cp.array(pairs)
i = cp.arange(len(pairs))
min_fb = cp.amin(fb[pairs], axis=1)
max_fb = cp.amax(fb[pairs], axis=1)
b_matrix = cp.empty((len(pairs), len(f)))
#index[i, :] = (min_fb[i] < f.all()) & (f.all() <= max_fb[i])
b_matrix[:] = (min_fb[i, None] < f[None]) & (f[None] <= max_fb[i, None])
#t2 = time()
'''
for i, j in pairs:
f_min, f_max = min(fb[i], fb[j]), max(fb[i], fb[j])
b_matrix.append((f_min < f) & (f <= f_max))
b_matrix = np.array(b_matrix)
'''
#print("matrices: ", t2 - t1)
#print("their loop ", time() - t2)
return cp.asnumpy(b_matrix)
def predict_log_proba(self, X) -> CumlArray:
"""
Return log-probability estimates for the test vector X.
"""
if has_scipy():
from scipy.sparse import isspmatrix as scipy_sparse_isspmatrix
else:
from cuml.common.import_utils import dummy_function_always_false \
as scipy_sparse_isspmatrix
# todo: use a sparse CumlArray style approach when ready
# https://github.com/rapidsai/cuml/issues/2216
if scipy_sparse_isspmatrix(X) or cupyx.scipy.sparse.isspmatrix(X):
X = _convert_x_sparse(X)
else:
X = input_to_cupy_array(
X, order='K', check_dtype=[cp.float32, cp.float64,
cp.int32]).array
jll = self._joint_log_likelihood(X)
# normalize by P(X) = P(f_1, ..., f_n)
# Compute log(sum(exp()))
# Subtract max in exp to prevent inf
a_max = cp.amax(jll, axis=1, keepdims=True)
exp = cp.exp(jll - a_max)
logsumexp = cp.log(cp.sum(exp, axis=1))
a_max = cp.squeeze(a_max, axis=1)
log_prob_x = a_max + logsumexp
if log_prob_x.ndim < 2:
log_prob_x = log_prob_x.reshape((1, log_prob_x.shape[0]))
result = jll - log_prob_x.T
return result
def log_softmax(x, axis=None):
"""Compute logarithm of softmax function
Parameters
----------
x : array-like
Input array
axis : int or tuple of ints, optional
Axis to compute values along. Default is None and softmax
will be computed over the entire array `x`
Returns
-------
s : cupy.ndarry
An array with the same shape as `x`. Exponential of the
result will sum to 1 along the specified axis. If `x` is a
scalar, a scalar is returned
"""
x_max = cp.amax(x, axis=axis, keepdims=True)
if x_max.ndim > 0:
x_max[~cp.isfinite(x_max)] = 0
elif not cp.isfinite(x_max):
x_max = 0
tmp = x - x_max
if tmp.dtype.kind in 'iu':
for out_dtype in [cp.float16, cp.float32, cp.float64]:
if cp.can_cast(tmp.dtype, out_dtype):
tmp = tmp.astype(out_dtype)
break
out = _log_softmax_kernel(tmp, axis=axis, keepdims=True)
out = tmp - out
return out
def create_triangulation(raster, optix):
datahash = np.uint64(hash(str(raster.data.get())))
optixhash = np.uint64(optix.getHash())
# Calculate a scale factor for the height that maintains the ratio
# width/height
H, W = raster.shape
# Scale the terrain so that the width is proportional to the height
# Thus the terrain would be neither too flat nor too steep and
# raytracing will give best accuracy
maxH = float(cupy.amax(raster.data))
maxDim = max(H, W)
scale = maxDim / maxH
if optixhash != datahash:
num_tris = (H - 1) * (W - 1) * 2
verts = cupy.empty(H * W * 3, np.float32)
triangles = cupy.empty(num_tris * 3, np.int32)
# Generate a mesh from the terrain (buffers are on the GPU, so
# generation happens also on GPU)
res = _triangulate_terrain(verts, triangles, raster, scale)
if res:
raise RuntimeError(
f"Failed to generate mesh from terrain, error code: {res}")
res = optix.build(datahash, verts, triangles)
if res:
raise RuntimeError(f"OptiX failed to build GAS, error code: {res}")
# Enable for debug purposes
if False:
write("mesh.stl", verts, triangles)
# Clear some GPU memory that we no longer need
verts = None
triangles = None
cupy.get_default_memory_pool().free_all_blocks()
return scale
def max(tensor, axis=None, keepdims=False):
"""Returns the maximum of an array or the maximum along a given axis.
Note::
When at least one element is NaN, the corresponding min value will be
NaN.
Args:
tensor (ndarray): Array to take the maximum.
axis (int): Along which axis to take the maximum. The flattened array
is used by default. Defaults to None.
keepdims (bool): If ``True``, the axis is kept as an axis of
size one. Default to False.
Returns:
ndarray: The maximum of ``tensor``, along the axis if specified.
"""
# cupy don't support keepdims.
if keepdims:
return numpy.amax(tensor, axis=axis, keepdims=keepdims)
else:
return cp.amax(tensor, axis=axis, keepdims=keepdims)
if(sys.argv[i]=="--help"):
print("command:python3 amax_test.py [-finame]")
exit()
for i in range(n_parameter):
if(flag_list[i]==0):
print("please input parameter : [" + parameter_name_list[i] + "]")
input_parameter=1
if(input_parameter==1):
exit()
with mrcfile.open(finame, permissive=True) as mrc:
cp_temp=cp.asarray(mrc.data,dtype="float32")
mrc.close
amax_axis0=cp.amax(cp_temp,axis=(0,1))
amax_axis1=cp.amax(cp_temp,axis=(1,2))
amax_axis2=cp.amax(cp_temp,axis=(0,2))
amax=cp.amax(cp_temp)
print("axis 01 = " + str(amax_axis0))
print("axis 12 = " + str(amax_axis1))
print("axis 02 = " + str(amax_axis2))
print("axis 012 = " + str(amax))
print()
print("axis 01 shape = " + str(amax_axis0.shape))
print("axis 12 shape = " + str(amax_axis1.shape))
print("axis 02 shape = " + str(amax_axis2.shape))
print()
print("cp_temp shape = " + str(cp_temp.shape))
cp_structure_factor_bk.imag = cp_G_kernel * cp_structure_factor_bk.imag
cp_structure_factor_bk = cp.fft.ifftshift(
cp_structure_factor_bk)
G_dens = cp.fft.ifft2(cp_structure_factor_bk, norm="ortho")
# np_G_dens = cp.asnumpy(cp.abs(cp_structure_factor_bk))
# tifffile.imsave(header + "_" + str(i+1).zfill(6) + '_cp_structure_factor_bk.tif' ,np_G_dens)
# np_G_dens = cp.asnumpy(G_dens.real)
# tifffile.imsave(header + "_" + str(i+1).zfill(6) + '_G_dens.tif' ,np_G_dens)
G_dens_real = G_dens.real
# G_dens_real_average=cp.average(G_dens_real)
# threshold = float(SW_delta)*(cp.amax(G_dens_real)-G_dens_real_average) + G_dens_real_average
threshold = float(SW_delta) * cp.amax(G_dens_real)
cp_sup = cp.where(G_dens_real >= threshold, float(1), float(0))
cp_sup = cp_sup.astype(cp.float32)
SW_ips = SW_ips * float(SW_ips_step)
if (SW_sup_output_flag == 1):
np_sup = cp.asnumpy(cp_sup)
tifffile.imsave(
header + "_" + str(i + 1).zfill(6) + '_sup.tif',
np_sup)
#実空間拘束
cp_dens_bk = cp.real(cp_dens)
index_orientation = cp.argmax(correlation_orientation)
# print(correlation[0,:,i_shift,i_shift])
print("i_dens_obs = " + str(i_dens_obs))
# print("max correlation = " + str(cp.amax(correlation)))
print("max correlation = " +
str(correlation_orientation[index_orientation]))
print("index_orientation = " + str(index_orientation))
print("index_rot = " + str(index_rot[index_orientation]))
print("index_x = " + str(index_x[index_orientation]))
print("index_y = " + str(index_y[index_orientation]))
print("")
with open(log_path, mode='a') as log:
log.write(
str(i_dens_obs) + "," + str(index_orientation) + "," +
str(cp.amax(correlation)) + "," +
str(index_rot[index_orientation]) + "," +
str(index_x[index_orientation]) + "," +
str(index_y[index_orientation]) + "\n")
#n=0
#print(correlation[:,n,:,:])
#print("index = " + str(index[n]))
#print("index_rot = " + str(index_rot[n]))
#print("index_x = " + str(index_x[n]))
#print("index_y = " + str(index_y[n]))
#print(correlation[index_rot[n],n,index_x[n],index_y[n]])
#print(correlation[:,n,:,:].shape)
#cupy配列 ⇒ numpy配列に変換
#cp_density_stack = cp.asnumpy(cp_density_stack)
def scan_image_calc_color(self, file_path, height, pts_cp, downsampling_xy):
### Open Image
img_src = self.open_image(file_path)
w, h = img_src.size
### DownSampling
ww = int(w / downsampling_xy)
hh = int(h / downsampling_xy)
img = img_src.resize((ww, hh), Image.LANCZOS)
### Read Shape
px = img.getdata()
px_cp = cp.array(px)
# print("px_cp.shape :", px_cp.shape)
### Create Result Canvas
img_tmp = self.create_canvas_alpha(ww)
img_result = self.create_canvas_alpha(w)
### Segment Contour True/False
px_seg_0 = cp.amax(px_cp)
### Contour : False
if px_seg_0 < 127:
### Export None-Image
px_result = [(0, 0, 0, 0) for i in range(w) for j in range(h)]
img_result.putdata(tuple(px_result))
return img_result
### Contour : True
else:
### Running on Cuda
# print("Running on Cuda !!")
################################################################################################
###########################
### ###
### Calc Distance ###
### ###
###########################
# print("Distance")
### [X] Clac Distance
# dist_list = self.gen_disctance_list(w, h, height, pts_cp)
### [O] Clac Distance with DownSampling
dist_list = self.gen_disctance_list_ds(ww, hh, height, downsampling_xy, pts_cp)
################################################################################################
############################################
### ###
### Generate Color From Distance ###
### ###
############################################
# print("Color")
### Define Colors
################################################################################################
### Offset Pattern (Small)
dist_src = dist_list.tolist()
# print("len(dist_src) :", len(dist_src))
clrs = []
amp = 1 / 2
for d in dist_src:
c = int((math.sin(d * amp) + 1) * (1 / 2) * 255)
cc = 255 - c
clrs.append([c, c, cc, 255])
clrs_tuple = tuple(map(tuple, clrs))
### Generate New Image
img_tmp.putdata(tuple(clrs_tuple))
################################################################################################
"""
### Offset Pattern (Large)
dist_src = dist_list.tolist()
# print("len(dist_src) :", len(dist_src))
clrs = []
for d in dist_src:
th = 30
if d < (th * 1):
clrs.append([255, 0, 0, 255])
elif d < (th * 2):
clrs.append([0, 255, 0, 255])
elif d < (th * 3):
clrs.append([0, 0, 255, 255])
else:
clrs.append([255, 255, 255, 255])
clrs_tuple = tuple(map(tuple, clrs))
### Generate New Image
img_tmp.putdata(tuple(clrs_tuple))
"""
################################################################################################
"""
### Test Distance Map
dist_remap = self.remap_number_cp(dist_list, 0, 200, 0, 255)
dist_remap = dist_remap.astype('int64')
# print("dist_remap.shape :", dist_remap.shape)
### Fill Array (255)
alpha_array = cp.ones(dist_list.shape) * 255
alpha_array = alpha_array.astype('int64')
dist_img = cp.stack([dist_remap, dist_remap, dist_remap, alpha_array])
dist_img = dist_img.T
# print("dist_img.shape :", dist_img.shape)
# print(dist_img)
dist_4 = dist_img.tolist()
dist_4 = tuple(map(tuple, dist_4))
# print("type(dist_4) :", type(dist_4))
### Generate New Image
img_tmp.putdata(tuple(dist_4))
"""
################################################################################################
#########################
### ###
### Composite ###
### ###
#########################
# print("Composite")
### Scaling
img_dist = img_tmp.resize((w, h), Image.LANCZOS)
### Create Canvas for Composite
img_canvas = self.create_canvas_alpha(w)
### Define Mask
img_mask = img_src.convert("L")
### Composite
img_result = Image.composite(img_dist, img_canvas, img_mask)
### Flip
### Image Coordination >> Rhino Coordination
img_flip = ImageOps.flip(img_result)
return img_flip
def getNextPrediction(fileJac: str, measuring_electrodes: np.ndarray, voltages: np.ndarray,
num_returned: int=10, n_el: int=20, n_per_el: int=3, n_pix: int=64, pert: float=0.5,
p_influence: float=-10., p_rec: float=10., p: float=0.2, lamb:float=0.1) -> np.ndarray:
# extract const permittivity jacobian and voltage (& other)
file = h5.File(fileJac, 'r')
meas = file['meas'][()]
new_ind = file['new_ind'][()]
p = file['p'][()]
t = file['t'][()]
file.close()
# initialise const permitivity and el_pos variables
perm = np.ones(t.shape[0], dtype=np.float32)
el_pos = np.arange(n_el * n_per_el).astype(np.int16)
mesh_obj = {'element': t,
'node': p,
'perm': perm}
# list all possible active/measuring electrode permutations of this measurement
meas = cp.array(meas)
# find their indices in the already calculated const. permitivity Jacobian (CPJ)
measuring_electrodes = cp.array(measuring_electrodes)
measurements_0 = cp.amin(measuring_electrodes[:, :2], axis=1)
measurements_1 = cp.amax(measuring_electrodes[:, :2], axis=1)
measurements_2 = cp.amin(measuring_electrodes[:, 2:], axis=1)
measurements_3 = cp.amax(measuring_electrodes[:, 2:], axis=1)
measuring_electrodes = cp.empty((len(measuring_electrodes), 4))
measuring_electrodes[:, 0] = measurements_0
measuring_electrodes[:, 1] = measurements_1
measuring_electrodes[:, 2] = measurements_2
measuring_electrodes[:, 3] = measurements_3
index = (cp.sum(cp.equal(measuring_electrodes[:, None, :], meas[None, :, :]), axis=2) == 4)
index = cp.where(index)
#print(index)
ind = cp.unique(index[1])
#print(ind)
i = cp.asnumpy(ind)
j = index[0]
mask = np.zeros(len(meas), dtype=int)
mask[i] = 1
mask = mask.astype(bool)
# take a slice of Jacobian, voltage readings and B matrix (the one corresponding to the performed measurements)
file = h5.File(fileJac, 'r')
jac = file['jac'][mask, :][()]
v = file['v'][mask][()]
b = file['b'][mask, :][()]
file.close()
# put them in the form desired by the GREIT function
pde_result = train.namedtuple("pde_result", ['jac', 'v', 'b_matrix'])
f = pde_result(jac=jac,
v=v,
b_matrix=b)
# now we can use the real voltage readings and the GREIT algorithm to reconstruct
greit = train.greit.GREIT(mesh_obj, el_pos, f=f, ex_mat=(meas[index[1], :2]), step=None)
greit.setup(p=p, lamb=lamb, n=n_pix)
h_mat = greit.H
reconstruction = greit.solve(voltages, f.v).reshape(n_pix, n_pix)
# fix_electrodes_multiple is in meshing.py
_, el_coords = train.fix_electrodes_multiple(centre=None, edgeX=0.1, edgeY=0.1, a=2, b=2, ppl=n_el, el_width=0.02, num_per_el=3)
# find the distances between each existing electrode pair and the pixels lying on the liine that connects them
pixel_indices, voltage_all_possible = measopt.find_all_distances(reconstruction, h_mat, el_coords, n_el, cutoff=0.8)
# call function get_total_map that generates the influence map, the gradient map and the log-reconstruction
total_map, grad_mat, rec_log = np.abs(measopt.get_total_map(reconstruction, voltages, h_mat, pert=pert, p_influence=p_influence, p_rec=p_rec))
# get the indices of the total map along the lines connecting each possible electrode pair
total_maps_along_lines = total_map[None] * pixel_indices
# find how close each connecting line passes to the boundary of an anomaly (where gradient supposed to be higher)
proximity_to_boundary = np.sum(total_maps_along_lines, axis=(1, 2)) / np.sum(pixel_indices, axis=(1, 2))
# rate the possible src-sink pairs by their proximity to existing anomalies
proposed_ex_line = voltage_all_possible[np.argsort(proximity_to_boundary)[::-1]][:num_returned]
number_of_voltages = 10
# generate the voltage measuring electrodes for this current driver pair
proposed_voltage_pairs = measopt.findNextVoltagePair(proposed_ex_line[0], fileJac, total_map, number_of_voltages, 0, npix=n_pix, cutoff=0.97)
return proposed_ex_line, proposed_voltage_pairs, reconstruction, total_map
def simulateMeasurements(fileJac, anomaly=0, measurements=None, v_meas=None, n_el=20, n_per_el=3, n_pix=64, a=2.):
# extract const permittivity jacobian and voltage (& other)
file = h5.File(fileJac, 'r')
meas = file['meas'][()]
new_ind = file['new_ind'][()]
p = file['p'][()]
t = file['t'][()]
file.close()
# initialise const permitivity and el_pos variables
perm = np.ones(t.shape[0], dtype=np.float32)
el_pos = np.arange(n_el * n_per_el).astype(np.int16)
mesh_obj = {'element': t,
'node': p,
'perm': perm}
#for testing
if measurements is None:
el_dist = np.random.randint(1, 20)
ex_mat = (cp.concatenate((cp.arange(20)[None], (cp.arange(20) + el_dist)[None])) % 20).T
#print(ex_mat.shape)
fem_all = Forward(mesh_obj, el_pos)
measurements = fem_all.voltMeter(ex_mat)
#ex_mat = mesurements[1]
measurements = cp.concatenate((measurements[1], measurements[0]), axis=1)
#print(measurements.shape)
# list all possible active/measuring electrode permutations of this measurement
meas = cp.array(meas)
# find their indices in the already calculated const. permitivity Jacobian (CPJ)
measurements = cp.array(measurements)
measurements_0 = cp.amin(measurements[:, :2], axis=1)
measurements_1 = cp.amax(measurements[:, :2], axis=1)
measurements_2 = cp.amin(measurements[:, 2:], axis=1)
measurements_3 = cp.amax(measurements[:, 2:], axis=1)
measurements = cp.empty((len(measurements), 4))
measurements[:, 0] = measurements_0
measurements[:, 1] = measurements_1
measurements[:, 2] = measurements_2
measurements[:, 3] = measurements_3
index = (cp.sum(cp.equal(measurements[:, None, :], meas[None, :, :]), axis=2) == 4)
index = cp.where(index)
ind = cp.unique(index[1])
i = cp.asnumpy(ind)
j = index[0]
mask = np.zeros(len(meas), dtype=int)
mask[i] = 1
mask = mask.astype(bool)
# take a slice of Jacobian, voltage readings and B matrix
file = h5.File(fileJac, 'r')
jac = file['jac'][mask, :][()]
v = file['v'][mask][()]
b = file['b'][mask, :][()]
file.close()
pde_result = train.namedtuple("pde_result", ['jac', 'v', 'b_matrix'])
f = pde_result(jac=jac,
v=v,
b_matrix=b)
# simulate voltage readings if not given
if v_meas is None:
if np.isscalar(anomaly):
print("generating new anomaly")
anomaly = train.generate_anoms(a, a)
true = train.generate_examplary_output(a, int(n_pix), anomaly)
mesh_new = train.set_perm(mesh_obj, anomaly=anomaly, background=1)
fem = FEM(mesh_obj, el_pos, n_el)
new_ind = cp.array(new_ind)
f2, raw = fem.solve_eit(volt_mat_all=meas[ind, 2:], new_ind=new_ind[ind], ex_mat=meas[ind, :2], parser=None, perm=mesh_new['perm'].astype('f8'))
v_meas = f2.v
'''
#plot
fig = plt.figure(3)
x, y = p[:, 0], p[:, 1]
ax1 = fig.add_subplot(111)
# draw equi-potential lines
print(raw.shape)
raw = cp.asnumpy(raw[5]).ravel()
vf = np.linspace(min(raw), max(raw), 32)
ax1.tricontour(x, y, t, raw, vf, cmap=plt.cm.viridis)
# draw mesh structure
ax1.tripcolor(x, y, t, np.real(perm),
edgecolors='k', shading='flat', alpha=0.5,
cmap=plt.cm.Greys)
ax1.plot(x[el_pos], y[el_pos], 'ro')
for i, e in enumerate(el_pos):
ax1.text(x[e], y[e], str(i+1), size=12)
ax1.set_title('Equipotential Lines of Uniform Permittivity')
# clean up
ax1.set_aspect('equal')
ax1.set_ylim([-1.2, 1.2])
ax1.set_xlim([-1.2, 1.2])
fig.set_size_inches(6, 6)
#plt.show()'''
elif len(measurements) == len(v_meas):
measurements = np.array(measurements)
v_meas = np.array(v_meas[j[:len(ind)]])
else:
raise ValueError('Sizes of arrays do not match (have to have voltage reading for each measurement). If you don\'t have readings, leave empty for simulation.')
print('Number of measurements:', len(v_meas), len(f.v))
# now we can use the real voltage readings and the GREIT algorithm to reconstruct
greit = train.greit.GREIT(mesh_obj, el_pos, f=f, ex_mat=(meas[index[1], :2]), step=None)
greit.setup(p=0.2, lamb=0.01, n=n_pix)
h_mat = greit.H
reconstruction = greit.solve(v_meas, f.v).reshape(n_pix, n_pix)
# optional: see reconstruction
'''
plt.figure(1)
im1 = plt.imshow(reconstruction, cmap=plt.cm.viridis, origin='lower', extent=[-1, 1, -1, 1])
plt.title("Reconstruction")
plt.colorbar(im1)
plt.figure(2)
im2 = plt.imshow(true, cmap=plt.cm.viridis, origin='lower', extent=[-1, 1, -1, 1])
plt.colorbar(im2)
plt.title("True Image")
plt.show()
'''
return reconstruction, h_mat, v_meas, f.v, true, len(v_meas)
