def minimize(self):
# self.create_3d_mask()
p= cupy.array(self.gradient(0*self.inputImage))
self.iterationNumber += 10
for ind in tqdm(range(0, self.iterationNumber),desc = "tvmin"):
if self.verbose:
print("Itertion: ",ind)
if ind < 10:
lamb = 0.5
else:
lamb = self.lamb
midP = self.divergence(p) - self.inputImage/lamb
psi=cupy.array(self.gradient(midP))
r = self.getSquareSum(psi)
p = (p + self.to*psi)/(1 + self.to*r)
self.resultImage = (self.inputImage - self.divergence(p)*lamb)
self.resultImage = self.positive_constrain(self.resultImage,self.dF_3D_2)
if ind == 9 :
n_3D = cupy.asnumpy(self.resultImage).astype(float)
otsu_val = filters.threshold_otsu(n_3D)
n_3D_bi = np.zeros_like(n_3D)
n_3D_bi[n_3D >= otsu_val]= 1
self.dn_3D_bi = cupy.asarray(n_3D_bi)
elif ind > 9:
self.resultImage[cupy.equal(self.dn_3D_bi , 0)] = 0
def test_preprocess():
expected_tokens, expected_masks, expected_metadata = get_expected_preprocess(
)
actual_tokens, actual_masks, actual_metadata = cyparse.preprocess(
input_logs)
assert actual_tokens.equal(expected_tokens)
assert actual_masks.equal(expected_masks)
assert cupy.equal(actual_metadata, expected_metadata).all()
def equal(x1: Array, x2: Array, /) -> Array:
"""
Array API compatible wrapper for :py:func:`np.equal <numpy.equal>`.
See its docstring for more information.
"""
# Call result type here just to raise on disallowed type combinations
_result_type(x1.dtype, x2.dtype)
x1, x2 = Array._normalize_two_args(x1, x2)
return Array._new(np.equal(x1._array, x2._array))
def test_accuracy(W1, b1, W2, b2, W3, b3, images, labels):
nums = labels.shape[1]
z1 = np.matmul(W1, images) + b1
a1 = common.relu(z1)
z2 = np.matmul(W2, a1) + b2
a2 = common.relu(z2)
z3 = np.matmul(W3, a2) + b3
cost = common.cross_entropy_with_softmax(labels, z3) / nums
pred = np.argmax(labels, axis=0)
label = np.argmax(z3, axis=0)
return (np.sum(np.equal(pred, label)) / nums, cost)
def test_accuracy(W1, W2, W3, images, labels):
nums = labels.shape[1]
z1 = np.matmul(W1, images)
a1 = para_func.relu(z1)
z2 = np.matmul(W2, a1)
a2 = para_func.relu(z2)
z3 = np.matmul(W3, a2)
# print("output shape", z3.shape, labels.shape)
cost = para_func.cross_entropy_with_softmax(labels, z3) / nums
pred = np.argmax(labels, axis=0)
label = np.argmax(z3, axis=0)
return (100.0 * np.sum(np.equal(pred, label)) / nums, cost)
def fetch_neighborhood(user, tabular_np, k):
user_vector, user_indeces = fetch_user_vector(user, tabular_np)
data_vector = cupy.take(tabular_np, user_indeces,
axis=1).astype(cupy.int64)
neighbors_data = cupy.zeros(k, dtype=cupy.float64)
neighbors_indeces = cupy.zeros(k, dtype=int)
for i in range(data_vector.shape[0]):
if i != user:
pearson = evaluate_chromosome(data_vector[i][0], user_vector)
# check if the given vectors have the same non-zero indeces
if cupy.equal(
cupy.where(user_vector == 0)[0].shape,
cupy.where(data_vector[i][0] == 0)[0].shape):
if cupy.equal(
cupy.where(user_vector == 0)[0],
cupy.where(data_vector[i][0] == 0)[0]):
# adjust pearson coefficient to minimum for we do not want that vector to be chosen
pearson = -2
print(
'Warning [2]: Same indeces are evaluated [at fetch neighborhood]'
)
# sort pearson correlation coefficients
for a in range(k):
for b in range(k):
if neighbors_data[a] < neighbors_data[b]:
tmp = neighbors_data[b]
neighbors_data[b] = neighbors_data[a]
neighbors_data[a] = tmp
tmp = neighbors_indeces[b]
neighbors_indeces[b] = neighbors_indeces[a]
neighbors_indeces[a] = tmp
# check if greater pearson coefficient was found
for j in range(k):
if neighbors_data[j] < pearson:
neighbors_data[j] = pearson
neighbors_indeces[j] = i
break
return neighbors_data, neighbors_indeces
def gpu_resize(dPhi, dAmp, src_x, src_y, nx, ny):
ratio_x = nx/src_x
ratio_y = ny/src_y
# print(ratio_x , ratio_y)
dPhi[cupy.isnan(dPhi)] = 0
dPhi[cupy.isinf(dPhi)] = 0
dAmp[cupy.isnan(dAmp)] = 1
dAmp[cupy.isinf(dAmp)] = 1
dAmp[cupy.equal(dAmp,0.0)] = 0.01;
dAmp = cupy.absolute(dAmp)
dPhi = cupyx.scipy.ndimage.zoom(dPhi, (ratio_y,ratio_x))
dAmp = cupyx.scipy.ndimage.zoom(dAmp, (ratio_y,ratio_x))
dField = cupy.log(dAmp) + 1j*(dPhi)
return dField
def criterion(self, y_gt: np.array, y_pred: np.array) -> float:
'''
critertion for KNN Model, return the accuracy for predict result
:param y_gt: ground truth in numpy array
:param y_pred: predict result in numpy array
:return: accuracy in float
'''
assert y_gt.shape == y_pred.shape
total = y_gt.shape[0]
correct = np.equal(y_gt, y_pred).sum()
return correct / total
def disposeRepeated(ex_mat):
#get rid of all repeated source sink pairs in ex_mat (information about them will be kept in new_ind array)
index_XM = cp.sum(cp.equal(ex_mat[:, None, :], ex_mat[None]), axis=2) == 2
indices = cp.where(index_XM)
ind = (indices[0] > indices[1])
indices = [indices[0][ind], indices[1][ind]]
i = cp.ones(len(ex_mat), dtype='i4')
indices = cp.unique(indices[0])
i[indices] = 0
i= i.astype(bool)
ex_mat = ex_mat[i]
return ex_mat
def isDifferent(self, other):
# Checking whether the input is a vector or not
if not isinstance(other, VectorCupy):
raise TypeError("Provided input vector not a %s!" % self.whoami)
if not self._check_same_device(other):
raise ValueError('Provided input has to live in the same device')
# Using Hash table for python2 and numpy built-in function array_equal otherwise
if version_info[0] == 2:
# First make both array buffers read-only
self.arr.flags.writeable = False
other.arr.flags.writeable = False
chcksum1 = hash(self.getNdArray().data)
chcksum2 = hash(other.getNdArray().data)
# Remake array buffers writable
self.arr.flags.writeable = True
other.arr.flags.writeable = True
isDiff = (chcksum1 != chcksum2)
else:
isDiff = (not cp.equal(self.getNdArray(),
other.getNdArray()).all())
return isDiff
z = squared_diff(x, y)
print(z)
z = squared_diff(x, 5)
print(z)
# call vector_add kernel
print('test vector_add kernel')
x = cp.random.random_sample(5, dtype=np.float32)
print(x)
y = cp.random.random_sample(5, dtype=np.float32)
print(y)
z = vector_add(x, y)
print(z)
w = x + y
print(w)
print(cp.equal(w, z))
# call mat_add kernel
print('test mat_add kernel')
x = cp.random.random_sample((2, 3), dtype=np.float32)
# test broadcast op
# x = cp.random.random_sample((2, 1), dtype=np.float32)
print(x)
y = cp.random.random_sample((2, 3), dtype=np.float32)
print(y)
z = mat_add(x, y)
print(z)
w = x + y
print(w)
print(cp.equal(w, z))
def test___array__():
a = ones((2, 3), dtype=int16)
assert cp.asarray(a) is a._array
b = cp.asarray(a, dtype=cp.float64)
assert cp.all(cp.equal(b, cp.ones((2, 3), dtype=cp.float64)))
assert b.dtype == cp.float64
def accuracy(a_hat, a_true):
result = cp.equal(a_hat, a_true)
right = cp.count_nonzero(result)
return right / a_hat.shape[1]
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 __eq__(self, other):
return cupy.equal(self, other)
def estimate_JEMMIG_cupy(z_mean,
z_stddev,
y,
x_weights=None,
num_samples=10000,
seed=None,
batch_size=10,
eps=1e-8,
gpu=0):
"""
We simply need to care about log q(zi,yk) - log q(zi) - log q(yk) =
log sum_x^(n) (q(zi | x^(n)) q(yk | x^(n)))
Note that, yk^(m) for a particular x^(n) can be 0.
:param z_mean: (N, z_dim), mean of q(z|x^(n))
:param z_stddev: (N, z_dim), stddev of q(z|x^(n))
:param y: (N, num_factors), an 2D int array contains values of factors
:param x_weights: A vector of length N
:param num_samples: Number of samples
:param seed: Numpy random state used for sampling
:param batch_size: Batch size during computation
:param eps: Batch size during computation
:param gpu: ID of the gpu
:return:
"""
print("num_samples: {}".format(num_samples))
print("batch_size: {}".format(batch_size))
# Processing z
# ------------------------------------ #
assert z_mean.shape == z_stddev.shape and len(z_mean.shape) == 2, \
"z_mean.shape={} and z_stddev={}".format(z_mean.shape, z_stddev.shape)
num_x, z_dim = z_mean.shape[0], z_mean.shape[1]
print("num_x: {}".format(num_x))
print("z_dim: {}".format(z_dim))
if x_weights is None:
x_weights = np.full([num_x], fill_value=1.0 / num_x, dtype=np.float32)
assert 1.0 - 1e-5 <= np.sum(
x_weights
) <= 1.0 + 1e-5, "'weights' should sum to 1. Found {:.5f}!".format(
np.sum(x_weights))
rs = np.random.RandomState(seed)
rand_ids = rs.choice(num_x, size=num_samples, replace=True, p=x_weights)
# (S, z_dim)
noise = rs.randn(num_samples, z_dim)
z_samples = z_mean[rand_ids] + noise * z_stddev[rand_ids]
# ------------------------------------ #
# Processing y
# ------------------------------------ #
print("Processing ground truth factors!")
assert len(y.shape) == 2 and ('int' in y.dtype.name) and len(y) == num_x, \
"y.shape={} and y.dtype={}!".format(y.shape, y.dtype.name)
y_dim = y.shape[1]
y_unique = []
y_prob = []
H_yk = []
for k in range(y_dim):
yk_unique, yk_count = np.unique(y[:, k], return_counts=True)
y_unique.append(yk_unique)
yk_prob = yk_count / (1.0 * np.sum(yk_count))
y_prob.append(yk_prob)
H_yk.append(-np.sum(yk_prob * np.log(np.maximum(yk_prob, eps))))
H_yk = np.asarray(H_yk, dtype=np.float32)
print("Done!")
# ------------------------------------ #
import cupy as cp
with cp.cuda.Device(gpu):
# (S, z_dim)
z_samples = cp.asarray(z_samples)
# (N, 1, z_dim)
z_mean = cp.expand_dims(cp.asarray(z_mean), axis=1)
# (N, 1, z_dim)
z_stddev = cp.expand_dims(cp.asarray(z_stddev), axis=1)
# (N, y_dim)
y = cp.asarray(y)
print("z_samples.shape: {}".format(z_samples.shape))
print("z_mean.shape: {}".format(z_mean.shape))
print("z_stddev.shape: {}".format(z_stddev.shape))
x_weights = cp.asarray(x_weights)
print("x_weights.shape: {}".format(x_weights.shape))
# (z_dim,)
H_zi_cond_x = cp.asarray(np.zeros(z_dim, dtype=np.float32))
# (z_dim,)
H_zi = cp.asarray(np.zeros(z_dim, dtype=np.float32))
# (z_dim, y_dim)
H_zi_yk = cp.asarray(np.zeros([z_dim, y_dim], dtype=np.float32))
progress_bar = tqdm(total=num_samples)
count = 0
while count < num_samples:
b = min(batch_size, num_samples - count)
# (S_batch, z_dim)
q_zi_cond_x_batch = normal_density_cupy(
z_samples[count:count + b],
z_mean[rand_ids[count:count + b], 0, :],
z_stddev[rand_ids[count:count + b], 0, :],
eps=eps,
gpu=gpu)
# (1, S_batch, z_dim)
z_batch = cp.expand_dims(z_samples[count:count + b], axis=0)
# (N, S_batch, z_dim)
q_zi_cond_x_all_batch = normal_density_cupy(z_batch,
z_mean,
z_stddev,
eps=eps,
gpu=gpu)
# Computing H_zi_cond_x
# --------------------------------- #
H_zi_cond_x += -cp.sum(cp.log(cp.maximum(q_zi_cond_x_batch, eps)),
axis=0)
# --------------------------------- #
# Computing H_zi
# --------------------------------- #
# Sum (p(x^(n)) * q(zi|x^(n)))
# (N, 1, 1) * (N, S_batch, z_dim) then sum axis 0 => (S_batch, z_dim)
q_zi_batch = cp.sum(
cp.expand_dims(cp.expand_dims(x_weights, axis=-1), axis=-1) *
q_zi_cond_x_all_batch,
axis=0)
# Sum (S_batch, z_dim) over S_batch => (z_dim,)
H_zi += -cp.sum(cp.log(cp.maximum(q_zi_batch, eps)), axis=0)
# --------------------------------- #
for k in range(y_dim):
# (N, 1) == (1, S_batch) => (N, S_batch)
q_yk_cond_x_all_batch = cp.equal(
cp.expand_dims(y[:, k], axis=-1),
cp.expand_dims(y[rand_ids[count:count + b], k], axis=0))
# print("q_yk_cond_x_all_batch[:10, :10]: {}".format(q_yk_cond_x_all_batch[:10, :10]))
# (N, S_batch, 1)
q_yk_cond_x_all_batch = cp.expand_dims(cp.asarray(
q_yk_cond_x_all_batch, dtype=cp.float32),
axis=-1)
# (N, S_batch, z_dim) * (N, S_batch, 1) then sum over axis=0 => (S_batch, z_dim)
q_zi_yk_batch = cp.sum(
cp.expand_dims(cp.expand_dims(x_weights, axis=-1), axis=-1)
* q_zi_cond_x_all_batch * q_yk_cond_x_all_batch,
axis=0)
# Sum (S_batch, z_dim) over S_batch => (z_dim, )
H_zi_yk[:,
k] += -cp.sum(cp.log(cp.maximum(q_zi_yk_batch, eps)),
axis=0)
count += b
progress_bar.update(b)
progress_bar.close()
# Convert entropies back to numpy
H_zi_cond_x = cp.asnumpy(H_zi_cond_x)
H_zi = cp.asnumpy(H_zi)
H_zi_yk = cp.asnumpy(H_zi_yk)
# (z_dim, )
H_zi_cond_x = H_zi_cond_x / (1.0 * num_samples)
H_zi = H_zi / (1.0 * num_samples)
H_zi_yk = H_zi_yk / (1.0 * num_samples)
print("H_yk: {}".format(H_yk))
print("\nH_zi: {}".format(H_zi))
print("\nH_zi_yk:\n{}".format(H_zi_yk))
MI_zi_yk = np.expand_dims(H_zi, axis=-1) + np.expand_dims(H_yk,
axis=0) - H_zi_yk
ids_sorted = []
MI_zi_yk_sorted = []
H_zi_yk_sorted = []
RMIG_yk = []
RMIG_norm_yk = []
JEMMIG_yk = []
for k in range(y_dim):
# Compute RMIG and JEMMI
ids_sorted_at_k = np.argsort(MI_zi_yk[:, k], axis=0)[::-1]
MI_zi_yk_sorted_at_k = np.take_along_axis(MI_zi_yk[:, k],
ids_sorted_at_k,
axis=0)
H_zi_yk_sorted_at_k = np.take_along_axis(H_zi_yk[:, k],
ids_sorted_at_k,
axis=0)
RMIG_yk_at_k = MI_zi_yk_sorted_at_k[0] - MI_zi_yk_sorted_at_k[1]
RMIG_norm_yk_at_k = np.divide(RMIG_yk_at_k, H_yk[k])
JEMMIG_yk_at_k = H_zi_yk_sorted_at_k[0] - MI_zi_yk_sorted_at_k[
0] + MI_zi_yk_sorted_at_k[1]
ids_sorted.append(ids_sorted_at_k)
MI_zi_yk_sorted.append(MI_zi_yk_sorted_at_k)
H_zi_yk_sorted.append(H_zi_yk_sorted_at_k)
RMIG_yk.append(RMIG_yk_at_k)
RMIG_norm_yk.append(RMIG_norm_yk_at_k)
JEMMIG_yk.append(JEMMIG_yk_at_k)
ids_sorted = np.stack(ids_sorted, axis=-1)
MI_zi_yk_sorted = np.stack(MI_zi_yk_sorted, axis=-1)
H_zi_yk_sorted = np.stack(H_zi_yk_sorted, axis=-1)
RMIG_yk = np.asarray(RMIG_yk, dtype=np.float32)
RMIG_norm_yk = np.asarray(RMIG_norm_yk, dtype=np.float32)
RMIG_norm = np.mean(RMIG_norm_yk, axis=0)
JEMMIG_yk = np.stack(JEMMIG_yk, axis=-1)
results = {
"H_yk": H_yk,
"H_zi_cond_x": H_zi_cond_x,
"H_zi": H_zi,
"H_zi_yk": H_zi_yk,
"H_zi_yk_sorted": H_zi_yk_sorted,
"MI_zi_yk": MI_zi_yk,
"MI_zi_yk_sorted": MI_zi_yk_sorted,
"id_sorted": ids_sorted,
"RMIG_yk": RMIG_yk,
"RMIG_norm_yk": RMIG_norm_yk,
"RMIG_norm": RMIG_norm,
"JEMMIG_yk": JEMMIG_yk,
}
return results
h = x.dot(w1)
h_relu = cp.maximum(h, 0) # using ReLU as activate function
y_pred = h_relu.dot(w2)
# Compute and print loss
loss = cp.square(y_pred - y).sum() # loss function
loss_col.append(loss)
print("第%d次訓練\n誤差:%f\n輸出:" % (t, loss))
print(y_pred)
# Backprop to compute gradients of w1 and w2 with respect to loss
grad_y_pred = 2.0 * (y_pred - y) # the last layer's error
grad_w2 = h_relu.T.dot(grad_y_pred)
grad_h_relu = grad_y_pred.dot(w2.T) # the second laye's error
grad_h = grad_h_relu.copy()
grad_h[h < 0] = 0 # the derivate of ReLU
grad_w1 = x.T.dot(grad_h)
# Update weights
w1 -= learning_rate * grad_w1
w2 -= learning_rate * grad_w2
result = cp.equal(cp.argmax(y, 1), cp.argmax(y_pred, 1))
for i in result:
if i:
k += 1
t = t + 1
print("答對筆數/總筆數: %d/%d" % (k, N))
print()
if t % 100 == 0:
plt.plot(loss_col)
plt.show()
def accuracy(y_pred, y_true):
if len(y_true[0]) == 1:
return cp.asnumpy(cp.mean(cp.equal(cp.where(y_pred<0.5, 0, 1), y_true).astype(cp.float32)))
else:
return cp.asnumpy(cp.mean(cp.equal(cp.argmax(y_pred, 1), cp.argmax(y_true, 1)).astype(cp.float32)))
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)
