def model(self):
w_init = tf.keras.initializers.glorot_normal(
seed=None
) # glorot initialization is better than uniform in practice
# init_w=3e-3
# w_init = tf.random_uniform_initializer(-init_w, init_w)
inputs = Input([None, self.input_dim],
name=str(self.scope) +
'q_input' if self.scope is not None else 'q_input')
l = Dense(n_units=self.hidden_dim,
act=tf.nn.relu,
W_init=w_init,
name=str(self.scope) +
'v_1' if self.scope is not None else 'v_1')(inputs)
for i in range(self.num_hidden_layer):
l = Dense(n_units=self.hidden_dim,
act=tf.nn.relu,
W_init=w_init,
name=str(self.scope) + 'v_1' +
str(i + 2) if self.scope is not None else 'v_1' +
str(i + 2))(l)
outputs = Dense(
n_units=1,
W_init=w_init,
name=str(self.scope) + 'v' +
str(self.num_hidden_layer + 2) if self.scope is not None else 'v' +
str(self.num_hidden_layer + 2))(l)
return tl.models.Model(
inputs=inputs,
outputs=outputs,
name=str(self.scope) +
'value_network' if self.scope is not None else 'value_network')
def __init__(self,
num_inputs,
num_actions,
hidden_dim,
action_range=1.,
init_w=3e-3):
super(PolicyNetwork, self).__init__()
# w_init = tf.keras.initializers.glorot_normal(seed=None)
w_init = tf.random_uniform_initializer(-init_w, init_w)
self.linear1 = Dense(n_units=hidden_dim,
act=tf.nn.relu,
W_init=w_init,
in_channels=num_inputs,
name='policy1')
self.linear2 = Dense(n_units=hidden_dim,
act=tf.nn.relu,
W_init=w_init,
in_channels=hidden_dim,
name='policy2')
self.linear3 = Dense(n_units=hidden_dim,
act=tf.nn.relu,
W_init=w_init,
in_channels=hidden_dim,
name='policy3')
self.output_linear = Dense(n_units=num_actions, W_init=w_init, \
b_init=tf.random_uniform_initializer(-init_w, init_w), in_channels=hidden_dim, name='policy_output')
self.action_range = action_range
self.num_actions = num_actions
def __init__(self,
state_dim,
action_dim,
hidden_dim,
init_w=3e-3,
scope=None):
super(DeterministicPolicyNetwork_old, self).__init__()
w_init = tf.keras.initializers.glorot_normal(seed=None)
# w_init = tf.random_uniform_initializer(-init_w, init_w)
self.linear1 = Dense(n_units=hidden_dim,
act=tf.nn.relu,
W_init=w_init,
in_channels=state_dim,
name='policy1')
self.linear2 = Dense(n_units=hidden_dim,
act=tf.nn.relu,
W_init=w_init,
in_channels=hidden_dim,
name='policy2')
self.linear3 = Dense(n_units=hidden_dim,
act=tf.nn.relu,
W_init=w_init,
in_channels=hidden_dim,
name='policy3')
self.action_linear = Dense(n_units=action_dim, W_init=w_init, \
b_init=tf.random_uniform_initializer(-init_w, init_w), in_channels=hidden_dim, name='policy')
def __init__(
self, num_inputs, num_actions, hidden_dim, action_range=1., init_w=3e-3, log_std_min=-20, log_std_max=2
):
super(PolicyNetwork, self).__init__()
self.log_std_min = log_std_min
self.log_std_max = log_std_max
w_init = tf.keras.initializers.glorot_normal(seed=None)
# w_init = tf.random_uniform_initializer(-init_w, init_w)
self.linear1 = Dense(n_units=hidden_dim, act=tf.nn.relu, W_init=w_init, in_channels=num_inputs, name='policy1')
self.linear2 = Dense(n_units=hidden_dim, act=tf.nn.relu, W_init=w_init, in_channels=hidden_dim, name='policy2')
self.linear3 = Dense(n_units=hidden_dim, act=tf.nn.relu, W_init=w_init, in_channels=hidden_dim, name='policy3')
self.mean_linear = Dense(
n_units=num_actions, W_init=w_init, b_init=tf.random_uniform_initializer(-init_w, init_w),
in_channels=hidden_dim, name='policy_mean'
)
self.log_std_linear = Dense(
n_units=num_actions, W_init=w_init, b_init=tf.random_uniform_initializer(-init_w, init_w),
in_channels=hidden_dim, name='policy_logstd'
)
self.action_range = action_range
self.num_actions = num_actions
def get_discriminator(latent_shape, image_shape, df_dim=64):
w_init = tf.random_normal_initializer(stddev=0.02)
gamma_init = tf.random_normal_initializer(1., 0.02)
lrelu = lambda x: tf.nn.leaky_relu(x, 0.2)
n1i = Input(image_shape)
n1 = Conv2d(df_dim, (5, 5), (2, 2), act=lrelu, W_init=w_init)(n1i)
n1 = Conv2d(df_dim * 2, (5, 5), (2, 2), W_init=w_init, b_init=None)(n1)
n1 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(n1)
n1 = Dropout(keep=0.8)(n1)
n1 = Conv2d(df_dim * 4, (5, 5), (2, 2), W_init=w_init, b_init=None)(n1)
n1 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(n1)
n1 = Dropout(keep=0.8)(n1)
n1 = Conv2d(df_dim * 8, (5, 5), (2, 2), W_init=w_init, b_init=None)(n1)
n1 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(n1)
n1 = Dropout(keep=0.8)(n1)
n1 = Flatten()(n1) # [-1,4*4*df_dim*8]
n2i = Input(latent_shape)
n2 = Dense(n_units=4 * 4 * df_dim * 8, W_init=w_init, b_init=None)(n2i)
n2 = Dropout(keep=0.8)(n2)
nn = Concat()([n1, n2])
nn = Dense(n_units=1, W_init=w_init, b_init=None)(nn)
return tl.models.Model(inputs=[n1i, n2i], outputs=nn, name='discriminator')
def get_discriminator(train_model, n_filter=512, layer_num=5):
scale_size = train_model.backbone.scale_size
data_format = train_model.data_format
feature_hin, feature_win = train_model.hin / scale_size, train_model.win / scale_size
dis_hin, dis_win = feature_hin, feature_win
last_channels = train_model.backbone.out_channels
layer_list = []
for layer_idx in range(0, layer_num):
strides = (1, 1)
if (dis_hin > 10 or dis_win > 10):
strides = (2, 2)
dis_hin, dis_win = (dis_hin + 1) // 2, (dis_win + 1) // 2
layer_list+=[
Conv2d(n_filter=n_filter,in_channels=last_channels,strides=strides,act=tf.nn.relu,data_format=data_format,\
name=f"dis_conv_{layer_idx}")
]
last_channels = n_filter
layer_list.append(Flatten(name="Flatten"))
layer_list.append(
Dense(n_units=4096,
in_channels=dis_hin * dis_win * n_filter,
act=tf.nn.relu,
name="fc1"))
layer_list.append(
Dense(n_units=1000, in_channels=4096, act=tf.nn.relu, name="fc2"))
layer_list.append(Dense(n_units=1, in_channels=1000, act=None, name="fc3"))
discriminator = Discriminator(layer_list=layer_list,
data_format=data_format)
print("domain adaptation discriminator generated!")
return discriminator
def hidden_model(inputs_shape):
ni = Input(inputs_shape)
nn = Dropout(keep=0.8)(ni)
nn = Dense(n_units=800, act=tf.nn.relu)(nn)
nn = Dropout(keep=0.8)(nn)
nn = Dense(n_units=800, act=tf.nn.relu)(nn)
return Model(inputs=ni, outputs=nn, name="mlp_hidden")
def __init__(self, num_inputs, num_actions, hidden_dim, init_w=3e-3):
super(QNetwork, self).__init__()
input_dim = num_inputs + num_actions
w_init = tf.random_uniform_initializer(-init_w, init_w)
self.linear1 = Dense(n_units=hidden_dim, act=tf.nn.relu, W_init=w_init, in_channels=input_dim, name='q1')
self.linear2 = Dense(n_units=hidden_dim, act=tf.nn.relu, W_init=w_init, in_channels=hidden_dim, name='q2')
self.linear3 = Dense(n_units=1, W_init=w_init, in_channels=hidden_dim, name='q3')
def __init__(self, state_space, action_space, hidden_dim_list, w_init=tf.keras.initializers.glorot_normal(),
activation=tf.nn.relu, output_activation=tf.nn.tanh, trainable=True, name=None):
""" Deterministic continuous/discrete policy network with multiple fully-connected layers
Args:
state_space (gym.spaces): space of the state from gym environments
action_space (gym.spaces): space of the action from gym environments
hidden_dim_list (list[int]): a list of dimensions of hidden layers
w_init (callable): weights initialization
activation (callable): activation function
output_activation (callable or None): output activation function
trainable (bool): set training and evaluation mode
"""
self._state_space, self._action_space = state_space, action_space
if isinstance(self._action_space, spaces.Discrete):
self._action_shape = self._action_space.n,
elif isinstance(self._action_space, spaces.Box):
assert len(self._action_space.shape) == 1
self._action_shape = self._action_space.shape
assert all(self._action_space.low < self._action_space.high)
action_bounds = [self._action_space.low, self._action_space.high]
self._action_mean = np.mean(action_bounds, 0)
self._action_scale = action_bounds[1] - self._action_mean
else:
raise NotImplementedError
self._state_shape = state_space.shape
# build structure
if len(self._state_shape) == 1:
l = inputs = Input((None,) + self._state_shape, name='input_layer')
else:
with tf.name_scope('CNN'):
inputs, l = CNN(self._state_shape, conv_kwargs=None)
with tf.name_scope('MLP'):
for i, dim in enumerate(hidden_dim_list):
l = Dense(n_units=dim, act=activation, W_init=w_init, name='hidden_layer%d' % (i + 1))(l)
with tf.name_scope('Output'):
outputs = Dense(n_units=self._action_shape[0], act=output_activation, W_init=w_init)(l)
if isinstance(self._action_space, spaces.Discrete):
outputs = tl.layers.Lambda(lambda x: tf.argmax(tf.nn.softmax(x), axis=-1))(outputs)
elif isinstance(self._action_space, spaces.Box):
outputs = tl.layers.Lambda(lambda x: x * self._action_scale + self._action_mean)(outputs)
outputs = tl.layers.Lambda(lambda x: tf.clip_by_value(x, self._action_space.low,
self._action_space.high))(outputs)
# make model
super().__init__(inputs=inputs, outputs=outputs, name=name)
if trainable:
self.train()
else:
self.eval()
def make_layers(config, batch_norm=False, end_with='outputs'):
layer_list = []
is_end = False
for layer_group_idx, layer_group in enumerate(config):
if isinstance(layer_group, list):
for idx, layer in enumerate(layer_group):
layer_name = layer_names[layer_group_idx][idx]
n_filter = layer
if idx == 0:
if layer_group_idx > 0:
in_channels = config[layer_group_idx - 2][-1]
else:
in_channels = 3
else:
in_channels = layer
layer_list.append(
Conv2d(n_filter=n_filter,
filter_size=(3, 3),
strides=(1, 1),
act=tf.nn.relu,
padding='SAME',
in_channels=in_channels,
name=layer_name))
if batch_norm:
layer_list.append(BatchNorm())
if layer_name == end_with:
is_end = True
break
else:
layer_name = layer_names[layer_group_idx]
if layer_group == 'M':
layer_list.append(
MaxPool2d(filter_size=(2, 2),
strides=(2, 2),
padding='SAME',
name=layer_name))
elif layer_group == 'O':
layer_list.append(
Dense(n_units=1000, in_channels=4096, name=layer_name))
elif layer_group == 'F':
layer_list.append(Flatten(name='flatten'))
elif layer_group == 'fc1':
layer_list.append(
Dense(n_units=4096,
act=tf.nn.relu,
in_channels=512 * 7 * 7,
name=layer_name))
elif layer_group == 'fc2':
layer_list.append(
Dense(n_units=4096,
act=tf.nn.relu,
in_channels=4096,
name=layer_name))
if layer_name == end_with:
is_end = True
if is_end:
break
return LayerList(layer_list)
def __init__(self):
super(CustomModel, self).__init__()
self.dropout1 = Dropout(keep=0.8) #(self.innet)
self.dense1 = Dense(n_units=800, act=tf.nn.relu, in_channels=784) #(self.dropout1)
self.dropout2 = Dropout(keep=0.8) #(self.dense1)
self.dense2 = Dense(n_units=800, act=tf.nn.relu, in_channels=800) #(self.dropout2)
self.dropout3 = Dropout(keep=0.8) #(self.dense2)
self.dense3 = Dense(n_units=10, act=tf.nn.relu, in_channels=800) #(self.dropout3)
def get_z_D(shape_z):
w_init = tf.random_normal_initializer(stddev=0.02)
lrelu = lambda x: tf.nn.leaky_relu(x, 0.2)
nz = Input(shape_z)
n = Dense(n_units=750, act=lrelu, W_init=w_init)(nz)
n = Dense(n_units=750, act=lrelu, W_init=w_init)(n)
n = Dense(n_units=750, act=lrelu, W_init=w_init)(n)
n = Dense(n_units=1, act=None, W_init=w_init, b_init=None)(n)
return tl.models.Model(inputs=nz, outputs=n)
def __init__(self):
super(CustomModelHidden, self).__init__()
self.dropout1 = Dropout(keep=0.8) #(self.innet)
self.seq = LayerList([
Dense(n_units=800, act=tf.nn.relu, in_channels=784),
Dropout(keep=0.8),
Dense(n_units=800, act=tf.nn.relu, in_channels=800),
])
self.dropout3 = Dropout(keep=0.8) #(self.seq)
def get_Q(shape):
w_init = tf.random_normal_initializer(stddev=0.02)
ni = Input(shape)
cat1 = Dense(n_units=flags.dim_categorical, W_init=w_init)(ni)
cat2 = Dense(n_units=flags.dim_categorical, W_init=w_init)(ni)
cat3 = Dense(n_units=flags.dim_categorical, W_init=w_init)(ni)
mu = Dense(n_units=1, W_init=w_init, name='mu')(ni)
# sigma = Dense(n_units=1, W_init=w_init, name='sigma')(ni)
return tl.models.Model(inputs=ni, outputs=[cat1, cat2, cat3, mu], name='Q')
def get_model(inputs_shape):
ni = Input(inputs_shape)
nn = Dropout(keep=0.8)(ni)
nn = Dense(n_units=800, act=tf.nn.relu)(nn)
nn = Dropout(keep=0.8)(nn)
nn = Dense(n_units=800, act=tf.nn.relu)(nn)
nn = Dropout(keep=0.8)(nn)
nn = Dense(n_units=10, act=tf.nn.relu)(nn)
M = Model(inputs=ni, outputs=nn, name="mlp")
return M
def create_base_network(input_shape):
'''Base network to be shared (eq. to feature extraction).
'''
input = Input(shape=input_shape)
x = Flatten()(input)
x = Dense(128, act=tf.nn.relu)(x)
x = Dropout(0.9)(x)
x = Dense(128, act=tf.nn.relu)(x)
x = Dropout(0.9)(x)
x = Dense(128, act=tf.nn.relu)(x)
return Model(input, x)
def get_Q(shape):
w_init = tf.random_normal_initializer(stddev=0.02)
gamma_init = tf.random_normal_initializer(1., 0.02)
lrelu = lambda x: tf.nn.leaky_relu(x, flags.leaky_rate)
ni = Input(shape)
q = Dense(n_units=128, W_init=w_init, b_init=None)(ni)
q = BatchNorm(decay=0.9, act=lrelu, gamma_init=gamma_init)(q)
q = Dense(n_units=flags.n_categorical * flags.dim_categorical,
W_init=w_init)(q)
return tl.models.Model(inputs=ni, outputs=q, name='Q_tail')
def __init__(self, num_inputs, num_actions, hidden_dim, init_w=3e-3):
super(SoftQNetwork, self).__init__()
input_dim = num_inputs + num_actions
w_init = tf.keras.initializers.glorot_normal(
seed=None
) # glorot initialization is better than uniform in practice
# w_init = tf.random_uniform_initializer(-init_w, init_w)
self.linear1 = Dense(n_units=hidden_dim, act=tf.nn.relu, W_init=w_init, in_channels=input_dim, name='q1')
self.linear2 = Dense(n_units=hidden_dim, act=tf.nn.relu, W_init=w_init, in_channels=hidden_dim, name='q2')
self.linear3 = Dense(n_units=1, W_init=w_init, in_channels=hidden_dim, name='q3')
def get_trans_func(shape=[None, flags.z_dim]):
w_init = tf.random_normal_initializer(stddev=0.02)
act = 'relu' # lambda x : tf.nn.leaky_relu(x, 0.2)
ni = Input(shape)
nn = Dense(n_units=flags.z_dim, act=act, W_init=w_init)(ni)
nn = Dense(n_units=flags.z_dim, act=act, W_init=w_init)(nn)
nn = Dense(n_units=flags.z_dim, act=act, W_init=w_init)(nn)
nn = Dense(n_units=flags.z_dim, W_init=w_init)(nn)
return tl.models.Model(inputs=ni, outputs=nn)
def get_model(inputs_shape):
ni = Input(inputs_shape)
nn = Dropout(keep=0.8)(ni)
nn = Dense(n_units=800, act=tf.nn.relu)(nn)
nn = Dropout(keep=0.8)(nn)
nn = Dense(n_units=800, act=tf.nn.relu)(nn)
# FIXME: currently assume the inputs and outputs are both Layer. They can be lists.
M_hidden = Model(inputs=ni, outputs=nn, name="mlp_hidden")
nn = Dropout(keep=0.8)(M_hidden.as_layer())
nn = Dense(n_units=10, act=tf.nn.relu)(nn)
return Model(inputs=ni, outputs=nn, name="mlp")
def get_z_D(shape_z):
gamma_init = tf.random_normal_initializer(1., 0.02)
w_init = tf.random_normal_initializer(stddev=0.02)
lrelu = lambda x: tf.nn.leaky_relu(x, 0.2)
nz = Input(shape_z)
n = Dense(n_units=750, act=None, W_init=w_init, b_init=None)(nz)
n = BatchNorm(decay=0.9, act=lrelu, gamma_init=gamma_init)(n)
n = Dense(n_units=750, act=None, W_init=w_init, b_init=None)(n)
n = BatchNorm(decay=0.9, act=lrelu, gamma_init=gamma_init)(n)
n = Dense(n_units=750, act=None, W_init=w_init, b_init=None)(n)
n = BatchNorm(decay=0.9, act=lrelu, gamma_init=gamma_init)(n)
n = Dense(n_units=1, act=None, W_init=w_init)(n)
return tl.models.Model(inputs=nz, outputs=n, name='c_Discriminator')
def get_model(inputs_shape):
# self defined initialization
W_init = tl.initializers.truncated_normal(stddev=5e-2)
W_init2 = tl.initializers.truncated_normal(stddev=0.04)
b_init2 = tl.initializers.constant(value=0.1)
# build network
ni = Input(inputs_shape)
nn = Conv2d(64, (5, 5), (1, 1),
padding='SAME',
act=tf.nn.relu,
W_init=W_init,
b_init=None,
name='conv1')(ni)
nn = MaxPool2d((3, 3), (2, 2), padding='SAME', name='pool1')(nn)
nn = LocalResponseNorm(depth_radius=4,
bias=1.0,
alpha=0.001 / 9.0,
beta=0.75,
name="norm1")(nn)
nn = Conv2d(64, (5, 5), (1, 1),
padding='SAME',
act=tf.nn.relu,
W_init=W_init,
b_init=None,
name='conv2')(nn)
nn = LocalResponseNorm(depth_radius=4,
bias=1.0,
alpha=0.001 / 9.0,
beta=0.75,
name="norm2")(nn)
nn = MaxPool2d((3, 3), (2, 2), padding='SAME', name='pool2')(nn)
nn = Flatten(name='flatten')(nn)
nn = Dense(384,
act=tf.nn.relu,
W_init=W_init2,
b_init=b_init2,
name='dense1relu')(nn)
nn = Dense(192,
act=tf.nn.relu,
W_init=W_init2,
b_init=b_init2,
name='dense2relu')(nn)
nn = Dense(10, act=None, W_init=W_init2, name='output')(nn)
M = Model(inputs=ni, outputs=nn, name='cnn')
return M
def __init__(self, nc=3, ndf=64, T=16):
super(discriminator_V, self).__init__()
self.conv1 = Conv3d(in_channels=nc,
n_filter=ndf,
filter_size=(4, 4, 4),
strides=(2, 2, 2),
padding='SAME',
b_init=None,
act=tf.nn.leaky_relu)
self.conv2 = Conv3d(in_channels=ndf,
n_filter=ndf * 2,
filter_size=(4, 4, 4),
strides=(2, 2, 2),
padding='SAME',
b_init=None)
self.batch1 = BatchNorm3d(num_features=ndf * 2, act=tf.nn.leaky_relu)
self.conv3 = Conv3d(in_channels=ndf * 2,
n_filter=ndf * 4,
filter_size=(4, 4, 4),
strides=(2, 2, 2),
padding='SAME',
b_init=None)
self.batch2 = BatchNorm3d(num_features=ndf * 4, act=tf.nn.leaky_relu)
self.conv4 = Conv3d(in_channels=ndf * 4,
n_filter=ndf * 8,
filter_size=(4, 4, 4),
strides=(2, 2, 2),
padding='SAME',
b_init=None)
self.batch3 = BatchNorm3d(num_features=ndf * 8, act=tf.nn.leaky_relu)
self.flatten = Flatten()
self.dense = Dense(in_channels=(int((ndf * 8) * (T / 16) * 36)),
n_units=1,
act=tf.nn.sigmoid)
def __init__(self, state_shape, action_shape, hidden_dim_list, \
w_init=tf.keras.initializers.glorot_normal(), activation=tf.nn.relu, output_activation=None,
trainable=True):
"""
Q-value network with multiple fully-connected layers
Inputs: (state tensor, action tensor)
:param state_shape: (tuple[int]) shape of the state, for example, (state_dim, ) for single-dimensional state
:param action_shape: (tuple[int]) shape of the action, for example, (action_dim, ) for single-dimensional action
:param hidden_dim_list: (list[int]) a list of dimensions of hidden layers
:param w_init: (callable) weights initialization
:param activation: (callable) activation function
:param output_activation: (callable or None) output activation function
:param trainable: (bool) set training and evaluation mode
"""
input_shape = tuple(map(sum, zip(action_shape, state_shape)))
input_dim = input_shape[0]
assert len(state_shape) == 1
with tf.name_scope('MLP'):
inputs, l = MLP(input_dim, hidden_dim_list, w_init, activation)
with tf.name_scope('Output'):
outputs = Dense(n_units=1, act=output_activation, W_init=w_init)(l)
super().__init__(inputs=inputs, outputs=outputs)
if trainable:
self.train()
else:
self.eval()
def get_generator(shape=[None, flags.z_dim], gf_dim=64, name=None):
image_size = 64
s16 = image_size // 16
w_init = tf.random_normal_initializer(stddev=0.02)
gamma_init = tf.random_normal_initializer(1., 0.02)
ni = Input(shape)
nn = Dense(n_units=(gf_dim * 8 * s16 * s16), W_init=w_init,
b_init=None)(ni)
nn = Reshape(shape=[-1, s16, s16, gf_dim * 8])(nn)
nn = BatchNorm(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init,
name=None)(nn)
nn = DeConv2d(gf_dim * 4, (5, 5), (2, 2), W_init=w_init, b_init=None)(nn)
nn = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(nn)
nn = DeConv2d(gf_dim * 2, (5, 5), (2, 2), W_init=w_init, b_init=None)(nn)
nn = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(nn)
nn = DeConv2d(gf_dim, (5, 5), (2, 2), W_init=w_init, b_init=None)(nn)
nn = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(nn)
nn = DeConv2d(3, (5, 5), (2, 2), act=tf.nn.tanh, W_init=w_init)(nn)
return tl.models.Model(inputs=ni, outputs=nn, name=name)
def get_encoder(shape=[None, flags.output_size, flags.output_size, flags.c_dim] \
, df_dim=64, name=None):
w_init = tf.random_normal_initializer(stddev=0.02)
gamma_init = tf.random_normal_initializer(1., 0.02)
lrelu = lambda x: tf.nn.leaky_relu(x, 0.2)
ni = Input(shape)
nn = Conv2d(df_dim, (5, 5), (2, 2), act=lrelu, W_init=w_init)(ni)
nn = Conv2d(df_dim * 2, (5, 5), (2, 2),
act=None,
W_init=w_init,
b_init=None)(nn)
nn = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(nn)
nn = Conv2d(df_dim * 4, (5, 5), (2, 2),
act=None,
W_init=w_init,
b_init=None)(nn)
nn = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(nn)
nn = Conv2d(df_dim * 8, (5, 5), (2, 2),
act=None,
W_init=w_init,
b_init=None)(nn)
nn = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(nn)
nn = Flatten()(nn)
#print(nn.shape)
nn = Dense(flags.z_dim, act=tf.identity, W_init=w_init)(nn)
return tl.models.Model(inputs=ni, outputs=nn, name=name)
def get_generator(
shape,
gf_dim=64): # Dimension of gen filters in first conv layer. [64]
image_size = 64
s16 = image_size // 16
w_init = tf.random_normal_initializer(0.0, 0.02)
gamma_init = tf.random_normal_initializer(1., 0.02)
ni = Input(shape)
nn = Dense(n_units=(gf_dim * 8 * s16 * s16), W_init=w_init,
b_init=None)(ni)
nn = Reshape(shape=[-1, s16, s16, gf_dim * 8])(nn)
nn = BatchNorm2d(decay=0.9,
act=tf.nn.relu,
gamma_init=gamma_init,
name=None)(nn)
nn = DeConv2d(gf_dim * 4, (5, 5), (2, 2), W_init=w_init, b_init=None)(nn)
nn = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(nn)
nn = DeConv2d(gf_dim * 2, (5, 5), (2, 2), W_init=w_init, b_init=None)(nn)
nn = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(nn)
nn = DeConv2d(gf_dim, (5, 5), (2, 2), W_init=w_init, b_init=None)(nn)
nn = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(nn)
nn = DeConv2d(3, (5, 5), (2, 2), act=tf.nn.tanh, W_init=w_init)(nn)
return tl.models.Model(inputs=ni, outputs=nn, name='generator')
def create_model(inputs_shape):
W_init = tl.initializers.truncated_normal(stddev=5e-2)
W_init2 = tl.initializers.truncated_normal(stddev=0.04)
ni = Input(inputs_shape)
nn = Conv2d(64, (3, 3), (1, 1), padding='SAME', act=tf.nn.relu, W_init=W_init, name='conv1_1')(ni)
nn = MaxPool2d((2, 2), (2, 2), padding='SAME', name='pool1_1')(nn)
nn = Conv2d(64, (3, 3), (1, 1), padding='SAME', act=tf.nn.relu, W_init=W_init, b_init=None, name='conv1_2')(nn)
nn = MaxPool2d((2, 2), (2, 2), padding='SAME', name='pool1_2')(nn)
nn = Conv2d(128, (3, 3), (1, 1), padding='SAME', act=tf.nn.relu, W_init=W_init, b_init=None, name='conv2_1')(nn)
nn = MaxPool2d((2, 2), (2, 2), padding='SAME', name='pool2_1')(nn)
nn = Conv2d(128, (3, 3), (1, 1), padding='SAME', act=tf.nn.relu, W_init=W_init, b_init=None, name='conv2_2')(nn)
nn = MaxPool2d((2, 2), (2, 2), padding='SAME', name='pool2_2')(nn)
nn = Conv2d(256, (3, 3), (1, 1), padding='SAME', act=tf.nn.relu, W_init=W_init, b_init=None, name='conv3_1')(nn)
nn = MaxPool2d((2, 2), (2, 2), padding='SAME', name='pool3_1')(nn)
nn = Conv2d(256, (3, 3), (1, 1), padding='SAME', act=tf.nn.relu, W_init=W_init, b_init=None, name='conv3_2')(nn)
nn = MaxPool2d((2, 2), (2, 2), padding='SAME', name='pool3_2')(nn)
nn = Conv2d(512, (3, 3), (1, 1), padding='SAME', act=tf.nn.relu, W_init=W_init, b_init=None, name='conv4_1')(nn)
nn = MaxPool2d((2, 2), (2, 2), padding='SAME', name='pool4_1')(nn)
nn = Conv2d(512, (3, 3), (1, 1), padding='SAME', act=tf.nn.relu, W_init=W_init, b_init=None, name='conv4_2')(nn)
nn = MaxPool2d((2, 2), (2, 2), padding='SAME', name='pool4_2')(nn)
nn = Flatten(name='flatten')(nn)
nn = Dense(1000, act=None, W_init=W_init2, name='output')(nn)
M = Model(inputs=ni, outputs=nn, name='cnn')
return M
def __init__(self, state_shape, action_shape, hidden_dim_list, w_init=tf.keras.initializers.glorot_normal(), \
activation=tf.nn.relu, output_activation=tf.nn.tanh, trainable=True):
""" Deterministic continuous policy network with multiple fully-connected layers or convolutional layers (according to state shape)
Args:
state_shape (tuple[int]): shape of the state, for example, (state_dim, ) for single-dimensional state
action_shape (tuple[int]): shape of the action, for example, (action_dim, ) for single-dimensional action
hidden_dim_list (list[int]): a list of dimensions of hidden layers
w_init (callable): weights initialization
activation (callable): activation function
output_activation (callable or None): output activation function
trainable (bool): set training and evaluation mode
"""
action_dim = action_shape[0]
if len(state_shape) == 1:
with tf.name_scope('MLP'):
state_dim = state_shape[0]
inputs, l = MLP(state_dim, hidden_dim_list, w_init, activation)
else:
with tf.name_scope('CNN'):
inputs, l = CNN(state_shape, conv_kwargs=None)
with tf.name_scope('Output'):
outputs = Dense(n_units=action_dim, act=output_activation, W_init=w_init)(l)
super().__init__(inputs=inputs, outputs=outputs)
if trainable:
self.train()
else:
self.eval()
def get_model(inputs_shape):
ni = Input(inputs_shape)
nn = Dropout(keep=0.8)(ni)
nn = Dense(n_units=800, act=tf.nn.relu, in_channels=784)(
nn
) # in_channels is optional in this case as it can be inferred by the previous layer
nn = Dropout(keep=0.8)(nn)
nn = Dense(n_units=800, act=tf.nn.relu, in_channels=800)(
nn
) # in_channels is optional in this case as it can be inferred by the previous layer
nn = Dropout(keep=0.8)(nn)
nn = Dense(n_units=10, act=tf.nn.relu, in_channels=800)(
nn
) # in_channels is optional in this case as it can be inferred by the previous layer
M = Model(inputs=ni, outputs=nn, name="mlp")
return M
