def convolutional_block_attention_module(inputs, hidden_size=16, conv_size=7):
# CBAM：通道注意力+像素注意力
ca = channel_attention(inputs, hidden_size)
x = layers.Multiply(name='channel_attention_x')([inputs, ca])
sa = spatial_attention(x, conv_size)
x = layers.Multiply(name='spatial_attention_x')([x, sa])
return x
def fusionnetPos(y):
y, inTensor1, inTensor2 = y
# # crop the input images to the same size as network output.
# inCrop1 = layers.Cropping2D(cropping=((8, 8), (8, 8)))(inTensor1)
# inCrop2 = layers.CroppinimgIdx = 9
# fig=plt.figure(figsize=(12, 12))
# columns = 6
# rows = 1
# fig.add_subplot(rows, columns, 1)
# plt.imshow(x_test1[imgIdx, :, :, :])
# fig.add_subplot(rows, columns, 2)
# plt.imshow(x_test2[imgIdx, :, :, :])
# fig.add_subplot(rows, columns, 3)
# plt.imshow(mask_test[imgIdx, :, :, 0])
# fig.add_subplot(rows, columns, 4)
# plt.imshow((layer_output[imgIdx, :, :, 0]+1)/2)
# fig.add_subplot(rows, columns, 5)
# plt.imshow((prediction[imgIdx, :, :, :]+1)/2)
# fig.add_subplot(rows, columns, 6)
# plt.imshow(y_test[imgIdx, :, :, :])
# plt.show()
# # fig.savefig(dataPath+"results/struc_loss{:.2E}.png".format(lambda_tv))g2D(cropping=((8, 8), (8, 8)))(inTensor2)
y = K.tile(y, [1, 1, 1, 3])
y1 = layers.Multiply()([inTensor1, (1 + y) / 2])
y2 = layers.Multiply()([inTensor2, 1 - (1 + y) / 2])
y = layers.Add()([y1, y2])
return y
def dual_domain_block(x, nFilters, Pyramid_Cells, nPyramidFilters, qy, qc,
Restriction):
_t = pyramid(x, nPyramidFilters, Pyramid_Cells)
_ty = conv(_t, nFilters, 3)
_tc = conv(_t, nFilters, 3, dilation_rate=2)
if Restriction == 'RaRe':
_ty = RaRe(r=0.75)(_ty)
_tc = RaRe(r=0.75)(_tc)
if Restriction == 'soft':
_ty = SoftThreshing(th=0.5)(_ty)
_tc = SoftThreshing(th=0.5)(_tc)
if Restriction == 'hard':
_ty = HardThreshing(th=0.5)(_ty)
#_tc = HardThreshing(th=0.75)(_tc)
_ty = layers.Multiply()([_ty, qy])
_tc = layers.Multiply()([_tc, qc])
_ty = IDCT(True)(_ty)
_tc = IDCT(True)(_tc)
_tp = conv(_t, nFilters, 3)
_td = layers.Concatenate(axis=-1)([_ty, _tc])
_td = conv(_td, nFilters, 3)
y = layers.Add()([_td, _tp])
#y = conv(_t, nFilters, 3)
y = layers.Lambda(lambda x: x * 0.1)(y)
y = layers.Add()([x, y])
return y
def compare_and_score(self, left, right, ent, feats):
""" Final layer of the compiled model
Concatenates several comparisons between the vectors of left and right
contexts and the entity vector.
Final dense layer takes all of these comparisons, and the final feature
vector, and outputs a binary prediction.
"""
comparisons = []
left_dot = layers.Dot(axes=1, normalize=True)([left, ent])
right_dot = layers.Dot(axes=1, normalize=True)([right, ent])
comparisons += [left_dot, right_dot]
left_diff = layers.Subtract()([left, ent])
right_diff = layers.Subtract()([right, ent])
comparisons += [left_diff, right_diff]
left_diff_sq = layers.Multiply()([left_diff, left_diff])
right_diff_sq = layers.Multiply()([right_diff, right_diff])
comparisons += [left_diff_sq, right_diff_sq]
left_mult = layers.Multiply()([left, ent])
right_mult = layers.Multiply()([right, ent])
comparisons += [left_mult, right_mult]
if feats is not None:
comparisons.append(feats)
comparisons_concat = layers.Concatenate(axis=1)(comparisons)
out = self.reduce_layer(comparisons_concat)
return out
def grouped_convolution(y, nb_channels, _strides):
# when `cardinality` == 1 this is just a standard convolution
if cardinality == 1:
return layers.Conv2D(nb_channels,
kernel_size=(3, 3),
strides=_strides,
padding='same')(y)
assert not nb_channels % cardinality
_d = nb_channels // (cardinality)
# in a grouped convolution layer, input and output channels are divided into `cardinality` groups,
# and convolutions are separately performed within each group
groups = []
attn1 = []
attn2 = []
skip1 = []
skip2 = []
for j in range(cardinality):
group = layers.Lambda(lambda z: z[:, :, :, j * _d:j * _d + _d])(y)
if j == 0:
attn1 = attention_block(group, _d, _strides)
if j == 1:
skip1 = skip_block(group, _d, _strides)
if j == 2:
attn2 = attention_block(group, _d, _strides)
if j == 3:
skip2 = skip_block(group, _d, _strides)
skip1 = layers.Multiply()([skip1, attn1])
y_1 = layers.Conv2D(_d * 2,
kernel_size=(1, 1),
strides=(1, 1),
padding='same')(skip1)
y_1 = add_common_layers(y_1)
skip2 = layers.Multiply()([skip2, attn2])
y_2 = layers.Conv2D(_d * 2,
kernel_size=(1, 1),
strides=(1, 1),
padding='same')(skip2)
y_2 = add_common_layers(y_2)
groups.append(y_1)
groups.append(y_2)
# the grouped convolutional layer concatenates them as the outputs of the layer
y = layers.concatenate(groups)
return y
def fusionnetPos(y):
y, inTensor1, inTensor2 = y
# crop the input images to the same size as network output.
inCrop1 = layers.Cropping2D(cropping=((8, 8), (8, 8)))(inTensor1)
inCrop2 = layers.Cropping2D(cropping=((8, 8), (8, 8)))(inTensor2)
# y1, y2 = tf.split(y, [1, 1], axis = 3)
# extend y1&y2 dimension to 3, consistant to color channels
y1 = y[:, :, :, :1]
y2 = y[:, :, :, 1:]
y1 = K.tile(y1, [1, 1, 1, 3])
y2 = K.tile(y2, [1, 1, 1, 3])
y1 = layers.Multiply()([inCrop1, y1])
y2 = layers.Multiply()([inCrop2, y2])
y = layers.Add()([y1, y2])
return y
def mul_layer(back_layer, last):
back = back_layer.output
upsample = layers.UpSampling2D((2, 2))(last)
to1024 = layers.Conv2D(
int(back.shape[3]), (1, 1), activation='relu')(upsample)
mul = layers.Multiply()([back, to1024])
return mul, layers.Conv2D(1, (1, 1), activation='sigmoid')(mul)
def self_Att_channel(x,x_att,r = 16,name = '1'):
'''
advanced
Hu, Jie, Li Shen, and Gang Sun."Squeeze-and-excitation networks." arXiv preprintarXiv:1709.01507 (2017).
:param x:
:param r:
:return:
'''
x_self = x
chanel = K.int_shape(x)[-1]
L = K.int_shape(x)[-2]
x_att = layers.GlobalAveragePooling1D(name='self_avg_pool' + name )(x_att)
# x_att = layers.Conv2D(chanel,
# (H,W),
# padding='valid',
# use_bias=None,
# name='FCN' + name)(x_att)
x_att = layers.Dense(int(chanel / r),activation='relu')(x_att)
x_att = layers.Dense(chanel, activation='sigmoid')(x_att)
x = layers.Multiply()([x_self,x_att])
return x
def atari_model():
# With the functional API we need to define the inputs.
frames_input = layers.Input(ATARI_SHAPE, name='frames')
actions_input = layers.Input((ACTION_SIZE, ), name='action_mask')
# Assuming that the input frames are still encoded from 0 to 255. Transforming to [0, 1].
normalized = layers.Lambda(lambda x: x / 255.0,
name='normalization')(frames_input)
# "The first hidden layer convolves 16 8×8 filters with stride 4 with the input image and applies a rectifier nonlinearity."
conv_1 = layers.convolutional.Conv2D(16, (8, 8),
strides=(4, 4),
activation='relu')(normalized)
# "The second hidden layer convolves 32 4×4 filters with stride 2, again followed by a rectifier nonlinearity."
conv_2 = layers.convolutional.Conv2D(32, (4, 4),
strides=(2, 2),
activation='relu')(conv_1)
# Flattening the second convolutional layer.
conv_flattened = layers.core.Flatten()(conv_2)
# "The final hidden layer is fully-connected and consists of 256 rectifier units."
hidden = layers.Dense(256, activation='relu')(conv_flattened)
# "The output layer is a fully-connected linear layer with a single output for each valid action."
output = layers.Dense(ACTION_SIZE)(hidden)
# Finally, we multiply the output by the mask!
filtered_output = layers.Multiply(name='QValue')([output, actions_input])
model = Model(inputs=[frames_input, actions_input],
outputs=filtered_output)
model.summary()
optimizer = RMSprop(lr=FLAGS.learning_rate, rho=0.95, epsilon=0.01)
# model.compile(optimizer, loss='mse')
# to changed model weights more slowly, uses MSE for low values and MAE(Mean Absolute Error) for large values
model.compile(optimizer, loss=huber_loss)
return model
def add_action_mask_layer(final, frames_input, num_actions):
actions_input = layers.Input((num_actions, ), name='action_mask')
filtered_output = layers.Multiply(name='QValue')(
[final, actions_input])
model = Model(inputs=[frames_input, actions_input],
outputs=filtered_output)
return model
def build(txt_shape,
img_shape,
max_len=400,
filters=250,
act_1=None,
act_2=None,
loss_function=mAP.my_loss):
K.clear_session()
word_index, embedding_matrix = loading()
input_text = layers.Input(shape=(None, ), dtype='int32')
input_image = layers.Input(shape=(img_shape, ))
embeddings = layers.Embedding(len(word_index) + 1,
128,
weights=[embedding_matrix],
input_length=max_len,
trainable=True)(input_text)
filter_sizes, convs = [2, 3, 4, 5], []
for fsz in filter_sizes:
conv1 = layers.Conv1D(filters, kernel_size=fsz,
activation='tanh')(embeddings)
pool1 = layers.MaxPooling1D(max_len - fsz + 1)(conv1)
pool1 = layers.Flatten()(pool1)
convs.append(pool1)
merge = layers.Concatenate(1)(convs)
text_embedding = layers.Dropout(0.5)(merge)
text_dense = layers.Dense(512, activation=act_1)(text_embedding)
image_dense = layers.Dense(512, activation=act_1)(input_image)
mul = layers.Multiply()([text_dense, image_dense])
pred = layers.Dense(1, activation=act_2)(mul)
model = Model(inputs=[input_text, input_image], outputs=pred)
model.compile(loss=loss_function, optimizer='adam', metrics=[mAP.auc])
model.summary()
return model
def call(self, input_xs): # Defines the computation from inputs to outputs
channel_refined_feature = self.channel_attention(input_xs)
spatial_attention_feature = self.spatial_attention(
channel_refined_feature)
refined_feature = KL.Multiply()(
[channel_refined_feature, spatial_attention_feature])
return KL.Add()([refined_feature, input_xs])
def build_model(self):
if self.mod_name == 'ddqn':
#dueling DQN implementation
frames_input, actions_input = layers.Input(self.frame_size, name='frames'), layers.Input((self.action_size,), name='action')
#normalization layer
normalized = layers.Lambda(lambda x: x / 255.0, name='normalization')(frames_input)
#same conv as dqn
conv_1 = layers.convolutional.Conv2D(16, (8, 8), strides=(4, 4), activation='relu')(normalized)
conv_2 = layers.convolutional.Conv2D(32, (4, 4), strides=(2, 2), activation='relu')(conv_1)
flattened = layers.core.Flatten()(conv_2)
#advantage and value layers
fullycon1 = layers.Dense(256)(flattened)
advantage = layers.Dense(self.action_size)(fullycon1)
fullycon2 = layers.Dense(256)(flattened)
value = layers.Dense(1)(fullycon2)
# print(value)
output = layers.merge([advantage, value], mode = lambda x: x[0]-K.mean(x[0])+x[1], output_shape = (self.action_size,))
#filter outputs for q values
model = Model(inputs=[frames_input, actions_input], outputs=layers.Multiply(name='Q')([output, actions_input]))
model.summary()
#allow the selection of adam as optimizer
if self.optimizer == 'adam':
optimizer = Adam(lr=self.lr, beta_1=0.9, beta_2=0.999)
elif self.optimizer == 'rmsprop':
optimizer = RMSprop(lr=self.lr, rho=0.95, epsilon=0.01)
#compiling model with customized huber loss
model.compile(optimizer, loss=clipping)
return model
def my_global_attention_upsample(x_high, x_low):
low_shape = K.int_shape(x_low)
x_low_mask = layers.Conv2D(low_shape[-1],
kernel_size=3,
padding='same',
use_bias=False)(x_low)
x_low_mask = layers.BatchNormalization()(x_low_mask)
x_high_gp = SpatialReduceLayer(mode='avg')(x_high)
x_high_gp = layers.Conv2D(low_shape[-1], kernel_size=1,
use_bias=False)(x_high_gp)
x_high_gp = layers.BatchNormalization()(x_high_gp)
x_high_gp = layers.Activation('relu')(x_high_gp)
x_high_gp = ResizeImageLayer(target_size=(low_shape[1],
low_shape[2]))(x_high_gp)
x_att = layers.Multiply()([x_high_gp, x_low_mask])
x_h = layers.Conv2D(low_shape[-1], kernel_size=1, use_bias=False)(x_high)
x_h = layers.BatchNormalization()(x_h)
x = layers.Add()([x_h, x_att])
x = layers.Activation('relu')(x)
return x
def layer(input_tensor):
x = kl.Conv2D(1, (1, 1),
kernel_initializer="he_normal",
activation='sigmoid',
use_bias=False)(input_tensor)
x = kl.Multiply()([input_tensor, x])
return x
def identity_block(X, f, filters, stage, block):
block_name = str(stage) + "_" + str(block)
conv_name_base = 'res' + str(stage) + block + '_branch'
bn_name_base = 'bn' + str(stage) + block + '_branch'
F1, F2, F3 = filters
X_shortcut = X
X = layers.Conv2D(filters=F1, kernel_size=(1,1), strides=(1,1), padding='valid',
name=conv_name_base + '2a', kernel_initializer=glorot_uniform(seed=0))(X)
X = layers.BatchNormalization(axis=3, name=bn_name_base + '2a')(X)
X = layers.Activation('relu')(X)
X = layers.Conv2D(filters=F2, kernel_size=(f,f), strides=(1,1), padding='same',
name=conv_name_base + '2b', kernel_initializer=glorot_uniform(seed=0))(X)
X = layers.BatchNormalization(axis=3, name=bn_name_base + '2b')(X)
X = layers.Activation('relu')(X)
X = layers.Conv2D(filters=F3, kernel_size=(1,1), strides=(1,1), padding='valid',
name=conv_name_base + '2c', kernel_initializer=glorot_uniform(seed=0))(X)
X = layers.BatchNormalization(axis=3, name=bn_name_base + '2c')(X)
se = layers.GlobalAveragePooling2D(name='pool' + block_name + '_gap')(X)
se = layers.Dense(F3 // 16, activation='relu', name = 'fc' + block_name + '_sqz')(se)
se = layers.Dense(F3, activation='sigmoid', name = 'fc' + block_name + '_exc')(se)
se = layers.Reshape([1, 1, F3])(se)
X = layers.Multiply(name='scale' + block_name)([X, se])
X = layers.Add()([X, X_shortcut])
X = layers.Activation('relu')(X)
return X
def call(self, inputs):
if len(inputs) == 2:
dec, enc = inputs
masks = None
elif len(inputs) == 3:
dec, enc, masks = inputs
q = kl.Dense(self.filters_q, use_bias=True)(dec)
q = kl.Activation(activation)(q)
# q = kl.tanh(alpha=1.0)(q)
k = kl.Dense(self.filters_k, use_bias=True)(enc)
k = kl.Activation(activation)(k)
# k = kl.tanh(alpha=1.0)(k)
v = kl.Dense(self.filters_v, use_bias=True)(enc)
v = kl.Activation(activation)(v)
# v = kl.tanh(alpha=1.0)(v)
# print('q.shape,k.shape,v.shape,',q.shape,k.shape,v.shape)
beta = K.batch_dot(q, K.permute_dimensions(k,
(0, 2, 1))) # # [bs, N, M]
if masks is not None:
# print('apply padding')
beta = kl.Multiply()([beta, masks])
scores = K.softmax(beta, axis=-1) # attention map
o = K.batch_dot(scores, v) # [bs, N, C]
self.q_sh = tuple(q.shape.as_list())
self.k_sh = tuple(k.shape.as_list())
self.v_sh = tuple(v.shape.as_list())
self.beta_sh = tuple(beta.shape.as_list())
self.scores_sh = tuple(scores.shape.as_list())
self.o_sh = tuple(o.shape.as_list())
return [q, k, v, beta, scores, o]
def atari_model_mask():
# With the functional API we need to define the inputs.
frames_input = layers.Input(ATARI_SHAPE, name='frames')
actions_input = layers.Input((ACTION_SIZE,), name='action_mask') # Masking!
# TODO: Do normalisation outside of tensorflow (since we're not computing gradients etc) - only use the ML framework
# when you actually need to.
# Assuming that the input frames are still encoded from 0 to 255. Transforming to [0, 1].
normalized = layers.Lambda(lambda x: x / 255.0, name='normalization')(frames_input)
# "The first hidden layer convolves 16 8×8 filters (stride 4) with the input & applies a rectifier nonlinearity."
conv_1 = layers.convolutional.Conv2D(
16, (8, 8), strides=(4, 4), activation='relu')(normalized)
# "The second hidden layer convolves 32 4×4 filters with stride 2, again followed by a rectifier nonlinearity."
conv_2 = layers.convolutional.Conv2D(
32, (4, 4), strides=(2, 2), activation='relu')(conv_1)
# Flattening the second convolutional layer.
conv_flattened = layers.core.Flatten()(conv_2)
# "The final hidden layer is fully-connected and consists of 256 rectifier units."
hidden = layers.Dense(256, activation='relu')(conv_flattened)
# "The output layer is a fully-connected linear layer with a single output for each valid action."
output = layers.Dense(ACTION_SIZE)(hidden)
# Finally, we multiply the output by the mask!
filtered_output = layers.Multiply(name='QValue')([output, actions_input])
model = Model(inputs=[frames_input, actions_input], outputs=filtered_output)
# Using logcosh loss function because it's similar to Huber, but easier to implement than a custom loss function
model.compile(loss='logcosh', optimizer=keras.optimizers.RMSprop(lr=0.00025, rho=0.95, epsilon=0.01))
return model
def mul_layer(back_layer, last):
back = back_layer.output
upsample = layers.Conv2DTranspose(int(last.shape[3]), (2, 2),
strides=(2, 2))(last)
to1024 = Conv2D(int(back.shape[3]), (1, 1), activation='elu')(upsample)
mul = layers.Multiply()([back, to1024])
return mul
def build(txt_shape,
img_shape,
act_1=None,
act_2=None,
loss_function=mAP.my_loss):
K.clear_session()
word_index, embedding_matrix = loading()
input_text = layers.Input(shape=(None, ), dtype='int32')
input_image = layers.Input(shape=(img_shape, ))
embeddings = layers.Embedding(len(word_index) + 1,
128,
weights=[embedding_matrix],
input_length=400,
trainable=True)(input_text)
embeddings = Position_Embedding()(embeddings)
O_seq = Attention(8, 16)([embeddings, embeddings, embeddings])
O_seq = layers.GlobalAveragePooling1D()(O_seq)
text_embedding = layers.Dropout(0.5)(O_seq)
text_dense = layers.Dense(512, activation=act_1)(text_embedding)
image_dense = layers.Dense(512, activation=act_1)(input_image)
mul = layers.Multiply()([text_dense, image_dense])
pred = layers.Dense(1, activation=act_2)(mul)
model = Model(inputs=[input_text, input_image], outputs=pred)
model.compile(loss=loss_function, optimizer='adam', metrics=[mAP.auc])
model.summary()
return model
def build_generator(latent_dim):
latent_input = layers.Input(shape=(latent_dim, ))
class_input = layers.Input(shape=(1, ), dtype='int32')
emb = layers.Embedding(10,
latent_dim,
embeddings_initializer='glorot_normal')(class_input)
emb = layers.Flatten()(emb)
generator_input = layers.Multiply()([latent_input, emb])
x = layers.Dense(1024)(generator_input)
x = layers.ReLU()(x)
x = layers.Dense(128 * 7 * 7)(x)
x = layers.ReLU()(x)
x = layers.Reshape((128, 7, 7))(x)
x = layers.UpSampling2D((2, 2))(x)
x = layers.Conv2D(256, 5, padding='same',
bias_initializer='glorot_normal')(x)
x = layers.ReLU()(x)
x = layers.UpSampling2D((2, 2))(x)
x = layers.Conv2D(128, 5, padding='same',
bias_initializer='glorot_normal')(x)
x = layers.ReLU()(x)
x = layers.Conv2D(1, 2, padding='same',
bias_initializer='glorot_normal')(x)
fake_image = layers.Activation('tanh')(x)
generator = keras.models.Model(input=[latent_input, class_input],
output=fake_image)
return generator
def atari_model():
"""
模型初始化
"""
# actions_input = layers.Input((ACTION_SIZE,), name='action_mask')
# frames_input = layers.Input(ATARI_SHAPE, name='inputs')
actions_input = layers.Input((ACTION_SIZE, ), name='mask')
frames_input = layers.Input(ATARI_SHAPE, name='img')
normalized = layers.Lambda(lambda x: x / 255.0, name='norm')(frames_input)
conv_1 = layers.convolutional.Conv2D(16, (8, 8),
strides=(4, 4),
activation='relu')(normalized)
conv_2 = layers.convolutional.Conv2D(32, (4, 4),
strides=(2, 2),
activation='relu')(conv_1)
conv_flattened = layers.core.Flatten()(conv_2)
hidden = layers.Dense(256, activation='relu')(conv_flattened)
output = layers.Dense(ACTION_SIZE)(hidden)
filtered_output = layers.Multiply(name='QValue')([output, actions_input])
model = Model(inputs=[frames_input, actions_input],
outputs=filtered_output)
model.summary()
optimizer = RMSprop(lr=0.00025, rho=0.95, epsilon=0.01)
model.compile(optimizer, loss=huber_loss)
return model
def matting_weighted_l1_loss(matting_gt, blending_result, trimask):
trimask = tf.where(trimask > 0.5, tf.ones_like(trimask), 0.1 * tf.ones_like(trimask))
square = K.square(matting_gt - blending_result)
l1 = K.sqrt(square + K.epsilon())
weighted_l1 = KL.Multiply(name='fusion_trimask_l1_loss_mul')([trimask, l1])
# return K.mean(weighted_l1)
return K.sum(weighted_l1) / K.sum(trimask)
def create_CNN_model(self):
input_shape = (self.stack_depth, self.image_height, self.image_width)
actions_input = layers.Input((self.num_actions, ), name='action_mask')
frames_input = layers.Input(input_shape, name='input_layer')
conv_1 = layers.Conv2D(32, (8,8), strides=4, padding ='same'\
,activation = 'relu', name='conv_1',kernel_initializer='glorot_uniform',bias_initializer='zeros')(frames_input)
conv_2 = layers.Conv2D(64, (4,4), strides=2, padding='same', activation='relu',name='conv_2'\
,kernel_initializer='glorot_uniform',bias_initializer='zeros')(conv_1)
conv_3 = layers.Conv2D(64, (3,3), strides=1, padding='same',name='conv_3', activation='relu'\
,kernel_initializer='glorot_uniform',bias_initializer='zeros')(conv_2)
flatten_1 = layers.Flatten()(conv_3)
dense_1 = layers.Dense(512,
activation='relu',
name='dense_1',
kernel_initializer='glorot_uniform',
bias_initializer='zeros')(flatten_1)
output = layers.Dense(self.num_actions,
activation='linear',
name='output',
kernel_initializer='glorot_uniform',
bias_initializer='zeros')(dense_1)
masked_output = layers.Multiply(name='masked_output')(
[output, actions_input])
model = Model(input=[frames_input, actions_input],
output=[masked_output])
optimizer = optimizers.Adam(lr=self.learning_rate)
model.compile(optimizer, loss=tf.losses.huber_loss)
return model
def agent_model():
frame_input = layers.Input(shape=OBSERV_SPACE , name="frame")
action_input = layers.Input(shape=(ACTION_SPACE , ) , name="action")
if env_type == "3D":
normalized = layers.Lambda(lambda x: x , name='normalization')(frame_input)
conv_1 = layers.Conv2D(16 , (8 , 8) , strides=(4 , 4) , activation="relu" , kernel_initializer='random_uniform' ,bias_initializer='random_uniform' )(normalized)
conv_2 = layers.Conv2D(32 , (4 , 4) , strides=(2 , 2) , activation="relu" , kernel_initializer='random_uniform' ,bias_initializer='random_uniform' )(conv_1)
flatten = layers.Flatten()(conv_2)
dense_1 = layers.Dense(256, activation="relu" ,kernel_initializer='random_uniform' ,bias_initializer='random_uniform' )(flatten)
elif env_type == "2D":
flatten = layers.Flatten()(frame_input)
normalized = layers.Lambda(lambda x: x / 255.0, name='normalization')(flatten)
dense_1_c = layers.Dense(256, activation="relu" , kernel_initializer='random_uniform' ,bias_initializer='random_uniform' )(normalized)
dense_1 = layers.Dense(256, activation="relu" , kernel_initializer='random_uniform' ,bias_initializer='random_uniform' )(dense_1_c)
else:
print("Exception please set enviournment type like '3D' , '2D' ")
exit()
out_1 = layers.Dense(ACTION_SPACE)(dense_1)
mult_output = layers.Multiply(name = "Q_val")([out_1 , action_input])
model = Model(inputs=[frame_input , action_input] , outputs= mult_output)
optimizer = RMSprop(lr=learning_rate, rho=0.95, epsilon=0.01)
# optimizer = Adam(learning_rate=learning_rate)
# optimizer = SGD(learning_rate=learning_rate)
model.compile(optimizer , loss="mse")
return model
def block(inputs):
x = inputs
x = layers.Lambda(
lambda a: K.mean(a, axis=spatial_dims, keepdims=True))(x)
x = layers.Conv2D(num_reduced_filters,
kernel_size=[1, 1],
strides=[1, 1],
kernel_initializer=conv_kernel_initializer,
padding='same',
name=block_name + 'se_reduce_conv2d',
use_bias=True)(x)
x = Swish(name=block_name + 'se_swish')(x)
x = layers.Conv2D(filters,
kernel_size=[1, 1],
strides=[1, 1],
kernel_initializer=conv_kernel_initializer,
padding='same',
name=block_name + 'se_expand_conv2d',
use_bias=True)(x)
x = layers.Activation('sigmoid')(x)
out = layers.Multiply()([x, inputs])
return out
def channel_squeeze_excite_block(input, ratio=0.25):
init = input
channel_axis = 1 if K.image_data_format() == "channels_first" else -1
filters = init._keras_shape[channel_axis]
cse_shape = (1, 1, filters)
cse = layers.GlobalAveragePooling2D()(init)
cse = layers.Reshape(cse_shape)(cse)
ratio_filters = int(np.round(filters * ratio))
if ratio_filters < 1:
ratio_filters += 1
cse = layers.Conv2D(ratio_filters, (1, 1),
padding='same',
activation='relu',
kernel_initializer='he_normal',
use_bias=False)(cse)
cse = layers.BatchNormalization()(cse)
cse = layers.Conv2D(filters, (1, 1),
activation='sigmoid',
kernel_initializer='he_normal',
use_bias=False)(cse)
if K.image_data_format() == 'channels_first':
cse = layers.Permute((3, 1, 2))(cse)
cse = layers.Multiply()([init, cse])
return cse
def atari_model():
# С помощью функционального API нам нужно определить входные данные.
frames_input = layers.Input(ATARI_SHAPE, name='frames')
actions_input = layers.Input((ACTION_SIZE, ), name='action_mask')
# входные кадры все еще закодированы от 0 до 255. Преобразование в [0, 1].
normalized = layers.Lambda(lambda x: x / 255.0,
name='normalization')(frames_input)
conv_1 = layers.convolutional.Conv2D(16, (8, 8),
strides=(4, 4),
activation='relu')(normalized)
conv_2 = layers.convolutional.Conv2D(32, (4, 4),
strides=(2, 2),
activation='relu')(conv_1)
conv_flattened = layers.core.Flatten()(conv_2)
hidden = layers.Dense(256, activation='relu')(conv_flattened)
output = layers.Dense(ACTION_SIZE)(hidden)
filtered_output = layers.Multiply(name='QValue')([output, actions_input])
model = Model(inputs=[frames_input, actions_input],
outputs=filtered_output)
model.summary()
optimizer = RMSprop(lr=FLAGS.learning_rate, rho=0.95, epsilon=0.01)
model.compile(optimizer, loss=huber_loss)
return model
def SqueezeExcitation(in_block, ch, ratio=10):
x = layers.GlobalAveragePooling3D()(in_block)
x = layers.Dense(ch//ratio, activation='relu')(x)
x = layers.Dense(ch, activation='sigmoid')(x)
return layers.Multiply()([in_block, x])
def get_model():
char_action = layers.Input(shape=[2])
char_action_r = layers.RepeatVector(30)(char_action)
position = layers.Input(shape=[6])
position_r = layers.RepeatVector(30)(position)
# enemy_key = layers.Input(shape=[30, 45])
# enemy_key_a = attention_3d_block(enemy_key)
# my_key = layers.Input(shape=[30, 45])
# my_key_a = attention_3d_block(my_key)
concat = layers.Concatenate()([char_action_r, position_r])
gate = layers.Dense(8, activation="sigmoid")(concat)
concat = layers.Multiply()([gate, concat])
'''flatten = layers.Flatten()(concat)
dense = layers.Dense(128, activation="tanh")(flatten)
c = layers.Dense(128, activation="tanh")(dense)
c = layers.Dense(128, activation="tanh")(c)'''
first = conv1d_block(32, 5, padding='causal', activation='tanh')(concat)
A, B = wavenet_block(32, 2, 1)(first)
skip_connections = [B]
for i in range(1, 12):
A, B = wavenet_block(32, 3, 2**(i % 3))(A)
skip_connections.append(B)
net = layers.Add()(skip_connections)
net = layers.LeakyReLU()(net)
net = conv1d_block(16, 1)(net)
net = layers.LeakyReLU()(net)
c = layers.Flatten()(net)
dense_category = layers.Dense(45, activation='softmax')(c)
return keras.models.Model(inputs=[char_action, position],
outputs=[dense_category],
name="TH123AI")
