def build_DCGAN(self):
gen_input = input_data(shape=[None, self.z_dim], name='input_gen_noise')
input_disc_noise = input_data(shape=[None, self.z_dim], name='input_disc_noise')
input_disc_real = input_data(shape=[None, self.img_size, self.img_size, 1], name='input_disc_real')
disc_fake = self.discriminator(self.generator(input_disc_noise))
disc_real = self.discriminator(input_disc_real, reuse=True)
disc_net = tf.concat([disc_fake, disc_real], axis=0)
gen_net = self.generator(gen_input, reuse=True)
stacked_gan_net = self.discriminator(gen_net, reuse=True)
disc_vars = tflearn.get_layer_variables_by_scope('Discriminator')
disc_target = tflearn.multi_target_data(['target_disc_fake', 'target_disc_real'],
shape=[None, 2])
adam = Adam(learning_rate=self.learning_rate, beta1=self.beta)
disc_model = regression(disc_net, optimizer=adam,
placeholder=disc_target,
loss='categorical_crossentropy',
trainable_vars=disc_vars,
name='target_disc', batch_size=self.batch_size,
op_name='DISC')
gen_vars = tflearn.get_layer_variables_by_scope('Generator')
gan_model = regression(stacked_gan_net, optimizer=adam,
loss='categorical_crossentropy',
trainable_vars=gen_vars,
name='target_gen', batch_size=self.batch_size,
op_name='GEN')
self.model = tflearn.DNN(gan_model, tensorboard_dir='log',
checkpoint_path=self.data_folder + 'checkpoints/' + self.model_name + '/')
self.gen_net = gen_net
gen_input = tflearn.input_data(shape=[None, z_dim], name='input_noise')
disc_input = tflearn.input_data(shape=[None, 784], name='disc_input')
gen_sample = generator(gen_input)
disc_real = discriminator(disc_input)
disc_fake = discriminator(gen_sample, reuse=True)
# Define Loss
disc_loss = -tf.reduce_mean(tf.log(disc_real) + tf.log(1. - disc_fake))
gen_loss = -tf.reduce_mean(tf.log(disc_fake))
# Build Training Ops for both Generator and Discriminator.
# Each network optimization should only update its own variable, thus we need
# to retrieve each network variables (with get_layer_variables_by_scope) and set
# 'placeholder=None' because we do not need to feed any target.
gen_vars = tflearn.get_layer_variables_by_scope('Generator')
gen_model = tflearn.regression(gen_sample,
placeholder=None,
optimizer='adam',
loss=gen_loss,
trainable_vars=gen_vars,
batch_size=64,
name='target_gen',
op_name='GEN')
disc_vars = tflearn.get_layer_variables_by_scope('Discriminator')
disc_model = tflearn.regression(disc_real,
placeholder=None,
optimizer='adam',
loss=disc_loss,
trainable_vars=disc_vars,
batch_size=64,
gen_input = tflearn.input_data(shape=[None, z_dim], name='input_gen_noise')
input_disc_noise = tflearn.input_data(shape=[None, z_dim], name='input_disc_noise')
input_disc_real = tflearn.input_data(shape=[None, 28, 28, 1], name='input_disc_real')
# Build Discriminator
disc_fake = discriminator(generator(input_disc_noise))
disc_real = discriminator(input_disc_real, reuse=True)
disc_net = tf.concat([disc_fake, disc_real], axis=0)
# Build Stacked Generator/Discriminator
gen_net = generator(gen_input, reuse=True)
stacked_gan_net = discriminator(gen_net, reuse=True)
# Build Training Ops for both Generator and Discriminator.
# Each network optimization should only update its own variable, thus we need
# to retrieve each network variables (with get_layer_variables_by_scope).
disc_vars = tflearn.get_layer_variables_by_scope('Discriminator')
# We need 2 target placeholders, for both the real and fake image target.
disc_target = tflearn.multi_target_data(['target_disc_fake', 'target_disc_real'],
shape=[None, 2])
disc_model = tflearn.regression(disc_net, optimizer='adam',
placeholder=disc_target,
loss='categorical_crossentropy',
trainable_vars=disc_vars,
batch_size=64, name='target_disc',
op_name='DISC')
gen_vars = tflearn.get_layer_variables_by_scope('Generator')
gan_model = tflearn.regression(stacked_gan_net, optimizer='adam',
loss='categorical_crossentropy',
trainable_vars=gen_vars,
batch_size=64, name='target_gen',
def __init__(self, sess, state_dim, learning_rate, scope):
self.reuse_gan = False
self.reuse_disc = False
self.sess = sess
self.s_dim = state_dim
self.lr_rate = learning_rate
self.scope = scope
#self.dual = dual
#self.critic = critic
self.inputs_g, self.gan_inputs, self.generate = self.create_generate_network(
)
self.inputs_d_real, self.disc_real = self.create_discriminator_network_real(
)
self.inputs_d_fake, self.disc_fake = self.create_discriminator_network(
self.generate)
# https://arxiv.org/pdf/1611.04076.pdf
# L2 GAN LOSS
self.gen_loss = 0.5 * \
tf.reduce_mean(tflearn.mean_square(self.disc_fake, 1.))
#-tf.reduce_mean(tf.log(self.disc_fake))
self.disc_loss = 0.5 * (
tf.reduce_mean(tflearn.mean_square(self.disc_real, 1.)) +
tf.reduce_mean(tflearn.mean_square(self.disc_real, 0.)))
#-(tf.reduce_mean(tf.log(self.disc_real)) + tf.reduce_mean(tf.log(1. - self.disc_fake)))
#tflearn.mean_square(tf.log(self.discriminator), self.out)
self.gen_vars = tflearn.get_layer_variables_by_scope(self.scope +
'-gan-g')
self.disc_vars = tflearn.get_layer_variables_by_scope(self.scope +
'-gan-d')
self.gen_op = tf.train.RMSPropOptimizer(self.lr_rate).minimize(
self.gen_loss, var_list=self.gen_vars)
self.disc_op = tf.train.RMSPropOptimizer(self.lr_rate).minimize(
self.disc_loss, var_list=self.disc_vars)
# Get all network parameters
self.network_params_g = \
tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope=self.scope + '-gan-g')
self.network_params_d = \
tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope=self.scope + '-gan-d')
# Set all network parameters
self.input_network_params_g = []
self.input_network_params_d = []
for param in self.network_params_g:
self.input_network_params_g.append(
tf.placeholder(tf.float32, shape=param.get_shape()))
for param in self.network_params_d:
self.input_network_params_d.append(
tf.placeholder(tf.float32, shape=param.get_shape()))
self.set_network_params_op_g = []
self.set_network_params_op_d = []
for idx, param in enumerate(self.input_network_params_g):
self.set_network_params_op_g.append(
self.network_params_g[idx].assign(param))
for idx, param in enumerate(self.input_network_params_d):
self.set_network_params_op_d.append(
self.network_params_d[idx].assign(param))
def main():
stage = 'train'
# stage = 'gen'
model_path = 'gan_model/gan_paper_3_private_loss.tfl'
if stage == 'train':
X = np.load('ben_original_feature.npy')
X_1 = X[500:, :45]
X = X[500:, :]
X = X[:, :45]
X = np.reshape(X, newshape=[-1, 9, 5, 1])
z_dim = 20 # Noise data points
total_samples = len(X)
# Input Data
gen_input = tflearn.input_data(shape=[None, z_dim],
name='input_gen_noise')
input_disc_noise = tflearn.input_data(shape=[None, z_dim],
name='input_disc_noise')
input_disc_real = tflearn.input_data(shape=[None, 9, 5, 1],
name='input_disc_real')
#Output Data of Generator
# Build Discriminator
disc_fake = discriminator(generator(input_disc_noise))
disc_real = discriminator(input_disc_real, reuse=True)
disc_net = tf.concat([disc_fake, disc_real], axis=0)
# Build Stacked Generator/Discriminator
gen_net = generator(gen_input, reuse=True)
stacked_gan_net = discriminator(gen_net, reuse=True)
# Build Training Ops for both Generator and Discriminator.
# Each network optimization should only update its own variable, thus we need
# to retrieve each network variables (with get_layer_variables_by_scope).
disc_vars = tflearn.get_layer_variables_by_scope('Discriminator')
# We need 2 target placeholders, for both the real and fake image target.
disc_target = tflearn.multi_target_data(
['target_disc_fake', 'target_disc_real'], shape=[None, 2])
gen_target = tflearn.multi_target_data(
['target_disc_fake', 'target_disc_real'], shape=[None, 2])
disc_model = tflearn.regression(disc_net,
optimizer='adam',
placeholder=disc_target,
loss='categorical_crossentropy',
trainable_vars=disc_vars,
batch_size=64,
name='target_disc',
op_name='DISC')
gen_vars = tflearn.get_layer_variables_by_scope('Generator')
gan_model = tflearn.regression(stacked_gan_net,
optimizer='adam',
loss='categorical_crossentropy',
trainable_vars=gen_vars,
batch_size=64,
name='target_gen',
op_name='GEN')
gen_to_train = tflearn.regression(gen_net,
optimizer='adam',
loss=private_loss,
trainable_vars=gen_vars,
batch_size=64,
name='gen_train',
op_name='GEN')
# Define GAN model
gan = tflearn.DNN(gan_model)
# Training
# Prepare input data to feed to the discriminator
disc_noise = np.random.uniform(-1., 1., size=[total_samples, z_dim])
# Prepare target data to feed to the discriminator (0: fake image, 1: real image)
y_disc_fake = np.zeros(shape=[total_samples])
y_disc_real = np.ones(shape=[total_samples])
y_disc_fake = tflearn.data_utils.to_categorical(y_disc_fake, 2)
y_disc_real = tflearn.data_utils.to_categorical(y_disc_real, 2)
# Prepare input data to feed to the stacked generator/discriminator
gen_noise = np.random.uniform(-1., 1., size=[total_samples, z_dim])
# Prepare target data to feed to the discriminator
# Generator tries to fool the discriminator, thus target is 1 (e.g. real images)
y_gen = np.ones(shape=[total_samples])
y_gen = tflearn.data_utils.to_categorical(y_gen, 2)
gan.fit(X_inputs={
'input_gen_noise': gen_noise,
'input_disc_noise': disc_noise,
'input_disc_real': X,
},
Y_targets={
'target_gen': y_gen,
'target_disc_fake': y_disc_fake,
'target_disc_real': y_disc_real,
'gen_train': X_1
},
n_epoch=10)
print('--GAN training finish--')
# gen_dnn = tflearn.DNN(gen_net,session=gan.session)
# gen_dnn.fit(X_inputs={'gen_input':gen_noise},Y_targets={'gen_train':X},n_epoch=10)
gan.save(model_path)
if stage == 'gen':
gen_amount = 13000
z_dim = 20 # Noise data points
# Input Data
gen_input = tflearn.input_data(shape=[None, z_dim],
name='input_gen_noise')
input_disc_noise = tflearn.input_data(shape=[None, z_dim],
name='input_disc_noise')
input_disc_real = tflearn.input_data(shape=[None, 9, 5, 1],
name='input_disc_real')
# Build Discriminator
disc_fake = discriminator(generator(input_disc_noise))
disc_real = discriminator(input_disc_real, reuse=True)
disc_net = tf.concat([disc_fake, disc_real], axis=0)
# Build Stacked Generator/Discriminator
gen_net = generator(gen_input, reuse=True)
stacked_gan_net = discriminator(gen_net, reuse=True)
# Build Training Ops for both Generator and Discriminator.
# Each network optimization should only update its own variable, thus we need
# to retrieve each network variables (with get_layer_variables_by_scope).
disc_vars = tflearn.get_layer_variables_by_scope('Discriminator')
# We need 2 target placeholders, for both the real and fake image target.
disc_target = tflearn.multi_target_data(
['target_disc_fake', 'target_disc_real'], shape=[None, 2])
disc_model = tflearn.regression(disc_net,
optimizer='adam',
placeholder=disc_target,
loss='categorical_crossentropy',
trainable_vars=disc_vars,
batch_size=64,
name='target_disc',
op_name='DISC')
gen_vars = tflearn.get_layer_variables_by_scope('Generator')
gan_model = tflearn.regression(stacked_gan_net,
optimizer='adam',
loss='categorical_crossentropy',
trainable_vars=gen_vars,
batch_size=64,
name='target_gen',
op_name='GEN')
# Define GAN model, that output the generated images.
gan = tflearn.DNN(gan_model)
gan.load(model_path)
# Create another model from the generator graph to generate some samples
# for testing (re-using same session to re-use the weights learnt).
gen = tflearn.DNN(gen_net, session=gan.session)
g = np.zeros((1, 45))
for i in range(int(gen_amount / 10)):
z = np.random.uniform(-1., 1., size=[10, z_dim])
g_part = np.array(gen.predict({'input_gen_noise': z}))
g = np.concatenate((g, g_part), axis=0)
# np.save('gen_result.npy', g[1:,:])
# data = np.load('gen_result.npy')
data = g[1:, :]
sample_num = len(data)
print('sample_number:{}'.format(sample_num))
result2 = []
data = np.abs(data)
for i in range(len(data)):
# if np.sum(data[i]) <= 1 and np.sum(data[i]) >= 0.9:
if np.sum(data[i]) <= 100000:
result2.append(data[i])
result2 = np.array(result2)
print('get:{}'.format(len(result2)))
for i in range(sample_num):
result2[i, :-1] = result2[i, :-1] / np.sum(result2[i, :-1])
np.save('result2_' + str(gen_amount) + '.npy', result2)
input_disc_real = tflearn.input_data(shape=[None, 28, 28, 1],
name='input_disc_real')
# Build Discriminator
disc_fake = discriminator(
generator(input_disc_noise)) # [n,200]->[n,28,28,1]->[n,2]
disc_real = discriminator(input_disc_real, reuse=True) # [n,28,28,1]->[n,2]
disc_net = tf.concat([disc_fake, disc_real], axis=0) # [2n,2]~~[n,2]
# Build Stacked Generator/Discriminator
gen_net = generator(gen_input, reuse=True) # [n,200]->[n,28,28,1]
stacked_gan_net = discriminator(gen_net, reuse=True) # [n,28,28,1]->[n,2]
# Build Training Ops for both Generator and Discriminator.
# Each network optimization should only update its own variable, thus we need
# to retrieve each network variables (with get_layer_variables_by_scope).
disc_vars = tflearn.get_layer_variables_by_scope(
'Discriminator') # 获取该节点下的所有可训练的变量
# We need 2 target placeholders, for both the real and fake image target.
disc_target = tflearn.multi_target_data(
['target_disc_fake', 'target_disc_real'], shape=[None, 2])
disc_model = tflearn.regression(disc_net,
optimizer='adam',
placeholder=disc_target,
loss='categorical_crossentropy',
trainable_vars=disc_vars,
batch_size=64,
name='target_disc',
op_name='DISC')
gen_vars = tflearn.get_layer_variables_by_scope('Generator')
gan_model = tflearn.regression(stacked_gan_net,
optimizer='adam',
ctrl_in = tf.concat([img_out, last_ctrl], 1)
ctrl = ctrl_net(ctrl_in)
value_in = tf.concat([ctrl_in, ctrl], 1)
value = value_net(value_in)
#评分(越大越好)
y = tf.placeholder(tf.float32, [None, 1])
value_loss = tf.reduce_mean(tf.square(y - value))
#ctrl_loss = tf.reduce_mean(-tf.log(value))
ctrl_loss = tf.reduce_mean(1 - value)
ctrl_vars = tfl.get_layer_variables_by_scope(
'ctrl') # + tfl.get_layer_variables_by_scope('image')
value_vars = tfl.get_layer_variables_by_scope(
'value') + tfl.get_layer_variables_by_scope('image')
ctrl_model = tfl.regression(ctrl,
placeholder=None,
optimizer='adam',
loss=ctrl_loss,
trainable_vars=ctrl_vars,
batch_size=64,
name='target_ctrl',
op_name='ctrl_model')
value_model = tfl.regression(value,
placeholder=y,
optimizer='adam',
input_example_ctrl = tfl.input_data([None, 2])
input_map = tf.concat([input_left, input_right], 2)
input_map = tf.reshape(input_map, [-1, 5, 4, 1])
ctrl = ctrl_net(input_map, input_state)
value_example = value_net(input_map, input_state, input_example_ctrl)
value = value_net(input_map, input_state, ctrl, reuse=True)
#评分(越大越好)
y_example = tf.placeholder(tf.float32, [None, 1])
value_loss = tf.reduce_mean(tf.square(y_example - value_example))
ctrl_loss = tf.reduce_mean(tf.square(1 - value))
value_vars = tfl.get_layer_variables_by_scope('value')
value_reg = tfl.regression(value_example,
placeholder=y_example,
optimizer='adam',
loss=value_loss,
trainable_vars=value_vars,
batch_size=512,
name='target_value',
op_name='value_reg')
ctrl_vars = tfl.get_layer_variables_by_scope('ctrl')
ctrl_reg = tfl.regression(value,
placeholder=None,
optimizer='adam',
loss=ctrl_loss,
trainable_vars=ctrl_vars,
