def __init__(self, name, DNA_size, global_pop, N_POP_size, Factor=2):
"""
这个类用来定义种群网络
:param name: 用来表示所在种群的名称
:param DNA_size: 用来表示所在种群的大小
:param global_pop: 用来存储对应的全局网络
:param N_POP_size: 用来表示每个种群要生成的offset的个数
:param Factor: 用来表示所选取的offset用于更新网络的个数因子
"""
with tf.variable_scope(name):
self.name = name
self.DNA_size = DNA_size
self.N_POP_size = N_POP_size
self.C_POP_size = math.floor(N_POP_size / Factor)
with tf.variable_scope('mean'):
self.mean = tf.Variable(tf.truncated_normal([
self.DNA_size,
],
stddev=0.05,
mean=0.5),
dtype=tf.float16,
name=name + '_mean')
with tf.variable_scope('cov'):
self.cov = tf.Variable(1.0 * tf.eye(self.DNA_size),
dtype=tf.float16,
name=name + '_cov')
self.mvn = MultivariateNormalFullCovariance(loc=self.mean,
covariance_matrix=abs(
self.cov))
self.make_kid = self.mvn.sample(self.N_POP_size)
self.tfkids_fit = tf.placeholder(tf.float16, [
self.C_POP_size,
])
self.tfkids = tf.placeholder(tf.float16,
[self.C_POP_size, self.DNA_size])
self.loss = -tf.reduce_mean(
self.mvn.log_prob(self.tfkids) * self.tfkids_fit)
self.train_op = tf.train.AdamOptimizer().minimize(self.loss)
self.mean_params = tf.get_collection(
tf.GraphKeys.TRAINABLE_VARIABLES, scope=name + '/mean')
self.cov_params = tf.get_collection(
tf.GraphKeys.TRAINABLE_VARIABLES, scope=name + '/cov')
with tf.name_scope('pull'):
self.pull_mean_op = self.mean.assign(global_pop.mean)
self.pull_cov_op = self.cov.assign(global_pop.cov)
with tf.name_scope('push'):
self.push_mean_op = global_pop.mean.assign(self.mean)
self.push_cov_op = global_pop.cov.assign(self.cov)
with tf.name_scope('restart'):
self.re_mean_op = self.mean.assign(
tf.Variable(tf.truncated_normal([
self.DNA_size,
],
stddev=0.05,
mean=0.5),
dtype=tf.float32))
self.re_cov_op = self.cov.assign(
tf.Variable(1.0 * tf.eye(self.DNA_size), dtype=tf.float32))
def __init__(self, name, data, global_pop, bili):
with tf.variable_scope(name):
self.name = name
self.max_fit = 0.0
self.fit_val = 0.0
self.dr = 0.0
self.bili = bili
self.DNA_size = data.getDNA_size()
# self.mean_params, self.cov_params, self.mean, self.cov = self._creat_net(name, data.getDNA_size())
with tf.variable_scope('mean'):
self.mean = tf.Variable(tf.truncated_normal([
self.DNA_size,
],
stddev=0.1,
mean=0.5),
dtype=tf.float32,
name=name + '_mean')
with tf.variable_scope('cov'):
self.cov = tf.Variable(1.0 * tf.eye(self.DNA_size),
dtype=tf.float32,
name=name + '_cov')
self.mvn = MultivariateNormalFullCovariance(loc=self.mean,
covariance_matrix=abs(
self.cov))
self.make_kid = self.mvn.sample(N_POP)
self.tfkids_fit = tf.placeholder(tf.float32, [
N_POP,
])
self.tfkids = tf.placeholder(tf.float32, [N_POP, self.DNA_size])
# self.loss = -tf.reduce_mean(
# self.mvn.log_prob(self.tfkids) * self.tfkids_fit + 0.01 * self.mvn.log_prob(
# self.tfkids) * self.mvn.prob(
# self.tfkids))
self.loss = -tf.reduce_mean(
self.mvn.log_prob(self.tfkids) * 0.04 * (self.tfkids_fit**3))
self.train_op = tf.train.AdamOptimizer().minimize(self.loss)
# self.train_op = tf.train.GradientDescentOptimizer(LEARNING_RATE).minimize(
# self.loss) # compute and apply gradients for mean and cov
self.mean_params = tf.get_collection(
tf.GraphKeys.TRAINABLE_VARIABLES, scope=name + '/mean')
self.cov_params = tf.get_collection(
tf.GraphKeys.TRAINABLE_VARIABLES, scope=name + '/cov')
with tf.name_scope('pull'):
self.pull_mean_op = self.mean.assign(global_pop.mean)
self.pull_cov_op = self.cov.assign(global_pop.cov)
# self.pull_mean_params_op = [l_p.assign(g_p) for l_p, g_p in
# zip(self.mean_params, global_pop.mean_params)]
# self.pull_cov_params_op = [l_p.assign(g_p) for l_p, g_p in zip(self.cov_params, global_pop.cov_params)]
with tf.name_scope('push'):
self.push_mean_op = global_pop.mean.assign(self.mean)
self.push_cov_op = global_pop.cov.assign(self.cov)
def _built_net(self, scope, DNA_SIZE, N_POP):
mean = tf.Variable(tf.truncated_normal([DNA_SIZE, ], stddev=0.02, mean=0.5), dtype=tf.float32)
cov = tf.Variable(tf.eye(DNA_SIZE), dtype=tf.float32)
mvn = MultivariateNormalFullCovariance(loc=mean, covariance_matrix=abs(
cov + tf.Variable(0.001 * tf.eye(DNA_SIZE), dtype=tf.float32)))
# make_kid = mvn.sample(N_POP)
return mvn
def __init__(self, name, pops, pop, sub, sub_size):
"""
这个类是用来定义全局网络的类
:param name: 用来表示所在种群全局网络的名称
:param pops: 用来表示所有的线程
:param pop: 用来表示所在的种群
:param sub: 用来表示所在的子集
:param sub_size: 用来表示所在种群的种群大小
"""
with tf.variable_scope(name):
self.name = name
self.pops = pops
self.pop = pop
self.sub = sub
self.sub_size = sub_size
with tf.variable_scope('mean'):
self.mean = tf.Variable(tf.truncated_normal([
self.sub_size,
],
stddev=0.05,
mean=0.5),
dtype=tf.float32,
name=name + '_mean')
with tf.variable_scope('cov'):
self.cov = tf.Variable(0.5 * tf.eye(self.sub_size),
dtype=tf.float32,
name=name + '_cov')
self.mvn = MultivariateNormalFullCovariance(loc=self.mean,
covariance_matrix=abs(
self.cov))
self.mean_params = tf.get_collection(
tf.GraphKeys.TRAINABLE_VARIABLES, scope=name + '/mean')
self.cov_params = tf.get_collection(
tf.GraphKeys.TRAINABLE_VARIABLES, scope=name + '/cov')
def __init__(self, name, DNA_size):
"""
这个类是用来定义全局网络的类
:param name: 用来表示所在种群全局网络的名称
:param DNA_size: 用来表示所在种群的种群大小
"""
with tf.variable_scope(name):
self.name = name
self.DNA_size = DNA_size
with tf.variable_scope('mean'):
self.mean = tf.Variable(tf.truncated_normal([
self.DNA_size,
],
stddev=0.05,
mean=0.5),
dtype=tf.float16,
name=name + '_mean')
with tf.variable_scope('cov'):
self.cov = tf.Variable(1.0 * tf.eye(self.DNA_size),
dtype=tf.float16,
name=name + '_cov')
self.mvn = MultivariateNormalFullCovariance(loc=self.mean,
covariance_matrix=abs(
self.cov))
self.mean_params = tf.get_collection(
tf.GraphKeys.TRAINABLE_VARIABLES, scope=name + '/mean')
self.cov_params = tf.get_collection(
tf.GraphKeys.TRAINABLE_VARIABLES, scope=name + '/cov')
class Worker_pop(object):
def __init__(self, name, data):
with tf.variable_scope(name):
self.name = name
self.DNA_size = data.getDNA_size()
# self.mean_params, self.cov_params, self.mean, self.cov = self._creat_net(name, data.getDNA_size())
with tf.variable_scope('mean'):
self.mean = tf.Variable(tf.truncated_normal([self.DNA_size, ], stddev=0.1, mean=0.5), dtype=tf.float32,
name=name + '_mean')
with tf.variable_scope('cov'):
self.cov = tf.Variable(1.0 * tf.eye(self.DNA_size), dtype=tf.float32, name=name + '_cov')
self.mvn = MultivariateNormalFullCovariance(loc=self.mean, covariance_matrix=abs(self.cov))
self.make_kid = self.mvn.sample(N_POP)
self.tfkids_fit = tf.placeholder(tf.float32, [N_POP, ])
self.tfkids = tf.placeholder(tf.float32, [N_POP, self.DNA_size])
# self.loss = -tf.reduce_mean(
# self.mvn.log_prob(self.tfkids) * self.tfkids_fit + 0.01 * self.mvn.log_prob(
# self.tfkids) * self.mvn.prob(
# self.tfkids))
self.loss = -tf.reduce_mean(self.mvn.log_prob(self.tfkids) * self.tfkids_fit)
self.train_op = tf.train.GradientDescentOptimizer(LEARNING_RATE).minimize(
self.loss) # compute and apply gradients for mean and cov
self.mean_params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=name + '/mean')
self.cov_params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=name + '/cov')
def _update_net(self):
lock_push.acquire()
self.push_mean_params_op = [g_p.assign(l_p) for g_p, l_p in zip(global_pop.mean_params, self.mean_params)]
self.push_cov_params_op = [g_p.assign(l_p) for g_p, l_p in zip(global_pop.cov_params, self.cov_params)]
sess.run([self.push_mean_params_op, self.push_cov_params_op])
# self.update_mean = self.train_op.apply_gradients(zip(self.mean_grads, global_pop.mean_params))
# self.update_cov = self.train_op.apply_gradients(zip(self.cov_grads, global_pop.cov_params))
# sess.run([self.update_mean, self.update_cov]) # local grads applies to global net
lock_push.release()
def _pull_net(self):
lock_pull.acquire()
self.pull_mean_params_op = [l_p.assign(g_p) for l_p, g_p in zip(self.mean_params, global_pop.mean_params)]
self.pull_cov_params_op = [l_p.assign(g_p) for l_p, g_p in zip(self.cov_params, global_pop.cov_params)]
sess.run([self.pull_mean_params_op, self.pull_cov_params_op])
lock_pull.release()
def __init__(self, name, data):
with tf.variable_scope(name):
self.name = name
self.DNA_size = data.getDNA_size()
# self.mean_params, self.cov_params, self.mean, self.cov = self._creat_net(name, data.getDNA_size())
with tf.variable_scope('mean'):
self.mean = tf.Variable(tf.truncated_normal([self.DNA_size, ], stddev=0.1, mean=0.0), dtype=tf.float32,
name=name + '_mean')
with tf.variable_scope('cov'):
self.cov = tf.Variable(1.0 * tf.eye(self.DNA_size), dtype=tf.float32, name=name + '_cov')
# self.mvn = MultivariateNormalFullCovariance(loc=self.mean, covariance_matrix=self.cov)
self.mvn = MultivariateNormalFullCovariance(loc=self.mean, covariance_matrix=abs(self.cov))
# self.mvn = MultivariateNormalFullCovariance(loc=self.mean, covariance_matrix=abs(self.cov + tf.Variable(0.05 * tf.eye(self.DNA_size), dtype=tf.float32)))
self.make_kid = self.mvn.sample(N_POP)
self.tfkids_fit = tf.placeholder(tf.float32, [N_POP, ])
self.tfkids = tf.placeholder(tf.float32, [N_POP, self.DNA_size])
self.loss = -tf.reduce_mean(
self.mvn.log_prob(self.tfkids) * self.tfkids_fit + 0.001 * self.mvn.log_prob(self.tfkids) * self.mvn.prob(
self.tfkids))
self.train_op = tf.train.GradientDescentOptimizer(LEARNING_RATE).minimize(self.loss) # compute and apply gradients for mean and cov
self.mean_params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=name + '/mean')
self.cov_params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=name + '/cov')
def __define_observations_simulation(self):
# TODO: reduce code not to create extra operations
self.__sim_graph = tf.Graph()
sim_graph = self.__sim_graph
r = self.__r
m = self.__m
n = self.__n
p = self.__p
x0_mean = self.__x0_mean
x0_cov = self.__x0_cov
with sim_graph.as_default():
th = tf.placeholder(tf.float64, shape=[None], name='th')
# TODO: this should be continuous function of time
# but try to let pass array also
u = tf.placeholder(tf.float64, shape=[r, None], name='u')
t = tf.placeholder(tf.float64, shape=[None], name='t')
# TODO: refactor
# TODO: embed function itself in the graph, must rebuild the graph
# if the structure of the model change
# use tf.convert_to_tensor
F = tf.convert_to_tensor(self.__F(th), tf.float64)
F.set_shape([n, n])
C = tf.convert_to_tensor(self.__C(th), tf.float64)
C.set_shape([n, r])
G = tf.convert_to_tensor(self.__G(th), tf.float64)
G.set_shape([n, p])
H = tf.convert_to_tensor(self.__H(th), tf.float64)
H.set_shape([m, n])
x0_mean = tf.convert_to_tensor(x0_mean(th), tf.float64)
x0_mean = tf.squeeze(x0_mean)
x0_cov = tf.convert_to_tensor(x0_cov(th), tf.float64)
x0_cov.set_shape([n, n])
x0_dist = MultivariateNormalFullCovariance(x0_mean,
x0_cov,
name='x0_dist')
Q = tf.convert_to_tensor(self.__w_cov(th), tf.float64)
Q.set_shape([p, p])
w_mean = self.__w_mean.squeeze()
w_dist = MultivariateNormalFullCovariance(w_mean, Q, name='w_dist')
R = tf.convert_to_tensor(self.__v_cov(th), tf.float64)
R.set_shape([m, m])
v_mean = self.__v_mean.squeeze()
v_dist = MultivariateNormalFullCovariance(v_mean, R, name='v_dist')
def sim_obs(x):
v = v_dist.sample()
v = tf.reshape(v, [m, 1])
y = H @ x + v # the syntax is valid for Python >= 3.5
return y
def sim_loop_cond(x, y, t, k):
N = tf.stack([tf.shape(t)[0]])
N = tf.reshape(N, ())
return tf.less(k, N - 1)
def sim_loop_body(x, y, t, k):
# TODO: this should be function of time
u_t_k = tf.slice(u, [0, k], [r, 1])
def state_propagate(x, t):
w = w_dist.sample()
w = tf.reshape(w, [p, 1])
Fx = tf.matmul(F, x, name='Fx')
Cu = tf.matmul(C, u_t_k, name='Cu')
Gw = tf.matmul(G, w, name='Gw')
dx = Fx + Cu + Gw
return dx
tk = tf.slice(t, [k], [2], 'tk')
x_k = x[:, -1]
x_k = tf.reshape(x_k, [n, 1])
# decreased default tolerance to avoid max_num_steps exceeded
# error may increase max_num_steps as an alternative
x_k = tf.contrib.integrate.odeint(state_propagate,
x_k,
tk,
name='state_propagate',
rtol=1e-4,
atol=1e-10)
x_k = x_k[-1] # last state (last row)
y_k = sim_obs(x_k)
# TODO: stack instead of concat
x = tf.concat([x, x_k], 1)
y = tf.concat([y, y_k], 1)
k = k + 1
return x, y, t, k
x = x0_dist.sample(name='x0_sample')
x = tf.reshape(x, [n, 1], name='x')
# this zeroth measurement should be thrown away
y = sim_obs(x)
k = tf.constant(0, name='k')
shape_invariants = [
tf.TensorShape([n, None]),
tf.TensorShape([m, None]),
t.get_shape(),
k.get_shape()
]
sim_loop = tf.while_loop(sim_loop_cond,
sim_loop_body, [x, y, t, k],
shape_invariants,
name='sim_loop')
self.__sim_loop_op = sim_loop
import numpy as np
from tensorflow.contrib.distributions import MultivariateNormalFullCovariance
rand_init = tf.random_normal_initializer()
mu = tf.get_variable(name="mu",
shape=[1, 16],
dtype=tf.float32,
initializer=rand_init)
log_d = tf.get_variable(name="log_d",
shape=[1, 16],
dtype=tf.float32,
initializer=rand_init)
with tf.name_scope(name="sample"):
cov = tf.diag(tf.exp(log_d[0]))
dist = MultivariateNormalFullCovariance(loc=mu, covariance_matrix=cov)
sample = dist.sample()
prob = dist.prob(value=sample)
with tf.name_scope("gradient"):
optimizer = tf.train.AdamOptimizer()
list = optimizer.compute_gradients(loss=prob, var_list=[log_d])
with tf.name_scope("miscellaneous"):
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
res = sess.run(list)
print(res)
#--------------------------建立神經網路--------------------------#
'''
build multivariate distribution(雙變數的normal distribution)
現在有 X1與X2兩個r.v
初始 cov 為 tf.eye(DNA_SIZE = 2) => 對角矩陣，代表X1與X2兩個r.v為不相關(不是獨立)!!
normal_dist.sample(POP_SIZE=20) = [x1_1 x1_2
x2_1 x2_2
... ...
x20_1 x20_2]
normal_dist.sample(POP_SIZE=20)代表讓X1與X2依照定義的 mean 與 cov 所形成的 distribution 以 sample 出20個值，並把這20個值當作訓練的數據丟進神經網路
而loss所要微分的對象即是 mean 與 var
'''
mean = tf.Variable(tf.random_normal([DNA_SIZE , ] , 5. , 1.) , dtype = tf.float32 , name = 'mean')
cov = tf.Variable(3. * tf.eye(DNA_SIZE) , dtype = tf.float32 , name = 'cov')
normal_dist = MultivariateNormalFullCovariance(loc = mean , covariance_matrix = cov)
make_child = normal_dist.sample(POP_SIZE) # 在定義好的normal_dist上sample資料
childs_fitness_input = tf.placeholder(tf.float32 , [POP_SIZE , ])
childs_input = tf.placeholder(tf.float32 , [POP_SIZE , DNA_SIZE])
loss = -tf.reduce_mean(normal_dist.log_prob(childs_input) * childs_fitness_input) # log prob * fitness
train_op = tf.train.GradientDescentOptimizer(LR).minimize(loss)
sess = tf.Session()
sess.run(tf.global_variables_initializer())
#--------------------------建立神經網路--------------------------#
# 畫等高線圖
contour()
from keras.engine.topology import Layer
from tensorflow.contrib.distributions import MultivariateNormalFullCovariance
import keras.backend as K
import matplotlib.pyplot as plt
f = np.load(os.path.join("numpy_data", "gmm.npz"))
latent_dim = len(f['pis'])
data = {}
for key in f.keys():
data[key] = f[key].astype(np.float32)
modes = [None] * latent_dim
for i in range(latent_dim):
modes[i] = MultivariateNormalFullCovariance(loc=data['means'][i, ...],
covariance_matrix=data['covariances'][i, ...])
data_input = Input(shape=(2,))
q_model = Dense(16, activation='relu')(data_input)
q_model = Dense(16, activation='relu')(q_model)
q_model = Dense(16, activation='relu')(q_model)
q_model = Dense(latent_dim)(q_model)
class ElboLayer(Layer):
def __init__(self, input_tensor, **kwargs):
super(ElboLayer, self).__init__(**kwargs)
self._input = input_tensor
def call(self, logits):
norm_logits = logits - K.tile(K.logsumexp(logits, axis=-1, keepdims=True),
N_POP = 20 # population size
N_GENERATION = 100 # training step
LR = 0.02 # learning rate
# fitness function
def get_fitness(pred):
return -((pred[:, 0])**2 + pred[:, 1]**2)
# build multivariate distribution
mean = tf.Variable(tf.random_normal([
2,
], 13., 1.), dtype=tf.float32)
cov = tf.Variable(5. * tf.eye(DNA_SIZE), dtype=tf.float32)
mvn = MultivariateNormalFullCovariance(
loc=mean, covariance_matrix=cov) # start build our model
make_kid = mvn.sample(N_POP) # sampling operation
# compute gradient and update mean and covariance matrix from sample and fitness
tfkids_fit = tf.placeholder(tf.float32, [N_POP])
tfkids = tf.placeholder(tf.float32, [N_POP, DNA_SIZE])
loss = -tf.reduce_mean(
mvn.log_prob(tfkids) *
tfkids_fit) # log prob * fitness and we want to min or obj function
train_op = tf.train.GradientDescentOptimizer(LR).minimize(
loss) # compute and apply gradients for mean and cov
sess = tf.Session()
sess.run(tf.global_variables_initializer()) # initialize tf variables
# something about plotting (can be ignored)
import tensorflow as tf from tensorflow.contrib.distributions import MultivariateNormalFullCovariance DNA_SIZE = 2 # parameter (solution) number N_POP = 20 # population size N_GENERATION = 100 # training step LR = 0.02 # learning rate # fitness function def get_fitness(pred): return -((pred[:, 0])**2 + pred[:, 1]**2) # build multivariate distribution mean = tf.Variable(tf.random_normal([2, ], 13., 1.), dtype=tf.float32) cov = tf.Variable(5. * tf.eye(DNA_SIZE), dtype=tf.float32) mvn = MultivariateNormalFullCovariance(loc=mean, covariance_matrix=cov) make_kid = mvn.sample(N_POP) # sampling operation # compute gradient and update mean and covariance matrix from sample and fitness tfkids_fit = tf.placeholder(tf.float32, [N_POP, ]) tfkids = tf.placeholder(tf.float32, [N_POP, DNA_SIZE]) loss = -tf.reduce_mean(mvn.log_prob(tfkids)*tfkids_fit) # log prob * fitness train_op = tf.train.GradientDescentOptimizer(LR).minimize(loss) # compute and apply gradients for mean and cov sess = tf.Session() sess.run(tf.global_variables_initializer()) # initialize tf variables # something about plotting (can be ignored) n = 300 x = np.linspace(-20, 20, n) X, Y = np.meshgrid(x, x)