def standardrecon(config, base, pos, bias, R=8):
bs, nc = config['boxsize'], config['nc']
basesm = tools.gauss(base, tools.fftk((nc, nc, nc), bs), R)
g = tf.Graph()
with g.as_default():
mesh = tf.constant(basesm.astype(np.float32))
meshk = tfpmfuncs.r2c3d(mesh, norm=nc**3)
DX = tfpm.lpt1(meshk, pos, config)
DX = tf.multiply(DX, -1 / bias)
pos = tf.add(pos, DX)
displaced = tf.zeros_like(mesh)
displaced = tfpm.cic_paint(displaced,
pos,
boxsize=bs,
name='displaced')
DXrandom = tfpm.lpt1(meshk, config['grid'], config)
DXrandom = tf.multiply(DXrandom, -1 / bias)
posrandom = tf.add(config['grid'], DXrandom)
random = tf.zeros_like(mesh)
random = tfpm.cic_paint(random, posrandom, boxsize=bs, name='random')
tf.add_to_collection('recon', [displaced, random])
return g
def mpm_mc(signal_noisy, w, p, A, m1, sig1, m2, sig2):
"""
Cette fonction permet d'appliquer la méthode mpm pour retrouver notre signal d'origine à partir de sa version bruité et des paramètres du model.
:param signal_noisy: Signal bruité (numpy array 1D de float)
:param w: vecteur dont la première composante est la valeur de la classe w1 et la deuxième est la valeur de la classe w2
:param p: vecteur de taille 2 avec la probailité d'apparition a priori pour chaque classe
:param A: Matrice (2*2) de transition de la chaîne
:param m1: La moyenne de la première gaussienne
:param sig1: L'écart type de la première gaussienne
:param m2: La moyenne de la deuxième gaussienne
:param sig2: L'écart type de la deuxième gaussienne
:return: Un signal discret à 2 classe (numpy array 1D d'int), résultat de la segmentation par mpm du signal d'entrée
"""
gausses = gauss(signal_noisy, m1, sig1, m2, sig2)
alpha = forward(A, p, gausses)
beta = backward(A, gausses)
gamma = alpha * beta
X = []
indexes = np.argmax(gamma, axis=1)
for index in indexes:
X.append(w[index])
return np.array(X)
def calc_param_EM_mc(signal_noisy, p, A, m1, sig1, m2, sig2):
"""
Cette fonction permet de calculer les nouveaux paramètres estimé pour une itération de EM
:param signal_noisy: Signal bruité (numpy array 1D de float)
:param p: vecteur de taille 2 avec la probailité d'apparition a priori pour chaque classe
:param A: Matrice (2*2) de transition de la chaîne
:param m1: La moyenne de la première gaussienne
:param sig1: L'écart type de la première gaussienne
:param m2: La moyenne de la deuxième gaussienne
:param sig2: L'écart type de la deuxième gaussienne
:return: tous les paramètres réestimés donc p, A, m1, sig1, m2, sig2
"""
gausses = gauss(signal_noisy, m1, sig1, m2, sig2)
alpha = forward(A, p, gausses)
beta = backward(A, gausses)
gamma = np.zeros((2, len(signal_noisy)))
for t in range(len(signal_noisy) - 1):
for i in range(2):
for j in range(2):
gamma[i][t] += calculate_pijn(i, j, t, alpha, beta, gausses, A)
p_est = [gamma[0][0], gamma[1][0]]
A_est = np.zeros((2, 2))
for i in range(2):
for j in range(2):
num, denom = 0, 0
for t in range(len(signal_noisy) - 1):
num += calculate_pijn(i, j, t, alpha, beta, gausses, A)
denom += gamma[i][t]
A_est[i][j] = num / denom
num = [0, 0]
denom = [0, 0]
for t in range(len(signal_noisy)):
print(str(t) + ' 1\r', end="")
num[0] += signal_noisy[t] * gamma[0][t]
denom[0] += gamma[0][t]
num[1] += signal_noisy[t] * gamma[1][t]
denom[1] += gamma[1][t]
m1_est = num[0] / denom[0]
m2_est = num[1] / denom[1]
num = [0, 0]
denom = [0, 0]
for t in range(len(signal_noisy)):
print(str(t) + ' 2\r', end="")
num[0] += np.power(signal_noisy[t] - m1_est, 2) * gamma[0][t]
denom[0] += gamma[0][t]
num[1] += np.power(signal_noisy[t] - m2_est, 2) * gamma[1][t]
denom[1] += gamma[1][t]
sig1_est = np.sqrt(num[0] / denom[0])
sig2_est = np.sqrt(num[1] / denom[1])
return p_est, A_est, m1_est, sig1_est, m2_est, sig2_est
def Squeeze_excitation_layer(input_x, out_dim, ratio, layer_name, is_training):
with tf.variable_scope(layer_name):
squeeze = slim.avg_pool2d(input_x,
input_x.get_shape()[1:3],
padding='VALID',
scope=layer_name + 'AvgPool')
excitation = slim.fully_connected(squeeze,
int(out_dim / ratio),
activation_fn=None,
scope=layer_name +
'_fully_connected1')
excitation = slim.dropout(excitation,
0.5,
is_training=is_training,
scope=layer_name + 'Dropout_1')
excitation = tf.nn.relu(excitation, name=layer_name + '_relu')
excitation = slim.fully_connected(excitation,
int(out_dim),
activation_fn=None,
scope=layer_name +
'_fully_connected2')
excitation = slim.dropout(excitation,
0.5,
is_training=is_training,
scope=layer_name + 'Dropout_2')
excitation = tf.nn.sigmoid(excitation, name=layer_name + '_sigmoid')
excitation = tf.reshape(excitation, [-1, 1, 1, out_dim])
scale = input_x * excitation
group_net = tf.reduce_mean(scale, axis=3, keep_dims=True)
group_net = gauss(group_net)
group_net = slim.flatten(group_net)
temp_list = list()
for i in range(batch_size):
temp_img = group_net[i, :]
temp_img = tf.reshape(norm(temp_img), (8, 8))
temp_img = tf.expand_dims(temp_img, axis=0)
temp_list.append(temp_img)
group_net = tf.concat(temp_list, axis=0)
group_net = tf.expand_dims(group_net, axis=3)
return scale, group_net
def calc_param_EM_gm(signal_noisy, p, m1, sig1, m2, sig2):
"""
Cette fonction permet de calculer les nouveaux paramètres estimé pour une itération de EM
:param signal_noisy: Signal bruité (numpy array 1D de float)
:param p: vecteur de taille 2 avec la probailité d'apparition a priori pour chaque classe
:param m1: La moyenne de la première gaussienne
:param sig1: L'écart type de la première gaussienne
:param m2: La moyenne de la deuxième gaussienne
:param sig2: L'écart type de la deuxième gaussienne
:return: tous les paramètres réestimés donc p, m1, sig1, m2, sig2
"""
gausses = gauss(signal_noisy, m1, sig1, m2, sig2)
proba_apost = p * gausses
proba_apost = proba_apost / (proba_apost.sum(axis=1)[..., np.newaxis])
p = proba_apost.sum(axis=0) / proba_apost.shape[0]
m1 = (proba_apost[:, 0] * signal_noisy).sum() / proba_apost[:, 0].sum()
sig1 = np.sqrt((proba_apost[:, 0] * ((signal_noisy - m1)**2)).sum() /
proba_apost[:, 0].sum())
m2 = (proba_apost[:, 1] * signal_noisy).sum() / proba_apost[:, 1].sum()
sig2 = np.sqrt((proba_apost[:, 1] * ((signal_noisy - m2)**2)).sum() /
proba_apost[:, 1].sum())
return p, m1, sig1, m2, sig2
def mpm_gm(signal_noisy, w, p, m1, sig1, m2, sig2):
"""
Cette fonction permet d'appliquer la méthode mpm pour retrouver notre signal d'origine à partir de sa version bruité et des paramètres du model.
:param signal_noisy: Signal bruité (numpy array 1D de float)
:param w: vecteur dont la première composante est la valeur de la classe w1 et la deuxième est la valeur de la classe w2
:param p: vecteur de taille 2 avec la probailité d'apparition a priori pour chaque classe
:param m1: La moyenne de la première gaussienne
:param sig1: L'écart type de la première gaussienne
:param m2: La moyenne de la deuxième gaussienne
:param sig2: L'écart type de la deuxième gaussienne
:return: Un signal discret à 2 classe (numpy array 1D d'int)
"""
gausses = gauss(signal_noisy, m1, sig1, m2, sig2)
proba_apost = p * gausses
proba_apost = proba_apost / (proba_apost.sum(axis=1)[..., np.newaxis])
X = []
indexes = np.argmax(proba_apost, axis=1)
for index in indexes:
X.append(w[index])
return np.array(X)