def dice_loss_dict(y_true, y_pred):
smooth = 1e-6
dict={}
for i in range(args.num_classes):
y_true_f_1 = layers.flatten(y_true[...,i])
y_pred_f_1 = layers.flatten(y_pred[...,i])
intersection = tf.reduce_sum(y_true_f_1 * y_pred_f_1)
if i==0:
key_name = 'dice loss on background: '
else:
key_name = 'dice loss on class {}: '.format(i)
dict[key_name] = 1- (2. * intersection + smooth) / (tf.reduce_sum(y_true_f_1 * y_true_f_1) + tf.reduce_sum(y_pred_f_1 * y_pred_f_1) + smooth)
return dict
def fourier_dqn_network(min_vals,
max_vals,
num_actions,
state,
fourier_basis_order=3):
"""Builds the function approximator used to compute the agent's Q-values.
It uses FourierBasis features and a linear layer.
Args:
min_vals: float, minimum attainable values (must be same shape as `state`).
max_vals: float, maximum attainable values (must be same shape as `state`).
num_actions: int, number of actions.
state: `tf.Tensor`, contains the agent's current state.
fourier_basis_order: int, order of the Fourier basis functions.
Returns:
The Q-values for DQN-style agents or logits for Rainbow-style agents.
"""
net = tf.cast(state, tf.float32)
net = layers.flatten(net)
# Feed state through Fourier basis.
feature_generator = FourierBasis(
net.get_shape().as_list()[-1],
min_vals,
max_vals,
order=fourier_basis_order)
net = feature_generator.compute_features(net)
# Q-values are always linear w.r.t. last layer.
q_values = layers.fully_connected(
net, num_actions, activation_fn=None, biases_initializer=None)
return q_values
def _basic_discrete_domain_network(min_vals, max_vals, num_actions, state,
num_atoms=None):
"""Builds a basic network for discrete domains, rescaling inputs to [-1, 1].
Args:
min_vals: float, minimum attainable values (must be same shape as `state`).
max_vals: float, maximum attainable values (must be same shape as `state`).
num_actions: int, number of actions.
state: `tf.Tensor`, the state input.
num_atoms: int or None, if None will construct a DQN-style network,
otherwise will construct a Rainbow-style network.
Returns:
The Q-values for DQN-style agents or logits for Rainbow-style agents.
"""
net = tf.cast(state, tf.float32)
net = layers.flatten(net)
net -= min_vals
net /= max_vals - min_vals
net = 2.0 * net - 1.0 # Rescale in range [-1, 1].
net = layers.fully_connected(net, 512)
net = layers.fully_connected(net, 512)
if num_atoms is None:
# We are constructing a DQN-style network.
return layers.fully_connected(net, num_actions, activation_fn=None)
else:
# We are constructing a Rainbow-style network.
return layers.fully_connected(
net, num_actions * num_atoms, activation_fn=None)
def _cnn(self, x):
x = tf.cast(x, tf.float32) / 255.
x = layers.conv2d(x,
filters=32,
kernel_size=8,
strides=(4, 4),
kernel_initializer=init,
activation=tf.nn.relu)
x = layers.conv2d(x,
filters=64,
kernel_size=4,
strides=(2, 2),
kernel_initializer=init,
activation=tf.nn.relu)
x = layers.conv2d(x,
filters=64,
kernel_size=3,
strides=(1, 1),
kernel_initializer=init,
activation=tf.nn.relu)
x = layers.flatten(x)
return layers.dense(x,
units=512,
kernel_initializer=init,
activation=tf.nn.relu)
def build(self):
"""
Build the MLP model.
"""
# keep_prob = tf.cond(tf.equal(self.is_training, tf.constant(True)), lambda: self.k_prob, lambda: 1.0)
with tf.variable_scope(self.name):
incoming = layers.flatten(self.incoming)
input_layer = layers.dense(incoming,
self.n_in,
kernel_initializer=he_init,
bias_initializer=b_init)
input_layer = tf.layers.batch_normalization(input_layer)
input_layer = tf.nn.relu(input_layer)
hidden_layer = layers.dense(input_layer,
self.n_hidden,
kernel_initializer=he_init,
bias_initializer=b_init)
hidden_layer = tf.layers.batch_normalization(hidden_layer)
hidden_layer = tf.nn.relu(hidden_layer)
output_layer = layers.dense(hidden_layer,
self.n_out,
bias_initializer=b_init)
output_layer = tf.layers.batch_normalization(output_layer)
# final activation: linear
return output_layer
def discriminatorNet(inputs, is_training, use_batchNorm):
idx = 0
f = inputs
f = layers.conv2d(f,
64,
kernel_size=4,
strides=2,
padding="SAME",
name="conv_%d" % idx)
if use_batchNorm:
f = layers.batch_normalization(f,
training=is_training,
name="bn_%d" % idx)
f = tf.nn.leaky_relu(f, alpha=0.01, name="lrelu_%d" % idx)
idx += 1
f = layers.conv2d(f,
128,
kernel_size=4,
strides=2,
padding="SAME",
name="conv_%d" % idx)
if use_batchNorm:
f = layers.batch_normalization(f,
training=is_training,
name="bn_%d" % idx)
f = tf.nn.leaky_relu(f, alpha=0.01, name="lrelu_%d" % idx)
idx += 1
f = layers.flatten(f)
f = layers.dense(f, 1024, name="dense_%d" % idx)
f = tf.nn.leaky_relu(f, alpha=0.01, name="lrelu_%d" % idx)
return f
def misconception_model(inputs,
filters_list,
kernel_size,
strides_list,
training,
objective_functions,
sub_filters=128,
sub_layers=2,
dropout_rate=0.5,
virtual_batch_size=None,
feature_means=None,
feature_stds=None):
""" A misconception tower.
Args:
input: a tensor of size [batch_size, 1, width, depth].
window_size: the width of the conv and pooling filters to apply.
depth: the depth of the output tensor.
levels: the height of the tower in misconception layers.
objective_functions: a list of objective functions to add to the top of
the network.
is_training: whether the network is training.
Returns:
a tensor of size [batch_size, num_classes].
"""
layers = []
net = inputs
if feature_means is not None:
net = net - tf.constant(feature_means)[None, None, :]
if feature_stds is not None:
net = net / (tf.constant(feature_stds) + 1e-6)
layers.append(net)
for filters, strides in zip(filters_list, strides_list):
net = misconception_with_bypass(net,
filters,
kernel_size,
strides,
training,
virtual_batch_size=virtual_batch_size)
layers.append(net)
outputs = []
for ofunc in objective_functions:
onet = net
for _ in range(sub_layers - 1):
onet = ly.conv1d(onet,
sub_filters,
1,
activation=None,
use_bias=False)
onet = ly.batch_normalization(
onet, training=training, virtual_batch_size=virtual_batch_size)
onet = tf.nn.relu(onet)
onet = ly.conv1d(onet, sub_filters, 1, activation=tf.nn.relu)
onet = ly.flatten(onet)
#
onet = ly.dropout(onet, training=training, rate=dropout_rate)
outputs.append(ofunc.build(onet))
return outputs, layers
def Encoder(inputs, is_training):
with tf.variable_scope('Encoder'):
conv_0 = CONV_BN_ACT(inputs=inputs,
filters=32,
kernel_size=[3,3],
strides=[1,1],
padding='same',
act_fn='lrelu',
is_training=is_training,
is_transpose=False)
conv_1 = CONV_BN_ACT(inputs=conv_0,
filters=64,
kernel_size=[3,3],
strides=[2,2],
padding='same',
act_fn='lrelu',
is_training=is_training,
is_transpose=False)
conv_2 = CONV_BN_ACT(inputs=conv_1,
filters=128,
kernel_size=[3,3],
strides=[2,2],
padding='same',
act_fn='lrelu',
is_training=is_training,
is_transpose=False)
flat = flatten(conv_2)
z_mean = dense(inputs=flat, units=z_dim)
z_log_var = dense(inputs=flat, units=z_dim)
return z_mean, z_log_var
def build_discriminator(image, reuse=False):
with tf.variable_scope("discriminator") as scope:
if reuse:
tf.get_variable_scope().reuse_variables()
#
t = image
t = conv2d(inputs=t,
filters=64,
kernel_size=[5, 5],
strides=2,
padding="same",
activation=my_leaky_relu)
t = batch_normalization(inputs=t)
t = conv2d(inputs=t,
filters=128,
kernel_size=[5, 5],
strides=2,
padding="same",
activation=my_leaky_relu)
t = batch_normalization(inputs=t)
t = dropout(inputs=t, rate=DROP_RATE)
t = flatten(inputs=t)
t = dense(inputs=t, units=1, activation=tf.sigmoid)
decision = t
#print("\nD output shape: {}".format(decision.shape))
return decision
def build(self):
"""
Build the model.
"""
with tf.variable_scope(self.name):
incoming = layers.flatten(self.incoming)
input_layer = layers.dense(incoming,
self.n_in,
kernel_initializer=he_init,
bias_initializer=b_init)
input_layer = tf.layers.batch_normalization(
input_layer, training=self.is_training)
input_layer = tf.nn.relu(input_layer)
hidden_layer = layers.dense(input_layer,
self.n_hidden,
kernel_initializer=he_init,
bias_initializer=b_init)
hidden_layer = tf.layers.batch_normalization(
hidden_layer, training=self.is_training)
hidden_layer = tf.nn.relu(hidden_layer)
output_layer = layers.dense(hidden_layer,
self.n_out,
bias_initializer=b_init)
output_layer = tf.layers.batch_normalization(
output_layer, training=self.is_training)
output_layer = tf.nn.relu(output_layer)
# final activation: linear
self.prediction = output_layer
return self
def _build_critic_network(self, state_in, name, reuse=False, batch_size=1):
w_reg = None # tf.contrib.layers.l2_regularizer(L2_REGULARIZATION)
with tf.variable_scope(name, reuse=reuse):
serial_net = layers.flatten(state_in)
serial_net = layers.dense(serial_net, 256)
serial_net = layers.dense(serial_net, RNN_UNIT_SIZE)
# LSTM layer
lstm = tf.nn.rnn_cell.LSTMCell(num_units=RNN_UNIT_SIZE,
name='lstm_cell')
#lstm = tf.nn.rnn_cell.ResidualWrapper(lstm)
#lstm = tf.nn.rnn_cell.DropoutWrapper(lstm, output_keep_prob=self.keep_prob_)
lstm = tf.nn.rnn_cell.MultiRNNCell([lstm] * RNN_NUM_LAYERS)
init_state = lstm.zero_state(batch_size=batch_size,
dtype=tf.float32)
lstm_in = tf.expand_dims(serial_net, axis=0)
rnn_net, final_state = tf.nn.dynamic_rnn(cell=lstm,
inputs=lstm_in,
initial_state=init_state)
rnn_net = tf.reshape(rnn_net, [-1, RNN_UNIT_SIZE],
name='flatten_rnn_outputs')
critic = layers.dense(
serial_net,
1,
kernel_initializer=normalized_columns_initializer(1.0),
kernel_regularizer=w_reg,
name="critic_out")
params = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES,
scope=self.scope + '/' + name)
return critic, params, init_state, final_state
def vgg_11(x, keep_proba, is_train, num_classes):
# https://arxiv.org/abs/1409.1556 --> configuration A
w_ini, b_ini, r_ini = initializers(conf.bias_init, conf.l2_str)
x_multichannel = tf.reshape(
x, [-1, conf.img_dim[0], conf.img_dim[1], conf.num_ch])
net = _conv2d(x_multichannel, 64, 3, 'conv1')
net = max_pooling2d(net, 2, 2, 'same', name='maxpool1')
net = _conv2d(net, 128, 3, 'conv2')
net = max_pooling2d(net, 2, 2, 'same', name='maxpool2')
net = _conv2d(net, 256, 3, 'conv3_1')
net = _conv2d(net, 256, 3, 'conv3_2')
net = max_pooling2d(net, 2, 2, 'same', name='maxpool3')
net = _conv2d(net, 512, 3, 'conv4_1')
net = _conv2d(net, 512, 3, 'conv4_2')
net = max_pooling2d(net, 2, 2, 'same', name='maxpool4')
net = _conv2d(net, 512, 3, 'conv5_1')
net = _conv2d(net, 512, 3, 'conv5_2')
net = max_pooling2d(net, 2, 2, 'same', name='maxpool5')
net = flatten(net, name='flat_layer')
net = _dense(net, 4096, 'fc6')
net = tf.nn.dropout(net, keep_proba, name='dropout6')
net = _dense(net, 4096, 'fc7')
net = tf.nn.dropout(net, keep_proba, name='dropout7')
# # TODO consider replacing fc layers by conv layers
# # as in https://github.com/tensorflow/models/blob/master/research/slim/nets/vgg.py
# # for "if include_top" see https://github.com/keras-team/keras-applications/blob/master/keras_applications/vgg16.py
# net = _conv2d(net, 4096, 7, 'fc6_replacement', padding='VALID')
# net = tf.nn.dropout(net, keep_proba, name='dropout7')
# net = _conv2d(net, 4096, 1, 'fc7_replacement')
# net = tf.reduce_mean(net, axis=[1, 2], name='global_avg_pool8')
logits = _dense(net, conf.num_cl, 'logits', activation=None)
# softmax performed at loss function
return logits
def decode(self, z, x_dim, training=False):
im_h, im_w, im_c = self.image_shape
with tf.variable_scope("decoder", reuse=tf.AUTO_REUSE):
h = z
h = tfl.dense(h, units=self.h_dim, activation=tf.nn.relu)
h = tfl.dense(h, units=self.h_dim, activation=tf.nn.relu)
stride = 16
h = tfl.dense(
h, units=im_h // stride * im_w // stride * self.kernel_num * 2,
activation=tf.nn.relu)
new_shape = (-1, im_h // stride, im_w // stride, self.kernel_num * 2)
h = tf.reshape(h, new_shape)
h = tfl.conv2d_transpose(
h, self.kernel_num * 2, self.kernel_size,
strides=2, padding="same", activation=tf.nn.relu)
h = tfl.conv2d_transpose(
h, self.kernel_num, self.kernel_size,
strides=2, padding="same", activation=tf.nn.relu)
h = tfl.conv2d_transpose(
h, self.kernel_num, self.kernel_size,
strides=2, padding="same", activation=tf.nn.relu)
h = tfl.conv2d_transpose(
h, im_c, self.kernel_size,
strides=2, padding="same", activation=tf.nn.sigmoid)
h = tfl.flatten(h)
y_mean = h
return y_mean
def __init__(self, model_name):
self.state_size = state_size
self.action_size = action_size
self.input = tf.placeholder(shape=[None, self.state_size[0],
self.state_size[1],
self.state_size[2]],
dtype=tf.float32)
self.input_normalize = (self.input - (255.0 / 2)) / (255.0 / 2)
with tf.variable_scope(name_or_scope=model_name):
self.conv1 = layer.conv2d(inputs=self.input_normalize,filters=32,
activation=tf.nn.relu,kernel_size=[8,8],
strides=[4,4],padding="SAME")
self.conv2 = layer.conv2d(inputs=self.conv1,filters=64,
activation=tf.nn.relu,kernel_size=[4,4],
strides=[2,2],padding="SAME")
self.conv3 = layer.conv2d(inputs=self.conv2,filters=64,
activation=tf.nn.relu,kernel_size=[3,3],
strides=[1,1],padding="SAME")
self.flat = layer.flatten(self.conv3)
self.fc1 = layer.dense(self.flat,512,activation=tf.nn.relu)
self.Q_Out = layer.dense(self.fc1,self.action_size,activation=None)
self.predict = tf.argmax(self.Q_Out, 1)
self.target_Q = tf.placeholder(shape=[None, self.action_size], dtype=tf.float32)
self.loss = tf.losses.huber_loss(self.target_Q, self.Q_Out)
self.UpdateModel = tf.train.AdamOptimizer(learning_rate).minimize(self.loss)
self.trainable_var = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, model_name)
def _model_fn(self, input_shape, output_shape):
X = tf.placeholder(tf.float32, (None, ) + input_shape, name="state")
Y = tf.placeholder(tf.float32, (None, ) + output_shape,
name="action_true")
nn = X
nn = L.conv2d(nn,
32,
8,
strides=4,
name="block1/conv1",
activation=N.relu)
nn = L.conv2d(nn, 64, 4, strides=2, name="block2/conv1")
nn = L.conv2d(nn, 64, 3, strides=1, name="block3/conv1")
nn = L.flatten(nn, name="flatten")
nn = L.dense(nn, 512, activation=N.relu, name="fc1")
value = L.dense(nn, 64, activation=N.relu, name="value_fc2")
value = L.dense(value, 1, name="value")
advantage = L.dense(nn, 64, activation=N.relu, name="advantage_fc2")
advantage = L.dense(advantage, output_shape[0], name="advantage")
q = tf.add(
value,
(advantage - tf.reduce_mean(advantage, axis=1, keepdims=True)),
name="action")
Y_pred = q
return X, Y, Y_pred
def classifier_net(inputs, scope, reuse=None): with tf.variable_scope(scope, reuse=reuse): net = conv2d(inputs, filters=32, kernel_size=5, strides=1, activation=tf.nn.leaky_relu, name='conv1') net = conv2d(net, filters=64, kernel_size=3, strides=1, activation=tf.nn.leaky_relu, name='conv2') net = max_pooling2d(net, pool_size=2, strides=2, padding='same', name='maxpool1') net = conv2d(net, filters=64, kernel_size=3, strides=1, activation=tf.nn.leaky_relu, name='conv3') net = max_pooling2d(net, pool_size=2, strides=2, padding='same', name='maxpool2a') net = conv2d(net, filters=64, kernel_size=3, strides=1, activation=tf.nn.leaky_relu, name='conv4') net = max_pooling2d(net, pool_size=2, strides=2, padding='same', name='maxpool2') net = conv2d(net, filters=64, kernel_size=3, strides=1, activation=tf.nn.leaky_relu, name='conv5') net = max_pooling2d(net, pool_size=2, strides=2, padding='same', name='maxpool3a') net = conv2d(net, filters=64, kernel_size=3, strides=1, activation=tf.nn.leaky_relu, name='conv6') net = max_pooling2d(net, pool_size=2, strides=2, padding='same', name='maxpool3') net = conv2d(net, filters=32, kernel_size=3, strides=1, activation=tf.nn.leaky_relu, name='conv7') net = max_pooling2d(net, pool_size=2, strides=2, padding='same', name='maxpool4') net = flatten(net, name='flatten') # net = dense(net, 1024, activation=tf.nn.leaky_relu, name='dense1') # net = batch_normalization(net) net = dense(net, 512, activation=tf.nn.leaky_relu, name='dense2') # net = batch_normalization(net) net = dense(net, 256, activation=tf.nn.leaky_relu, name='dense3') # net = batch_normalization(net) net = dense(net, 128, activation=tf.nn.leaky_relu, name='dense4') net = dense(net, 1, activation=tf.nn.sigmoid, name='out') return net
def __call__(self, input_obs):
with tf.variable_scope("default_conv_net"):
inputs = input_obs
for i, (filters_, kernel_size, stride,
padding) in enumerate(self._conv_filters):
inputs = layers.conv2d(inputs=inputs,
filters=filters_,
kernel_size=kernel_size,
strides=stride,
padding=padding,
activation=self._activation,
name="conv{}".format(i))
hidden = layers.flatten(inputs)
if self._input_action:
hidden = tf.concat([hidden, self._input_action], axis=1)
logits = layers.dense(hidden,
units=self._action_dim,
activation=None,
name="logits")
if self._need_v:
logits_to_v = layers.dense(hidden,
units=32,
activation=tf.nn.relu,
name="logits_to_value")
v = layers.dense(logits_to_v,
units=1,
activation=None,
name="value")
v = tf.squeeze(v, [-1])
return (
logits,
v,
)
return logits
def _model(self, inputs, mode, **config):
x = inputs['image']
if config['data_format'] == 'channels_first':
x = tf.transpose(x, [0, 3, 1, 2])
params = {'padding': 'SAME', 'data_format': config['data_format']}
x = tfl.conv2d(x, 32, 5, activation=tf.nn.relu, name='conv1', **params)
x = tfl.max_pooling2d(x, 2, 2, name='pool1', **params)
x = tfl.conv2d(x, 64, 5, activation=tf.nn.relu, name='conv2', **params)
x = tfl.max_pooling2d(x, 2, 2, name='pool2', **params)
x = tfl.flatten(x)
x = tfl.dense(x, 1024, activation=tf.nn.relu, name='fc1')
x = tfl.dense(x, 10, name='fc2')
if mode == Mode.TRAIN:
return {'logits': x}
else:
return {
'logits': x,
'prob': tf.nn.softmax(x),
'pred': tf.argmax(x, axis=-1)
}
def __discriminator__(self, image_input):
with tf.variable_scope("discriminator", reuse=tf.AUTO_REUSE):
cnn1 = layers.conv2d(image_input,
filters=64,
kernel_size=5,
strides=(2, 2),
padding="SAME")
cnn1 = tf.nn.leaky_relu(cnn1)
cnn2 = layers.conv2d(cnn1,
filters=128,
kernel_size=5,
strides=(2, 2),
padding="SAME")
cnn2 = tf.nn.leaky_relu(cnn2)
cnn3 = layers.conv2d(cnn2,
filters=256,
kernel_size=5,
strides=(2, 2),
padding="SAME")
cnn3 = tf.nn.leaky_relu(cnn3)
logits = layers.dense(layers.flatten(cnn3), 1)
#print_Arch:
print("Discriminator-Architecture")
print("input:{}".format(image_input.shape))
print("cnn1:{}".format(cnn1.shape))
print("cnn2:{}".format(cnn2.shape))
print("cnn3:{}".format(cnn3.shape))
print("output:{}".format(logits.shape))
return logits
def encode(self, x, z_dim, training=False):
im_h, im_w, im_c = self.image_shape
with tf.variable_scope("encoder", reuse=tf.AUTO_REUSE):
h = x
h = tf.reshape(h, (-1, im_h, im_w, im_c))
# TODO:
h = tfl.conv2d(
h, self.kernel_num, self.kernel_size,
strides=1, padding="same")
h = tf.nn.relu(h)
h = tfl.conv2d(
h, self.kernel_num, self.kernel_size,
strides=2, padding="same")
h = tf.nn.relu(h)
# TODO: tu troche zmienilem
h = tfl.conv2d(
h, self.kernel_num * 2, self.kernel_size,
strides=2, padding="same")
h = tf.nn.relu(h)
h = tfl.conv2d(
h, self.kernel_num * 2, self.kernel_size,
strides=2, padding="same")
h = tf.nn.relu(h)
h = tfl.flatten(h)
h = tfl.dense(h, units=self.h_dim, activation=tf.nn.relu)
z_mean = tfl.dense(h, units=z_dim, name='z_mean')
# z_mean = tfl.batch_normalization(z_mean, training=training)
return z_mean
def __init__(self, state_size, action_size):
self.states = tf.placeholder(tf.float32,
shape=[None, *state_size],
name="states")
self.labels = tf.placeholder(
tf.int32, shape=[None, 1],
name="labels") # size 1 because sparse loss is used.
# conv1 = layers.conv2d(self.states, filters=16, kernel_size=(8, 8), strides=(4, 4), activation='relu',
# name="conv1"),
# conv2 = layers.conv2d(conv1, filters=32, kernel_size=(4, 4), strides=(2, 2), activation='relu', name="conv2"),
# flatten = layers.flatten(conv2),
# dense = layers.dense(flatten, 256, activation='relu', name="features"),
#
# self.logits = layers.dense(dense, action_size, name="logits")
# self.value = layers.dense(dense, 1, name="values")
# conv1 = conv2d(self.states, filters=32, kernel_size=(3, 3), name='conv1')
with tf.variable_scope('layers'):
conv1 = layers.conv2d(self.states,
filters=32,
kernel_size=(3, 3),
activation='relu',
name='conv1')
conv2 = layers.conv2d(conv1,
filters=64,
kernel_size=(3, 3),
activation='relu',
name='conv2')
max_pool = layers.max_pooling2d(conv2, 2, 1, name='max_pool')
drop_1 = layers.dropout(max_pool, 0.25, name='drop1')
flatten = layers.flatten(drop_1, name='flatten')
dense = layers.dense(flatten, 128, activation='relu', name='dense')
drop2 = layers.dropout(dense, 0.5, name='drop2')
logits = layers.dense(drop2,
action_size,
activation='softmax',
name='logits')
self.output = tf.nn.softmax(logits, name='output')
# tf.one_hot(tf.arg_max(self.output, 1), depth=10)
print(tf.arg_max(self.output, 1))
self.test = tf.one_hot(tf.arg_max(self.output, 1), depth=10)
# input()
self.cost = tf.losses.sparse_softmax_cross_entropy(self.labels, logits)
self.acc, self.acc_op = tf.metrics.accuracy(self.labels,
tf.arg_max(self.output, 1))
# self.grad = tf.gradients(self.cost, self.states, stop_gradients=[self.states])
self.grad = tf.gradients(self.cost, tf.trainable_variables())
self.optimizer = tf.train.AdamOptimizer()
# print(tf.trainable_variables())
# print(tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='layers'))
# print(self.grad)
self.apply_grad = self.optimizer.apply_gradients(
zip(
self.grad,
tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope='layers')))
def resnet18(x, num_classes, training):
x = conv2d(x,
64,
7,
padding=PADDING,
strides=2,
data_format=DATA_FORMAT,
name='conv1')
x = group_normalization(x, 'gn0', 32)
# x = group_norm(x, 32, channels_axis=-3, reduction_axes=[-2, -1])
# x = batch_norm(x, decay=0.9, scale=True, is_training=training, epsilon=BN_EPS, data_format='NCHW')
x = tf.nn.relu(x)
stage = [2, 2, 2, 2]
channels = [64, 128, 256, 512]
for i, s, c in zip(list(range(4)), stage, channels):
for l in range(s):
stride = 1 if l > 0 else 2
proj = False if l > 0 else True
x = create_residual_block('res_block_{}_{}'.format(i + 1, l + 1),
x,
c,
stride=stride,
proj=proj,
training=training)
# BxCx1x1
x = flatten(x)
x = slim.fully_connected(x, num_classes, activation_fn=None)
return x
def weighted_accuracy(y_true, y_pred):
correct_prediction = layers.flatten(y_pred)
# correct_prediction = tf.reduce_min(y_pred, axis=-1)
correct_prediction = tf.greater(correct_prediction,0.5)
# correct_prediction = tf.equal(tf.argmax(y_pred, axis=-1), y_ture_tmp)
correct_prediction = tf.cast(correct_prediction, tf.float32)
# correct_prediction.shape = (1, 256, 256, 16)
y_true = layers.flatten(y_true)
# y_true = tf.reduce_min(y_true, axis=-1)
correct_partial = tf.multiply(correct_prediction, y_true)
accuracy = tf.reduce_sum(correct_partial)/tf.reduce_sum(y_true)
incorrect_partial = tf.multiply((1.-correct_prediction),(1.- y_true))
inaccuracy = tf.reduce_sum(incorrect_partial)/tf.reduce_sum(1.-y_true)
return accuracy, inaccuracy
def _dense_brick(incoming, is_training, scope='dense_brick'):
""" Dense brick: flatten --> fully connected --> batch normalization --> leaky relu.
"""
with tf.variable_scope(scope):
flat = layers.flatten(incoming)
fc = layers.dense(flat, units=32)
fc_bn = layers.batch_normalization(fc, training=is_training)
fc_act = tf.nn.leaky_relu(fc_bn)
return fc_act
def pretrained_classifier(inputae, n_label, reuse, name='classifier', isTrain = False, n_filters = 64, output_bias=None):
print("Classifier", isTrain)
if output_bias is not None:
output_bias = tf.constant_initializer(output_bias)
padw = 3
with tf.variable_scope(name) as scope:
if reuse:
tf.get_variable_scope().reuse_variables()
else:
assert tf.get_variable_scope().reuse is False
print("inputae: ", inputae)
pad_input = tf.pad(inputae, [[0, 0], [padw, padw], [padw, padw], [0, 0]], "CONSTANT")
#print("pad_input: ", pad_input)
conv1, _conv, _bn = conv_2d_BN_Relu(pad_input, n_filters, 7, 2, 'VALID',isTrain)
#print("conv1: ", conv1)
padw = 1
pad_conv1 = tf.pad(conv1, [[0, 0], [padw, padw], [padw, padw], [0, 0]], "CONSTANT")
#print("pad_conv1: ", pad_conv1)
pool1 = Max_Pooling(pad_conv1, pool_size=[3,3], stride=2)
#print("pool1: ", pool1)
# Block 1
block1 = dense_block(pool1, nb_layers=6, layer_name='dense_1', isTrain=isTrain, filters=n_filters)
transition1 = transition_layer(block1, isTrain, scope='trans_1')
#print("block1 output: ", transition1)
#print("............................")
block2 = dense_block(transition1, nb_layers=12, layer_name='dense_2', isTrain=isTrain, filters=n_filters)
transition2 = transition_layer(block2, isTrain, scope='trans_2')
#print("block2 output: ", transition2)
#print("............................")
block3 = dense_block(transition2, nb_layers=24, layer_name='dense_3', isTrain=isTrain, filters=n_filters)
transition3 = transition_layer(block3, isTrain, scope='trans_3')
#print("block3 output: ", transition3)
#print("............................")
block4 = dense_block(transition3, nb_layers=16, layer_name='dense_final', isTrain=isTrain, filters=n_filters)
#print("block4 output: ", block4)
#print("............................")
bn = batch_norm(block4, is_training=isTrain, name='linear_batch')
print("bn final: ", bn)
rel = tf.nn.relu(bn)
shape = rel.get_shape().as_list()
#print(shape)
gap = Average_pooling(rel, pool_size=[shape[1],shape[2]], stride=1)
#gap = Average_pooling(rel, pool_size=[7,7], stride=1)
#print("global avg pooling final: ", gap)
flat = flatten(gap)
#print("flat: ", flat)
logit = tf.layers.dense(flat, units=n_label, bias_initializer= output_bias, name='linear')
#print("logit: ", logit)
if isTrain == False:
#print(isTrain)
logit = tf.stop_gradient(logit)
prediction = tf.nn.sigmoid(logit)
#pred_y = tf.argmax(prediction, 1)
return logit, prediction
def build_network(self, img_placeholder):
x = img_placeholder
x = self.basic_conv2d(x,
32,
kernel_size=3,
stride=2,
padding="same",
namescope="conv2d_1a",
use_bias=False)
x = self.basic_conv2d(x,
32,
kernel_size=3,
stride=1,
padding="same",
namescope="conv2d_2a",
use_bias=False)
x = self.basic_conv2d(x,
64,
kernel_size=3,
stride=1,
padding="same",
namescope="conv2d_2b",
use_bias=False)
x = self.basic_conv2d(x,
80,
kernel_size=1,
stride=1,
padding="same",
namescope="conv2d_3b",
use_bias=False)
x = self.basic_conv2d(x,
192,
kernel_size=3,
stride=1,
padding="same",
namescope="conv2d_4a",
use_bias=False)
x = self.mixed_5b(x)
x = self.mixed_6a(x)
x = self.mixed_7a(x)
x = self.block8(x)
x = self.basic_conv2d(x,
1536,
kernel_size=1,
stride=1,
padding="same",
namescope="conv2d_7b",
use_bias=False)
x = layers.average_pooling2d(x, 8, strides=8, padding="valid")
x = layers.flatten(x)
logits = layers.dense(x, self.n_classes, name="last_linear")
probs = tf.nn.softmax(logits)
return logits, probs
def vgg_11_1d(x, keep_proba, conf):
def _dense(inputs, neurons, name, activation=tf.nn.relu, use_bias=True):
"""wrapper function for dense layer"""
w_ini, b_ini, r_ini = initializers(conf.bias_init, conf.l2_str)
return dense(inputs,
neurons,
activation=activation,
bias_initializer=b_ini,
kernel_initializer=w_ini,
kernel_regularizer=r_ini,
name=name,
use_bias=use_bias)
def _conv1d(inputs, n_filters, size, name, padding='SAME'):
"""wrapper function for 1D convolutional layer"""
w_ini, b_ini, r_ini = initializers(conf.bias_init, conf.l2_str)
return conv1d(inputs,
n_filters,
size,
padding=padding,
activation=tf.nn.relu,
bias_initializer=b_ini,
kernel_initializer=w_ini,
kernel_regularizer=r_ini,
name=name)
# https://arxiv.org/abs/1409.1556 --> configuration A
w_ini, b_ini, r_ini = initializers(conf.bias_init, conf.l2_str)
x_multichannel = tf.reshape(x, [-1, conf.seq_lngth, conf.num_ch])
net = _conv1d(x_multichannel, 64, 3, 'conv1')
net = max_pooling1d(net, 2, 2, 'same', name='maxpool1')
net = _conv1d(net, 128, 3, 'conv2')
net = max_pooling1d(net, 2, 2, 'same', name='maxpool2')
net = _conv1d(net, 256, 3, 'conv3_1')
net = _conv1d(net, 256, 3, 'conv3_2')
net = max_pooling1d(net, 2, 2, 'same', name='maxpool3')
net = _conv1d(net, 512, 3, 'conv4_1')
net = _conv1d(net, 512, 3, 'conv4_2')
net = max_pooling1d(net, 2, 2, 'same', name='maxpool4')
net = _conv1d(net, 512, 3, 'conv5_1')
net = _conv1d(net, 512, 3, 'conv5_2')
net = max_pooling1d(net, 2, 2, 'same', name='maxpool5')
net = flatten(net, name='flat_layer')
net = _dense(net, 4096, 'fc6')
net = tf.nn.dropout(net, keep_proba, name='dropout6')
net = _dense(net, 4096, 'fc7')
net = tf.nn.dropout(net, keep_proba, name='dropout7')
logits = _dense(net, conf.num_cl, 'logits', activation=None)
# softmax performed at loss function
return logits
def __init__(self, state_size, action_size, hidden_layer_size,
learning_rate, name):
if isinstance(state_size, list) and len(state_size) == 3:
self.mode = 'visual'
elif isinstance(state_size, int):
self.mode = 'vector'
self.state_size = state_size
self.action_size = action_size
self.hidden_size = hidden_layer_size
self.name = name
self.learning_rate = learning_rate
with tf.variable_scope(name):
if self.mode == 'visual':
self.observation = tf.placeholder(
tf.float32,
shape=[None, *self.state_size],
name="actor_observation")
self.L1 = layer.conv2d(self.observation,
64,
3,
activation=tf.nn.leaky_relu)
self.L2 = layer.conv2d(self.L1,
64,
3,
activation=tf.nn.leaky_relu)
self.L3 = layer.flatten(self.L2)
self.action = layer.dense(self.L3,
self.action_size,
activation=tf.nn.tanh,
name='actor_decide')
elif self.mode == 'vector':
self.observation = tf.placeholder(
tf.float32,
shape=[None, self.state_size],
name="actor_observation")
self.L1 = layer.dense(self.observation,
self.hidden_size,
activation=tf.nn.leaky_relu)
self.L2 = layer.dense(self.L1,
self.hidden_size,
activation=tf.nn.leaky_relu)
self.L3 = layer.dense(self.L2,
self.hidden_size,
activation=tf.nn.leaky_relu)
self.action = layer.dense(self.L3,
self.action_size,
activation=tf.nn.tanh,
name='actor_decide')
self.trainable_var = tf.get_collection(
tf.GraphKeys.TRAINABLE_VARIABLES, self.name)
def Net(self, x, is_train):
# 28*28*1
x = self.conv_net(x, 8, 3, 2, is_train, 'c0')
# 13*13*8
x = self.conv_net(x, 32, 2, 2, is_train, 'c1')
# 6*6*32
x = layer.flatten(x)
# base_code 에서는 tensorflow.contrib.layers.fully_connected 를 사용했는데 tensorflow.contrib.layers는 잘 안씀.
# tensorflow.layers를 보통 사용하고 여기선 tensorflow.layers.dense가 fully_connected와 동일.
x = layer.dense(x, 200, activation=None, name='d1')
x = tf.nn.relu(x)
x = layer.dense(x, 10, activation=None, name='d3')
return x
def discriminator(ten, dim, name, reuse=True):
# ans = tf.placeholder(tf.float32, [None, C.size, C.size, 3])
with tf.variable_scope(name, reuse=reuse):
ten = tl.conv2d(ten, dim * 1, 4, 2, 'same', activation=tf.nn.leaky_relu)
ten = tl.conv2d(ten, dim * 2, 4, 2, 'same', activation=tf.nn.leaky_relu)
ten = tl.conv2d(ten, dim * 4, 4, 2, 'same', activation=tf.nn.leaky_relu)
ten = tl.conv2d(ten, dim * 8, 4, 2, 'same', activation=tf.nn.leaky_relu)
ten = tl.conv2d(ten, dim * 16, 4, 2, 'same', activation=tf.nn.leaky_relu)
ten = tl.conv2d(ten, dim * 32, 4, 2, 'same', activation=tf.nn.leaky_relu)
ten = tl.conv2d(ten, dim * 64, 4, 1, 'valid', activation=tf.nn.leaky_relu)
ten = tl.conv2d(ten, 1, 1, 1, 'valid', activation=None)
ten = tl.flatten(ten)
return ten
