def baseline_model():
# create model
model = Sequential()
model.add(
Dense(
10,
input_dim=nf,
#kernel_regularizer=l2(0.01),
kernel_initializer=RandomUniform(minval=-np.sqrt(6 / nf),
maxval=np.sqrt(6 / nf),
seed=42)))
model.add(Activation('relu'))
model.add(
Dense(
7,
#kernel_regularizer=l2(0.01),
kernel_initializer=RandomUniform(minval=-np.sqrt(6 / 10),
maxval=np.sqrt(6 / 10),
seed=42)))
model.add(Activation('relu'))
model.add(
Dense(
nc,
#kernel_regularizer=l2(0.01),
kernel_initializer=TruncatedNormal(mean=0.0,
stddev=np.sqrt(2 / (nc + 7)),
seed=42)))
model.add(Activation('softmax'))
# Compile model
model.compile(loss='categorical_crossentropy',
optimizer=Adam(epsilon=1e-8),
metrics=['accuracy'])
return model
def build(self, input_shape):
input_dim = input_shape[-1]
expert_init_lim = np.sqrt(3.0 / (max(1.0, float(input_dim + self.units) / 2)))
gating_init_lim = np.sqrt(3.0 / (max(1.0, float(input_dim + 1) / 2)))
self.expert_kernel = self.add_weight(
shape=(input_dim, self.units, self.n_experts),
initializer=RandomUniform(minval=-expert_init_lim, maxval=expert_init_lim),
name="expert_kernel",
)
self.gating_kernel = self.add_weight(
shape=(input_dim, self.n_experts),
initializer=RandomUniform(minval=-gating_init_lim, maxval=gating_init_lim),
name="gating_kernel",
)
self.expert_bias = self.add_weight(
shape=(self.units, self.n_experts), initializer=Zeros, name="expert_bias"
)
self.gating_bias = self.add_weight(
shape=(self.n_experts,), initializer=Zeros, name="gating_bias"
)
super().build(input_shape)
def make_policy(l=7, board_size=s):
'''
creates players. l is the number of layers.
'''
model = Sequential()
model.add(
Conv2D(32,
kernel_size=2,
activation='relu',
padding='same',
input_shape=(2, board_size, board_size),
bias_initializer=RandomUniform(seed=1)))
for _ in range(l):
model.add(
Conv2D(64,
kernel_size=2,
padding='same',
activation='relu',
bias_initializer=RandomUniform()))
model.add(Flatten())
model.add(Dense(50, activation='relu', bias_initializer=RandomUniform()))
model.add(Dense(1, activation='sigmoid', bias_initializer=RandomUniform()))
model.compile(optimizer='adam', loss='mean_squared_error')
return model
def __init__(self):
super(ActorCritic, self).__init__()
self.day_layers = [
Conv2D(filters=32,
kernel_size=(5, 5),
strides=2,
padding='valid',
activation='relu',
input_shape=[1, 123, 5, 1]),
Conv2D(filters=16,
kernel_size=(4, 1),
strides=2,
padding='valid',
activation='relu'),
Conv2D(filters=8,
kernel_size=(3, 1),
strides=2,
padding='valid',
activation='relu'),
Flatten()
]
self.sec_layers = [
Dense(967, activation='relu'),
Dense(480, activation='relu'),
Dense(120, activation='relu')
]
self.shared_fc = Dense(120, activation='relu')
self.actor_mu = Dense(1, kernel_initializer=RandomUniform(-1e-3, 1e-3))
self.actor_sigma = Dense(1,
activation='sigmoid',
kernel_initializer=RandomUniform(-1e-3, 1e-3))
self.critic_out = Dense(1, activation='linear')
def build(self, input_shapes):
self.kernel1 = self.add_weight(name='kernel',
shape=(1, 1, self.actors_size, 1),
initializer=RandomUniform(minval=0,
maxval=1,
seed=None),
trainable=True,
constraint=NonNeg(),
dtype='float64')
self.kernel2 = self.add_weight(name='bias',
shape=(1, ),
initializer=RandomUniform(minval=0,
maxval=1,
seed=None),
trainable=True,
constraint=NonNeg(),
dtype='float64')
self.kernel3 = self.add_weight(name='beta',
shape=(1, ),
initializer=RandomUniform(minval=0,
maxval=1,
seed=None),
trainable=True,
constraint=NonNeg(),
dtype='float64')
def make_network(self):
obs_input = keras.Input(shape=self.obs_dim,
dtype="float32",
name="obs")
# layer 0 - with obs input
w_range = 1 / np.sqrt(self.obs_dim)
lr_0 = keras.layers.Dense(
400,
activation="relu",
name="a_lr_0",
kernel_initializer=RandomUniform(-w_range, w_range),
)(obs_input)
# layer 1
w_range = 1 / np.sqrt(400.0)
lr_1 = keras.layers.Dense(
300,
activation="relu",
name="a_lr_1",
kernel_initializer=RandomUniform(-w_range, w_range),
)(lr_0)
# action layer
w_range = 0.003
action = self.action_gain * keras.layers.Dense(
self.action_dim,
activation="tanh",
name="action",
kernel_initializer=RandomUniform(-w_range, w_range),
)(lr_1)
model = keras.Model(inputs=obs_input, outputs=action)
return model
def __init__(self, action_size):
super(A2C, self).__init__()
self.actor_fc = Dense(24, activation='tanh')
self.actor_out = Dense(action_size,
activation='softmax',
kernel_initializer=RandomUniform(-1e-3, 1e-3))
self.critic_fc1 = Dense(24, activation='tanh')
self.critic_fc2 = Dense(24, activation='tanh')
self.critic_out = Dense(1,
kernel_initializer=RandomUniform(-1e-3, 1e-3))
def creatDQN():
""" 创建DQN，DQN的输入是连续的4游戏画面，输出是状态动作值函数Q(s,a)。
即有几种状态，DQN就有几种输出，每一种输出对应采用相应动作后获得的回报。
DQN实际上就是一个深度卷积网络。
"""
model = tf.keras.Sequential()
# 添加第一个卷积层，输入为(80,80,4)【通道4是由于采用连续4帧游戏画面】
model.add(
layers.Conv2D(32, (8, 8),
strides=(4, 4),
use_bias=True,
input_shape=[80, 80, 4],
activation='relu',
padding='same',
kernel_initializer=RandomUniform()))
assert model.output_shape == (None, 20, 20, 32)
# 添加池化层
model.add(layers.MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
assert model.output_shape == (None, 10, 10, 32)
# 添加卷积层
model.add(
layers.Conv2D(64, (4, 4),
strides=(2, 2),
use_bias=True,
activation='relu',
padding='same',
kernel_initializer=RandomUniform()))
assert model.output_shape == (None, 5, 5, 64)
model.add(
layers.Conv2D(64, (3, 3),
strides=1,
use_bias=True,
activation='relu',
padding='same',
kernel_initializer=RandomUniform()))
assert model.output_shape == (None, 5, 5, 64)
# 将输出拉平
model.add(layers.Flatten())
# 添加全连接层
model.add(
layers.Dense(512,
use_bias=True,
activation='relu',
kernel_initializer=RandomUniform()))
# 添加输出层
model.add(
layers.Dense(ACTIONS,
use_bias=True,
kernel_initializer=RandomUniform()))
assert model.output_shape == (None, 2)
model.compile(
loss='mse',
optimizer=tf.keras.optimizers.Adam(learning_rate=LEARNING_RATE))
return model
def init_critic_network(self):
critic_model = tf.keras.Sequential()
if self.isMujoco:
critic_model.add(Dense(512, input_shape=self.state_dim, activation='relu', kernel_initializer=RandomUniform(seed=69)))
critic_model.add(Dense(256, activation='relu', kernel_initializer=RandomUniform(seed=69)))
critic_model.add(Dense(256, activation='relu', kernel_initializer=RandomUniform(seed=69)))
critic_model.add(Dense(128, activation='relu', kernel_initializer=RandomUniform(seed=69)))
else:
critic_model.add(Dense(128, input_shape=self.state_dim, activation='relu', kernel_initializer=RandomUniform(seed=69)))
critic_model.add(Dense(64, activation='relu', kernel_initializer=RandomUniform(seed=69)))
critic_model.add(Dense(1, activation = 'linear', kernel_initializer=RandomUniform(seed=69)))
return critic_model
def init_actor_network(self):
actor_model = tf.keras.Sequential()
if self.isMujoco:
actor_model.add(Dense(512, input_shape=self.state_dim, activation='relu', kernel_initializer=RandomUniform(seed=69)))
actor_model.add(Dense(256, activation='relu', kernel_initializer=RandomUniform(seed=69)))
actor_model.add(Dense(256, activation='relu', kernel_initializer=RandomUniform(seed=69)))
actor_model.add(Dense(128, activation='relu', kernel_initializer=RandomUniform(seed=69)))
else:
actor_model.add(Dense(128, input_shape=self.state_dim, activation='relu', kernel_initializer=RandomUniform(seed=69)))
actor_model.add(Dense(64, activation='relu', kernel_initializer=RandomUniform(seed=69)))
actor_model.add(Dense(self.action_dim, activation = 'tanh', kernel_initializer=RandomUniform(seed=69)))
return actor_model
def __init__(self, action_size):
super(ContinuousA2C, self).__init__()
self.actor_fc1 = Dense(24, activation='tanh')
self.actor_mu = Dense(action_size,
kernel_initializer=RandomUniform(-1e-3, 1e-3))
self.actor_sigma = Dense(action_size,
activation='sigmoid',
kernel_initializer=RandomUniform(-1e-3, 1e-3))
self.critic_fc1 = Dense(24, activation='tanh')
self.critic_fc2 = Dense(24, activation='tanh')
self.critic_out = Dense(1,
kernel_initializer=RandomUniform(-1e-3, 1e-3))
def combine_features(input_uid, input_iid, feas_u, feas_i, user_num, item_num,
n_latent, random_seed):
"""
Combine the review features and user/item latent vectors
Args:
-------
input_uid: user's id
input_iid: item's id
feas_u: weighted sum of user's reviews
feas_i: weighted sum of item's reviews
other_args: model parameters
Outputs:
-------
: latent representation for user and item modeling
"""
vec_uid = Embedding(user_num + 2,
n_latent,
embeddings_initializer=RandomUniform(minval=-0.1,
maxval=0.1,
seed=random_seed),
name='user_id_latent')(input_uid)
vec_iid = Embedding(item_num + 2,
n_latent,
embeddings_initializer=RandomUniform(minval=-0.1,
maxval=0.1,
seed=random_seed),
name='item_id_latent')(input_iid)
vec_uid = tf.reshape(vec_uid, [-1, vec_uid.shape[-1]])
vec_iid = tf.reshape(vec_iid, [-1, vec_iid.shape[-1]])
t_u = Dense(n_latent,
activation=None,
use_bias=True,
kernel_initializer='glorot_uniform',
bias_initializer='zeros',
name='user_rev_latent')(feas_u)
t_i = Dense(n_latent,
activation=None,
use_bias=True,
kernel_initializer='glorot_uniform',
bias_initializer='zeros',
name='item_rev_latent')(feas_i)
# Merge the latent vectors for reviews and IDs
f_u = Add(name='user_latent')([vec_uid, t_u])
f_i = Add(name='item_latent')([vec_iid, t_i])
return f_u, f_i
def build(self, input_shape):
assert len(input_shape) >= 2
input_dim = input_shape[-1]
expert_init_lim = np.sqrt(3.0 * self.expert_kernel_initializer_scale /
(max(1.,
float(input_dim + self.units) / 2)))
gating_init_lim = np.sqrt(3.0 * self.gating_kernel_initializer_scale /
(max(1.,
float(input_dim + 1) / 2)))
self.expert_kernel = self.add_weight(
shape=(input_dim, self.units, self.n_experts),
initializer=RandomUniform(minval=-expert_init_lim,
maxval=expert_init_lim),
name='expert_kernel',
regularizer=self.expert_kernel_regularizer,
constraint=self.expert_kernel_constraint)
self.gating_kernel = self.add_weight(
shape=(input_dim, self.n_experts),
initializer=RandomUniform(minval=-gating_init_lim,
maxval=gating_init_lim),
name='gating_kernel',
regularizer=self.gating_kernel_regularizer,
constraint=self.gating_kernel_constraint)
if self.use_expert_bias:
self.expert_bias = self.add_weight(
shape=(self.units, self.n_experts),
initializer=self.expert_bias_initializer,
name='expert_bias',
regularizer=self.expert_bias_regularizer,
constraint=self.expert_bias_constraint)
else:
self.expert_bias = None
if self.use_gating_bias:
self.gating_bias = self.add_weight(
shape=(self.n_experts, ),
initializer=self.gating_bias_initializer,
name='gating_bias',
regularizer=self.gating_bias_regularizer,
constraint=self.gating_bias_constraint)
else:
self.gating_bias = None
self.input_spec = InputSpec(min_ndim=2, axes={-1: input_dim})
self.built = True
def Linear(in_channels, out_channels, act=None, kernel_init=None, bias_init=None):
kernel_initializer = kernel_init or VarianceScaling(1.0 / 3, 'fan_in', 'uniform')
bound = math.sqrt(1 / in_channels)
bias_initializer = bias_init or RandomUniform(-bound, bound)
return Dense(out_channels, activation=act,
kernel_initializer=kernel_initializer,
bias_initializer=bias_initializer)
def __init__(
self,
arch_params={},
patch_size=None,
c_dim=3,
kernel_size=3,
upscaling='ups',
init_extreme_val=0.05,
):
self.params = arch_params
self.C = self.params['C']
self.D = self.params['D']
self.G = self.params['G']
self.G0 = self.params['G0']
self.scale = self.params['x']
self.patch_size = patch_size
self.c_dim = c_dim
self.kernel_size = kernel_size
self.upscaling = upscaling
self.initializer = RandomUniform(minval=-init_extreme_val,
maxval=init_extreme_val,
seed=None)
self.model = self._build_rdn()
self.model._name = 'generator'
self.name = 'rdn'
def __init__(self,
number_cluster,
initializer=RandomUniform(0.0, 1.0),
**kwargs):
self.number_cluster = number_cluster
self.initializer = initializer
super(RBFLayer, self).__init__(**kwargs)
def __init__(self,
output_dim=1,
kernel_size=(5, 5),
strides=(1, 1),
radius_min=2,
radius_max=3,
initializer='uniform',
use_bias=True): #, output_dim):
self.output_dim = output_dim
self.kernel_size = kernel_size
self.radius_min = radius_min
self.radius_max = radius_max
self.strides = strides
self.use_bias = use_bias
xx = np.arange(-(kernel_size[0] - 1) // 2, (kernel_size[0] + 1) // 2)
yy = np.arange(-(kernel_size[0] - 1) // 2, (kernel_size[0] + 1) // 2)
[XX, YY] = np.meshgrid(xx, yy)
R = np.sqrt(XX**2 + YY**2)
R[R < radius_min] = 0
R[R > radius_max] = 0
R[R > 0] = 1
self.mask = R # the mask defines the non-zero pattern and will multiply the weights
if initializer == 'uniform':
self.initializer = RandomUniform(minval=0, maxval=2 / R.sum())
else:
self.initializer = initializer
super(Masked_Conv2D, self).__init__()
def __init__(self,
arch_params={},
patch_size=None,
c_dim=3,
kernel_size=3,
upscaling='ups',
init_extreme_val=0.05,
weights=''):
if weights:
arch_params, c_dim, kernel_size, upscaling, url, fname = get_network(
weights)
self.params = arch_params
self.C = self.params['C']
self.D = self.params['D']
self.G = self.params['G']
self.G0 = self.params['G0']
self.scale = self.params['x']
self.patch_size = patch_size
self.c_dim = c_dim
self.kernel_size = kernel_size
self.upscaling = upscaling
self.initializer = RandomUniform(minval=-init_extreme_val,
maxval=init_extreme_val,
seed=None)
self.model = self._build_rdn()
self.model._name = 'generator'
self.name = 'rdn'
if weights:
weights_path = tf.keras.utils.get_file(fname=fname, origin=url)
self.model.load_weights(weights_path)
print("YOOOOO " + weights_path)
def make_actor(state_shape: Tuple[int, ...], action_shape: Tuple[int, ...],
scope_name: str) -> Model:
with tf.variable_scope(scope_name):
final_initializer = RandomUniform(-3e-3, 3e-3)
initializer = VarianceScaling(scale=1 / 3, mode='fan_in')
state_input = Input(shape=state_shape)
temp = Flatten()(state_input)
temp = BatchNormalization()(temp)
temp = Dense(400,
activation='relu',
kernel_initializer=initializer,
bias_initializer=initializer)(temp)
temp = BatchNormalization()(temp)
temp = Dense(300,
activation='relu',
kernel_initializer=initializer,
bias_initializer=initializer)(temp)
temp = BatchNormalization()(temp)
temp = Dense(sum(action_shape),
activation='tanh',
kernel_initializer=final_initializer,
bias_initializer=final_initializer)(temp)
output = Reshape(action_shape, name='action')(temp)
model = Model(inputs=state_input, outputs=output, name='actor')
model.compile(optimizer=Adam(1e-4), loss='mean_squared_error')
return model
def build_model(self):
''' Build the Neural Net for Deep-Q learning Model.
Convolutional layers with Batch Norm followed by dense layers.'''
# Define input layer (states)
states = Input(shape=self.state_size)
# Input layer is 25x25x2
net = Conv2D(8, (3, 3),
strides=(1, 1),
activation='relu',
padding='same',
kernel_initializer='glorot_uniform')(states)
#net = BatchNormalization(fused=False)(net)
#net = Conv2D(16, (3, 3), strides=(1, 1), activation='relu', padding='same', kernel_initializer='glorot_uniform')(net)
#net = BatchNormalization(fused=False)(net)
#net = Conv2D(32, (3, 3), strides=(1, 1), activation='relu', padding='same', kernel_initializer='glorot_uniform')(net)
#net = BatchNormalization(fused=False)(net)
# Now 25x25x8
actions = Conv2D(1, (3, 3),
strides=(1, 1),
activation='tanh',
padding='same',
kernel_initializer=RandomUniform(-5e-4, 5e-4),
kernel_regularizer=regularizers.l2(0.0001))(net)
# Create Keras model
self.model = Model(inputs=states, outputs=actions, name=self.name)
def build(self, input_shape=None):
self.input_spec = InputSpec(shape=input_shape)
if not self.layer.built:
self.layer.build(input_shape)
self.layer.built = True
super(ConcreteDropout, self).build(
) # this is very weird.. we must call super before we add new losses
# initialise p
self.p_logit = self.layer.add_weight(name='p_logit',
shape=(1, ),
initializer=RandomUniform(
self.init_min, self.init_max),
trainable=True)
self.p = K.sigmoid(self.p_logit[0])
# initialise regulariser / prior KL term
input_dim = np.prod(input_shape[1:]) # we drop only last dim
weight = self.layer.kernel
kernel_regularizer = self.weight_regularizer * K.sum(
K.square(weight)) / (1. - self.p)
dropout_regularizer = self.p * K.log(self.p)
dropout_regularizer += (1. - self.p) * K.log(1. - self.p)
dropout_regularizer *= self.dropout_regularizer * input_dim
regularizer = K.sum(kernel_regularizer + dropout_regularizer)
self.layer.add_loss(regularizer)
def build(self, input_shape):
self.stars = self.add_weight(name='stars',
shape=(self.output_dim, input_shape[2]),
initializer=RandomUniform(minval=-1,
maxval=1),
trainable=True)
super(MyUrsaGau, self).build(input_shape)
def dyke_dqn_agent(env: TFPyEnvironment,
layers: Optional[List[Layer]] = None) -> DqnAgent:
"""
Prepares a deep Q-network (DQN) agent for use in the dyke maintenance environment.
:param env: The dyke environment on which to base the DQN agent.
:param layers: Optional. A list of layers to supply to the DQN agent's network.
:return: The agent.
"""
layers = fully_connected_dyke_dqn_agent_network(
sizes=(100, 50)) if layers is None else layers
# prepare the Q-values layer
action_as: BoundedArraySpec = from_spec(env.action_spec())
number_actions: int = int(action_as.maximum - action_as.minimum + 1)
q_values_layer: Layer = Dense(units=number_actions,
activation=None,
kernel_initializer=RandomUniform(
minval=-3e-3, maxval=3e-3),
bias_initializer=Constant(-2e-1))
net = Sequential(layers=layers + [q_values_layer])
# instantiate and return the agent
optimizer = Adam(learning_rate=1e-3)
train_step_counter = Variable(initial_value=0)
return DqnAgent(time_step_spec=env.time_step_spec(),
action_spec=env.action_spec(),
q_network=net,
optimizer=optimizer,
epsilon_greedy=0.1,
td_errors_loss_fn=element_wise_squared_loss,
train_step_counter=train_step_counter)
def __init__(self, action_size):
super(DQN, self).__init__()
self.dense1 = Dense(units=32, activation='relu')
self.dense2 = Dense(units=64, activation='relu')
self.dense3 = Dense(units=64, activation='relu')
self.output_layer = Dense(units=action_size,
kernel_initializer=RandomUniform(
-1e-3, 1e-3))
def __init__(self, num_outputs, initializer=None, betas=1.0, **kwargs):
self.num_outputs = num_outputs
self.init_betas = betas
if not initializer:
self.initializer = RandomUniform(0.0, 1.0)
else:
self.initializer = initializer
super(RBFLayer, self).__init__(**kwargs)
def build_model(self):
# Feed-forward NN
model = tf.keras.Sequential()
init = RandomUniform(minval=-0.5, maxval=0.5)
model.add(layers.Dense(30, input_dim=self.state_size, activation='sigmoid', kernel_initializer=init))
model.add(layers.Dense(36, activation='sigmoid', kernel_initializer=init))
model.compile(loss='mse', optimizer=SGD(lr=self.learning_rate))
return model
def __init__(self, output_dim, initializer=None, betas=1.0, **kwargs):
self.output_dim = output_dim
self.init_betas = betas
if not initializer:
self.initializer = RandomUniform(0.0, 1.0)
else:
self.initializer = initializer
super(RBFLayer, self).__init__(**kwargs)
def __init__(self,
observation_spec,
action_spec,
preprocessing_layers=None,
preprocessing_combiner=None,
conv_layer_params=None,
fc_layer_params=(75, 40),
dropout_layer_params=None,
activation_fn=relu,
enable_last_layer_zero_initializer=False,
name="ActorCritic"):
super(ActorCritic, self).__init__(input_tensor_spec=observation_spec,
state_spec=(),
name=name)
self._action_spec = action_spec
flat_action_spec = nest.flatten(action_spec)
if len(flat_action_spec) > 1:
raise ValueError(
'Only a single action is supported by this network')
self._single_action_spec = flat_action_spec[0]
kernel_initializer = RandomUniform(minval=-0.003, maxval=0.003)
self._encoder = EncodingNetwork(
observation_spec,
preprocessing_layers=preprocessing_layers,
preprocessing_combiner=preprocessing_combiner,
conv_layer_params=conv_layer_params,
fc_layer_params=fc_layer_params,
dropout_layer_params=dropout_layer_params,
activation_fn=activation_fn,
kernel_initializer=kernel_initializer,
batch_squash=False)
initializer = RandomUniform(minval=-0.003, maxval=0.003)
self._action_projection_layer = Dense(
flat_action_spec[0].shape.num_elements(),
activation=tanh,
kernel_initializer=initializer,
name='action')
def generator_model(noise_dim, feature_dim):
noise_input = keras.layers.Input(shape=(noise_dim,))
eeg_input = keras.layers.Input(shape=(feature_dim,))
x = MoGLayer(kernel_initializer=RandomUniform(minval=-0.2, maxval=0.2),
bias_initializer=RandomUniform(minval=-1.0, maxval=1.0), kernel_regularizer=l2(0.01))(noise_input)
x = keras.layers.concatenate([x, eeg_input])
x = Dense(1024, activation="tanh")(x)
x = BatchNormalization(momentum=0.8)(x)
x = Dense(128 * 7 * 7, activation="tanh")(x)
x = Reshape((7, 7, 128))(x)
x = UpSampling2D()(x)
x = BatchNormalization(momentum=0.8)(x)
x = Conv2D(64, kernel_size=5, padding="same", activation="tanh")(x)
x = UpSampling2D()(x)
x = Conv2D(1, kernel_size=3, padding="same")(x)
output = Activation("tanh")(x)
return Model(inputs=[noise_input, eeg_input], outputs=[output])
def __init__(self, env_dim, act_range):
super(ActorModel, self).__init__()
self.b1 = layers.BatchNormalization(center=True, scale=True, input_shape=(None, 13))
self.d1 = layers.Dense(400, activation='relu')
self.b2 = layers.BatchNormalization(center=True, scale=True)
# self.f = layers.Flatten()
self.d2 = layers.Dense(300, activation='relu')
self.b3 = layers.BatchNormalization(center=True, scale=True)
# self.g2 = layers.GaussianNoise(1.0) #
self.out_layer = layers.Dense(4, activation='tanh', kernel_initializer=RandomUniform(minval=-0.003, maxval=0.003))
self.act_range = act_range