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