def _model():
p = yield Root(tfd.Beta(dtype(1), dtype(1), name="p"))
gamma_C = yield Root(tfd.Beta(dtype(1), dtype(1), name="gamma_C"))
gamma_T = yield Root(tfd.Beta(dtype(1), dtype(1), name="gamma_T"))
eta_C = yield Root(tfd.Dirichlet(np.ones(K, dtype=dtype) / K,
name="eta_C"))
eta_T = yield Root(tfd.Dirichlet(np.ones(K, dtype=dtype) / K,
name="eta_T"))
loc = yield Root(tfd.Sample(tfd.Normal(dtype(0), dtype(1)),
sample_shape=K, name="loc"))
nu = yield Root(tfd.Sample(tfd.Uniform(dtype(10), dtype(50)),
sample_shape=K, name="nu"))
phi = yield Root(tfd.Sample(tfd.Normal(dtype(m_phi), dtype(s_phi)),
sample_shape=K, name="phi"))
sigma_sq = yield Root(tfd.Sample(tfd.InverseGamma(dtype(3), dtype(2)),
sample_shape=K,
name="sigma_sq"))
scale = np.sqrt(sigma_sq)
gamma_T_star = compute_gamma_T_star(gamma_C, gamma_T, p)
eta_T_star = compute_eta_T_star(gamma_C[..., tf.newaxis],
gamma_T[..., tf.newaxis],
eta_C, eta_T,
p[..., tf.newaxis],
gamma_T_star[..., tf.newaxis])
# likelihood
y_C = yield mix(nC, eta_C, loc, scale, name="y_C")
n0C = yield tfd.Binomial(nC, gamma_C, name="n0C")
y_T = yield mix(nT, eta_T_star, loc, scale, name="y_T")
n0T = yield tfd.Binomial(nT, gamma_T_star, name="n0T")
def create_prior(K,
a_p=1,
b_p=1,
a_gamma=1,
b_gamma=1,
m_loc=0,
g_loc=0.1,
m_sigma=3,
s_sigma=2,
m_nu=0,
s_nu=1,
m_skew=0,
g_skew=0.1,
dtype=np.float64):
return tfd.JointDistributionNamed(
dict(
p=tfd.Beta(dtype(a_p), dtype(b_p)),
gamma_C=tfd.Gamma(dtype(a_gamma), dtype(b_gamma)),
gamma_T=tfd.Gamma(dtype(a_gamma), dtype(b_gamma)),
eta_C=tfd.Dirichlet(tf.ones(K, dtype=dtype) / K),
eta_T=tfd.Dirichlet(tf.ones(K, dtype=dtype) / K),
nu=tfd.Sample(tfd.LogNormal(dtype(m_nu), s_nu), sample_shape=K),
sigma_sq=tfd.Sample(tfd.InverseGamma(dtype(m_sigma),
dtype(s_sigma)),
sample_shape=K),
loc=lambda sigma_sq: tfd.Independent(tfd.Normal(
dtype(m_loc), g_loc * tf.sqrt(sigma_sq)),
reinterpreted_batch_ndims=1),
skew=lambda sigma_sq: tfd.Independent(tfd.Normal(
dtype(m_skew), g_skew * tf.sqrt(sigma_sq)),
reinterpreted_batch_ndims=1),
))
def mix(gamma, eta, loc, scale, neg_inf, n):
return tfd.Mixture(
cat=tfd.Categorical(probs=tf.stack([gamma, 1 - gamma], axis=-1)),
components=[
tfd.Sample(tfd.Normal(np.float64(neg_inf), 1e-5), sample_shape=n),
tfd.Sample(tfd.MixtureSameFamily(
mixture_distribution=tfd.Categorical(probs=eta),
components_distribution=tfd.Normal(loc=loc, scale=scale)),
sample_shape=n)
])
def create_model(n_C, n_T, K, neg_inf=-10, dtype=np.float64):
return tfd.JointDistributionNamed(
dict(p=tfd.Beta(dtype(1), dtype(1)),
gamma_C=tfd.Gamma(dtype(3), dtype(3)),
gamma_T=tfd.Gamma(dtype(3), dtype(3)),
eta_C=tfd.Dirichlet(tf.ones(K, dtype=dtype) / K),
eta_T=tfd.Dirichlet(tf.ones(K, dtype=dtype) / K),
loc=tfd.Sample(tfd.Normal(dtype(0), dtype(1)), sample_shape=K),
sigma_sq=tfd.Sample(tfd.InverseGamma(dtype(3), dtype(2)),
sample_shape=K),
y_C=lambda gamma_C, eta_C, loc, sigma_sq: mix(
gamma_C, eta_C, loc, tf.sqrt(sigma_sq), dtype(neg_inf), n_C),
y_T=lambda gamma_C, gamma_T, eta_C, eta_T, p, loc, sigma_sq:
mix_T(gamma_C, gamma_T, eta_C, eta_T, p, loc, tf.sqrt(sigma_sq),
dtype(neg_inf), n_T)))
def __init__(
self,
name: Optional[NameType],
*,
transform=None,
observed=None,
batch_stack=None,
event_stack=None,
conditionally_independent=False,
reinterpreted_batch_ndims=0,
**kwargs,
):
self.conditions = self.unpack_conditions(**kwargs)
self._distribution = self._init_distribution(self.conditions)
super().__init__(
self.unpack_distribution, name=name, keep_return=True, keep_auxiliary=False
)
if name is None and observed is not None:
raise ValueError(
"Observed variables are not allowed for anonymous (with name=None) Distributions"
)
self.model_info.update(observed=observed)
self.transform = self._init_transform(transform)
self.batch_stack = batch_stack
self.event_stack = event_stack
self.conditionally_independent = conditionally_independent
self.reinterpreted_batch_ndims = reinterpreted_batch_ndims
if reinterpreted_batch_ndims:
self._distribution = tfd.Independent(
self._distribution, reinterpreted_batch_ndims=reinterpreted_batch_ndims
)
if batch_stack is not None:
self._distribution = BatchStacker(self._distribution, batch_stack=batch_stack)
if event_stack is not None:
self._distribution = tfd.Sample(self._distribution, sample_shape=self.event_stack)
def mix(n, eta, loc, scale, name):
return tfd.Sample(
tfd.MixtureSameFamily(
mixture_distribution=tfd.Categorical(probs=eta),
components_distribution=tfd.Normal(loc=loc, scale=scale),
name=name),
sample_shape=n)
def create_dp_sb_gmm(nobs, K, dtype=np.float64):
return tfd.JointDistributionNamed(
dict(
# Mixture means
mu=tfd.Independent(tfd.Normal(np.zeros(K, dtype), 3),
reinterpreted_batch_ndims=1),
# Mixture scales
sigma=tfd.Independent(tfd.LogNormal(loc=np.full(K, -2, dtype),
scale=0.5),
reinterpreted_batch_ndims=1),
# Mixture weights (stick-breaking construction)
alpha=tfd.Gamma(concentration=np.float64(1.0), rate=10.0),
v=lambda alpha: tfd.Independent(
# NOTE: Dave Moore suggests doing this instead, to ensure
# that a batch dimension in alpha doesn't conflict with
# the other parameters.
tfd.Beta(np.ones(K - 1, dtype), alpha[..., tf.newaxis]),
reinterpreted_batch_ndims=1),
# Observations (likelihood)
obs=lambda mu, sigma, v: tfd.Sample(
tfd.MixtureSameFamily(
# This will be marginalized over.
mixture_distribution=tfd.Categorical(probs=stickbreak(v)),
components_distribution=tfd.Normal(mu, sigma)),
sample_shape=nobs)))
def __init__(self, blocks, hdLayers, latent_dim, label_dim, layerSize,
input_dim, clipval, permutation, zero_noise, y_noise,
latent_perturb_scale, **kwargs):
'''
Input:
blocks <int> defines the amount of blocks that the INN should contain
hdLayers <int> defines the amount of hidden layers per sub network
latent_dim <int> defines the dimension of the latent space
layerSize <int> defines the amount of neurons in each hidden layer
input_dim <int> defines the dimension of the input
clipval <float> defines the maximum argument in the exponential function
permutation <int array> defines a permutation to shuffle data at the end of a block
zero_noise <float> scale of Gaussian distribution used to fill the padding dimensions
y_noise <float> scale of Gaussian distribution used to perturb the labels.
latent_perturb_scale <float> defines how much the latent variable will be perturbed in the call function
This class contains a whole INN with multiple blocks.
'''
super(INN, self).__init__(**kwargs)
#initilizing variables
self.input_dim = input_dim
self.latent_dim = latent_dim
self.label_dim = label_dim
self.latent_perturb_scale = latent_perturb_scale
#initilizing the random distributions that are needed
latent_mean = tf.zeros(2)
latent_scale = tf.ones(2)
zero_mean = tf.zeros(self.input_dim - 2)
label_mean = tf.zeros(self.label_dim)
self.s = tfd.Sample(tfd.Normal(loc=latent_mean, scale=latent_scale))
self.s2 = tfd.Sample(tfd.Normal(loc=zero_mean, scale=zero_noise))
self.s3 = tfd.Sample(tfd.Normal(loc=label_mean, scale=y_noise))
#filling a list with the INNBlocks for the network
self.blocks = []
for curBlock in range(blocks - 1):
self.blocks.append(
INNBlock(hdLayers, layerSize, input_dim, clipval, permutation))
self.blocks.append(
INNBlockLast(hdLayers, layerSize, input_dim, clipval))
def __init__(self,
name: Optional[NameType],
*,
transform=None,
observed=None,
plate=None,
**kwargs):
self.conditions = self.unpack_conditions(**kwargs)
self._distribution = self._init_distribution(self.conditions)
self.plate = plate
super().__init__(self.unpack_distribution,
name=name,
keep_return=True,
keep_auxiliary=False)
if name is None and observed is not None:
raise ValueError(
"Observed variables are not allowed for anonymous (with name=None) Distributions"
)
self.model_info.update(observed=observed)
self.transform = self._init_transform(transform)
if self.plate is not None:
self._distribution = tfd.Sample(self._distribution,
sample_shape=self.plate)
return tf.linalg.cholesky(K)
def compute_f(alpha, rho, beta, eta):
LK = compute_LK(alpha, rho, X)
f = tf.linalg.matvec(LK, eta) # LK * eta, (matrix * vector)
return f + beta[..., tf.newaxis]
# GP Binary Classification Model.
gpc_model = tfd.JointDistributionNamed(
dict(
alpha=tfd.LogNormal(dtype(0), dtype(1)),
rho=tfd.LogNormal(dtype(0), dtype(1)),
beta=tfd.Normal(dtype(0), dtype(1)),
eta=tfd.Sample(tfd.Normal(dtype(0), dtype(1)),
sample_shape=X.shape[0]),
# NOTE: `Sample` and `Independent` resemble, respectively,
# `filldist` and `arraydist` in Turing.
obs=lambda alpha, rho, beta, eta: tfd.Independent(
tfd.Bernoulli(logits=compute_f(alpha, rho, beta, eta)),
reinterpreted_batch_ndims=1)))
### MODEL SET UP ###
# For some reason, this is needed for the compiler
# to know the correct model parameter dimensions.
_ = gpc_model.sample()
# Parameters as they appear in model definition.
# NOTE: Initial values should be defined in order appeared in model.
ordered_params = ['alpha', 'rho', 'beta', 'eta']
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
if self.plate is not None:
self._backend_distribution = tfd.Sample(self._backend_distribution,
sample_shape=self.plate)
def eightGauss(save=False):
'''
This function trains an INN on a Gaussain mixture model and then shows how well the network is able to generate data similar to the training data.
Option:
save <bool> if True the figures will be saved
'''
numb_of_dists = 8 # number of distributions in the gaussian mixture model
size = 1000 # number of datapoints per distribution
zero_noise = 0.08 # scale of the Gaussian distribution used to fill the padding dimensions
y_noise = 0.105 # scale of the Gaussian distribution used to perturb the label dimensions
input_dim = 16 # input dimension
latent_dim = 2 # latent dimension
label_dim = 4 # label dimension
# A Callback function is can be called during training to set the training parameters dynamically.
class MyCallback(tf.keras.callbacks.Callback):
def __init__(self, alpha, beta):
'''
Input:
alpha, beta <Keras variable> placeholder for a loss weight
'''
self.alpha = alpha
self.beta = beta
self.i = 0.0 # counts the number of training steps completed
def on_train_begin(self, logs={}):
'''This function is called each time the training starts.'''
self.i += 1.0
#set values of alpha and beta
self.alpha = K.set_value(
self.alpha, 20 *
np.asarray([1., 2. * 0.003**(1.0 - (self.i / 30.0))]).min())
self.beta = K.set_value(self.beta,
np.asarray([self.i * 3, 21]).min())
def genData(s, input_dim, latent_dim, label_dim):
'''
Input:
s <tensorflow_probability distribution object> contains the distribution used to sample the latent variable.
input_dim <int> input dimension
latent_dim <int> latent dimension
label_dim <int> label dimension
Output:
x <2D numpy array> contains x and y coorinates of the Gaussian mixture model
y <2D numpy array> contains the perturbed labels
z <2D numpy array> contains the latent variables
y_clean <2D numpy array> contains the unperturb version of the labels
This function generates all the data needed to train the INN
'''
#get x and y coordinates as well as labels for a gaussian mixture model.
ga = gaussian.mixture(numb_of_dists, size=size)
#shuffle the data
np.random.shuffle(ga)
#store x and y coordinates
x = np.delete(ga, 2, axis=1)
#sample a set of latent variables
z = tf.dtypes.cast(s.sample(numb_of_dists * size),
tf.dtypes.float32).numpy()
#get the labels
_, _, y_load = ga.T
#keep the labels in a custom form
y_clean = np.zeros((numb_of_dists * size, label_dim))
for j in range(len(y_clean)):
if y_load[j] < 4:
y_clean[j][0] += 1.0
else:
if y_load[j] < 6:
y_clean[j][1] += 1.0
else:
y_clean[j][int(y_load[j] - 4)] += 1.0
#perturb the labels
y = y_clean + np.random.normal(
loc=0.0, scale=y_noise, size=(len(y_load), label_dim))
return x, y, z, y_clean
#creating an INN
inn = INN(3, 3, latent_dim, label_dim, 384, input_dim, 2.0,
[7, 12, 5, 15, 2, 14, 6, 10, 8, 3, 1, 11, 13, 9, 4, 0],
zero_noise, y_noise, 0.05)
#loading an already trained INN
# inn.load_weights("./network/8Gauss.tf")
#intilizing the callback variables
alpha = K.variable(0.0)
beta = K.variable(0.0)
#compiling the model.
inn.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.001,
beta_1=0.5,
beta_2=0.5,
amsgrad=False,
clipvalue=15.0),
loss=[losses.MMD_forward, 'mse', 'mse', losses.MMD_backward],
loss_weights=[18.0, 0.08, 0.08, beta],
metrics=['accuracy'])
#creating distribution objects used to sample the latent variable (s) and padding dimension (s2)
latent_mean = np.zeros(2)
zero_mean = np.zeros(input_dim - 2)
s = tfd.Sample(tfd.Normal(loc=latent_mean, scale=1.0))
s2 = tfd.Sample(tfd.Normal(loc=zero_mean, scale=zero_noise))
#training loop
for i in range(30):
x_pad = s2.sample((numb_of_dists * size)).numpy()
x, y, z, y_clean = genData(s, input_dim, latent_dim, label_dim)
#concatenate the data to their final form used in the training process
x_t = np.concatenate((x, x_pad, y_clean), axis=1)
y_t = np.concatenate([
y,
np.random.normal(loc=0.0,
scale=zero_noise,
size=(len(x), input_dim - label_dim - latent_dim))
],
axis=1)
z_t = np.concatenate([z, y], axis=1)
#training the network
inn.fit(x_t, [z_t, y_t, x_t[:, :input_dim], x],
epochs=1,
batch_size=200,
verbose=2,
callbacks=[MyCallback(alpha, beta)]) #,callbacks=[tensorboard]
#saving the network weights
# inn.save_weights('./network/8Gauss.tf')
#generating new data to plot the results
x_pad = s2.sample((numb_of_dists * size)).numpy().astype(np.float32)
x, y, z, _ = genData(s, input_dim, latent_dim, label_dim)
x_t = np.concatenate((x, x_pad), axis=1)
y_t = np.concatenate([
y,
np.random.normal(loc=0.0,
scale=zero_noise,
size=(len(x), input_dim - label_dim - latent_dim))
],
axis=1)
z_t = np.concatenate([z, y_t], axis=1)
show_size = 2000
#using the generated data to perform an inverse pass through the network
out = inn.inv(z_t[:show_size])
#splitting the output into x and y coordinates
x_coord, y_coord = out[0].numpy().T
fig = py.figure(figsize=(11, 11))
fig.subplots_adjust(left=0.1, right=0.9, bottom=0.2, top=0.8)
ax = fig.add_subplot(111)
ax.set_xlabel("X", fontsize=25)
ax.set_ylabel("Y", fontsize=25)
ax.tick_params(axis='both', which='major', labelsize=24)
#///////////////////////////////////
# ax.set_title("Generated Data",fontsize=25)
ax.set_ylim(bottom=-3.1, top=3.1)
ax.set_xlim(left=-3.1, right=3.1)
#//////////////////////////////
ax.scatter(x_coord,
y_coord,
cmap='Spectral',
c=np.argmax(y[:show_size], axis=1),
s=2.0)
if save:
fig.savefig('8gaussGen.png', dpi=300)
fig = py.figure(figsize=(11, 11))
fig.subplots_adjust(left=0.1, right=0.9, bottom=0.2, top=0.8)
ax = fig.add_subplot(111)
ax.set_xlabel("X", fontsize=25)
ax.set_ylabel("Y", fontsize=25)
ax.tick_params(axis='both', which='major', labelsize=24)
ax.set_ylim(bottom=-3.1, top=3.1)
ax.set_xlim(left=-3.1, right=3.1)
ax.scatter(x[:show_size, 0],
x[:show_size, 1],
cmap='Spectral',
c=np.argmax(y[:show_size], axis=1),
s=2.0)
if save:
fig.savefig('8gaussOrig.png', dpi=300)
py.show()
def polar1(save=False):
input_dim = 2
inn = INN(64, input_dim, -1.0, 1.0)
inn.load_weights("./network/polar1.tf")
inn.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.0001,
beta_1=0.99,
beta_2=0.999,
amsgrad=False),
loss='mse',
metrics=['accuracy'])
loc1 = np.asarray([3.0, 0.0])
loc2 = np.zeros(6)
s = tfd.Sample(tfd.Uniform(low=[0.1, -5.0], high=[5.0, 5.0]))
s2 = tfd.Sample(tfd.Normal(loc=loc2, scale=0.05))
for i in range(0):
x, y = s.sample(10000).numpy().T
x_t = np.asarray([x, y]).T
r, phi = polar(x, y)
y_t = np.asarray([r, phi]).T
inn.fit(x_t, y_t, epochs=2, batch_size=256, verbose=2)
x, y = np.random.normal(4.0, 1.0, (600)), np.random.normal(0.0, 1.0, (600))
x_t = np.asarray([x, y]).T
r, phi = polar(x, y)
x_t = np.asarray([x, y]).T #network input
rp, phip = inn.predict(x_t).T
y_t = np.asarray([r, phi]).T #inverse network input
xp, yp = inn.inv(y_t).numpy().T
# print(np.mean(np.abs(r-rr)))
# print(np.mean(np.abs(phi-rphi)))
# for polar1forward------------------------------------------------------------
fig = py.figure(figsize=(11, 9))
fig.subplots_adjust(left=0.2, right=0.95, bottom=0.2, top=0.95)
ax = fig.add_subplot(111)
ax.plot(rp * np.cos(phip), rp * np.sin(phip), 'ro', label='transformed')
ax.plot(x, y, 'go', label='original')
ax.set_xlabel("X", fontsize=30)
ax.set_ylabel("Y", fontsize=30)
ax.tick_params(axis='both', which='major', labelsize=29)
ax.legend(fontsize=25)
if save:
fig.savefig('polar1forward.png', dpi=300)
# for polar1backward - ------------------------------------------------------ fig = py.figure(figsize=(10,9))
fig = py.figure(figsize=(11, 9))
fig.subplots_adjust(left=0.2, right=0.95, bottom=0.2, top=0.95)
ax = fig.add_subplot(111)
ax.plot(xp, yp, 'ro', label='inverse transformed')
ax.plot(x, y, 'go', label='original')
ax.set_xlabel("X", fontsize=30)
ax.set_ylabel("Y", fontsize=30)
ax.tick_params(axis='both', which='major', labelsize=29)
ax.legend(fontsize=25)
if save:
fig.savefig('polar1backward.png', dpi=300)
# py.show()
# for polar1mesh-----------------------------------------
# rr, rphi = polar(xmesh,ymesh)
# out = inn.predict(mesh)
# r,phi = out.T
# y_t = np.asarray([rr,rphi]).T
# out = inn.inv(y_t).numpy()
# xr,yr = out.T
# fig = py.figure(figsize=(15,15))
# fig.subplots_adjust(left=0.1,right = 0.9,bottom=0.2,top=0.8)
# ax = fig.add_subplot(111)
# ax.plot(r*np.cos(phi),r*np.sin(phi),'bo',label ='transformed')
# ax.plot(xr,yr,'ro',label='inverse transform')
# ax.plot(xmesh,ymesh,'go',label='original',alpha=0.5)
# ax.set_xlabel("X",fontsize=25)
# ax.set_ylabel("Y",fontsize=25)
# ax.tick_params(axis='both', which='major', labelsize=24)
# ax.legend(fontsize = 20)
# if save:
# fig.savefig('polar1mesh.png',dpi=300)
py.show()
# inn.save_weights('./network/polar1.tf')
return None
def twoGauss(save = False):
# This function trains an INN on a Gaussain mixture model and then shows how well the network is able to generate data similar to the training data.
# Option:
# save <bool> if True the figures will be saved
numb_of_dists = 2 # number of distributions in the gaussian mixture model
size = 1000 # number of datapoints per distribution
zero_noise=0.09 # scale of the Gaussian distribution used to fill the padding dimensions
y_noise = 0.1 # scale of the Gaussian distribution used to perturb the label dimensions
input_dim = 8 # input dimension
latent_dim = 2 # latent dimension
label_dim = 0 # label dimension
# A Callback function is can be called during training to set the training parameters dynamically.
class MyCallback(tf.keras.callbacks.Callback):
def __init__(self, alpha, beta):
# Input:
# alpha, beta <Keras variable> placeholder for a loss weight
self.alpha = alpha
self.beta = beta
self.i = 0.0 # counts the number of training steps completed
def on_train_begin(self, logs={}):
#is called each time the training starts.
self.i += 1.0
#set values of alpha and beta
self.alpha =K.set_value(self.alpha, 20* np.asarray([1., 2. * 0.003**(1.0 - (self.i / 30.0))]).min())
self.beta = K.set_value(self.beta,np.asarray([self.i*1.5,16]).min())
def genData(s,input_dim,latent_dim):
# Input:
# s <tensorflow_probability distribution object> contains the distribution used to sample the latent variable.
# input_dim <int> input dimension
# latent_dim <int> latent dimension
# Output:
# x <2D numpy array> contains x and y coorinates of the Gaussian mixture model
# z <2D numpy array> contains the latent variables
#
# This function generates all the data needed to train the INN
#get x and y coordinates as well as labels for a gaussian mixture model.
ga = gaussian.mixture(numb_of_dists,size=size)
#shuffle the data
np.random.shuffle(ga)
#store x and y coordinates
x = np.delete(ga,2,axis=1)
#sample a set of latent variables
z = tf.dtypes.cast(s.sample(numb_of_dists*size),tf.dtypes.float32).numpy()
return x,z
#creating an INN
inn = INN(4,5,latent_dim,label_dim,256,input_dim,2.0,[1,2,7,5,4,6,3,0],zero_noise,y_noise,0.1)
#loading an already trained INN
# inn.load_weights("./network/2Gauss.tf")
#intilizing the callback variables
alpha = K.variable(0.0)
beta = K.variable(0.0)
#compiling the model.
inn.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.0001, beta_1=0.9, beta_2=0.9,amsgrad=False,clipvalue=15.0),loss=[losses.MMD_forward,'mse','mse',losses.MMD_backward],loss_weights=[100.0,4.0,4.0,100.0],metrics=['accuracy'])
#creating distribution objects used to sample the latent variable (s) and padding dimension (s2)
latent_mean = np.zeros(2)
zero_mean = np.zeros(input_dim -2)
s = tfd.Sample(tfd.Normal(loc=latent_mean, scale=1.0))
s2 = tfd.Sample(tfd.Normal(loc=zero_mean, scale=zero_noise))
#training loop
for i in range(60):
#generate data
x_pad = s2.sample((numb_of_dists*size)).numpy()
x,z = genData(s,input_dim,latent_dim)
#concatenate the data to their final form used in the training process
x_t = np.concatenate((x,x_pad),axis=1)
y_t = np.concatenate([np.random.normal(loc=0.0,scale=zero_noise,size=(len(x),input_dim - label_dim - latent_dim))],axis=1)
#training the network
inn.fit(x_t,[z,y_t,x_t[:,:input_dim],x],epochs=2,batch_size=2000,verbose=2,callbacks=[MyCallback(alpha,beta)]) #,callbacks=[tensorboard]
#saving the network weights
# inn.save_weights('./network/2Gauss.tf')
#generating new data to plot the results
x_pad = s2.sample((numb_of_dists*size)).numpy().astype(np.float32)
x,z = genData(s,input_dim,latent_dim)
#z= np.random.uniform(low=-1.0,high=1.0,size=(2000,2))
x_t = np.concatenate((x,x_pad),axis=1)
y_t = np.concatenate([np.random.normal(loc=0.0,scale=zero_noise,size=(len(x),input_dim - label_dim - latent_dim))],axis=1)
z_t = np.concatenate([z,y_t],axis=1)
show_size = 2000
#using the generated data to perform an inverse pass through the network
out = inn.inv(z_t[:show_size])
#splitting the output into x and y coordinates
x_coord,y_coord = out[0].numpy().T
fig=py.figure(figsize=(14,3.5))
fig.subplots_adjust(left=0.1,right = 0.9,bottom=0.25,top=0.9)
ax = fig.add_subplot(111)
ax.set_xlabel("X",fontsize=25)
ax.set_ylabel("Y",fontsize=25)
ax.tick_params(axis='both', which='major', labelsize=24)
#///////////////////////////////////
# ax.set_title("Generated Data",fontsize=25)
ax.set_ylim(bottom = -0.5,top =0.5)
ax.set_xlim(left = -3.1,right=3.1)
#//////////////////////////////
ax.scatter(x_coord,y_coord,c='red',s=2.0)
if save:
fig.savefig('2gaussGen.png',dpi=300)
fig=py.figure(figsize=(14,3.5))
fig.subplots_adjust(left=0.1,right = 0.9,bottom=0.25,top=0.9)
ax = fig.add_subplot(111)
ax.set_xlabel("X",fontsize=25)
ax.set_ylabel("Y",fontsize=25)
ax.tick_params(axis='both', which='major', labelsize=24)
ax.set_ylim(bottom = -0.5,top =0.5)
ax.set_xlim(left = -3.1,right=3.1)
ax.scatter(x[:show_size,0],x[:show_size,1],c='red',s=2.0)
if save:
fig.savefig('2gaussOrig.png',dpi=300)
py.show()
