o1 = Bidirectional(CuDNNLSTM(filter_size, return_sequences=True))(classifier)
o1 = Dropout(0.2)(o1)
o1 = BatchNormalization()(o1)
o2 = Bidirectional(CuDNNLSTM(filter_size, return_sequences=True))(o1)
o2 = Add()([o1, o2])
o2 = Dropout(0.2)(o2)
o2 = BatchNormalization()(o2)
o3 = Bidirectional(CuDNNLSTM(filter_size, return_sequences=True))(o2)
o3 = Add()([o1, o2, o3])
o3 = Dropout(0.2)(o3)
o3 = BatchNormalization()(o3)
'''attention model'''
oa = TimeDistributed(Dense(filter_size * 2, activation='softmax'))(o3)
o3 = Multiply()([o3, oa])
classifier = o3
classifier = TimeDistributed(Dense(filter_size * 2,
activation='relu'))(classifier)
classifier = TimeDistributed(Dense(2, activation='softmax'))(classifier)
model = Model(input, classifier)
print(model.summary())
model.compile(optimizer=keras.optimizers.RMSprop(lr=0.001,
rho=0.9,
epsilon=None,
decay=0.0),
metrics=['accuracy', 'categorical_accuracy'],
loss='categorical_crossentropy')
def build_model(self, train_data, embedding_matrix):
print('Build model...')
embedding_layer = Embedding(output_dim=EMBEDDING_DIM,
input_dim=MAX_NB_WORDS + 1,
input_length=MAX_SEQUENCE_LENGTH,
weights=[embedding_matrix],
trainable=False,
name='embedding')
rnn_layer = LSTM(EMBEDDING_DIM,
activation='relu',
dropout=0.2,
recurrent_dropout=0.2,
return_sequences=False,
name='RNN')
main_input = Input(shape=(MAX_SEQUENCE_LENGTH, ),
dtype='int32',
name='main_input')
embedding_l = embedding_layer(main_input)
rnn_l = rnn_layer(embedding_l)
aux_input1 = Input(shape=(MAX_SEQUENCE_LENGTH, ),
dtype='int32',
name='aux_input1')
embedding_r1 = embedding_layer(aux_input1)
rnn_r1 = rnn_layer(embedding_r1)
aux_input2 = Input(shape=(MAX_SEQUENCE_LENGTH, ),
dtype='int32',
name='aux_input2')
embedding_r2 = embedding_layer(aux_input2)
rnn_r2 = rnn_layer(embedding_r2)
aux_input3 = Input(shape=(MAX_SEQUENCE_LENGTH, ),
dtype='int32',
name='aux_input3')
embedding_r3 = embedding_layer(aux_input3)
rnn_r3 = rnn_layer(embedding_r3)
aux_input4 = Input(shape=(MAX_SEQUENCE_LENGTH, ),
dtype='int32',
name='aux_input4')
embedding_r4 = embedding_layer(aux_input4)
rnn_r4 = rnn_layer(embedding_r4)
aux_input5 = Input(shape=(MAX_SEQUENCE_LENGTH, ),
dtype='int32',
name='aux_input5')
embedding_r5 = embedding_layer(aux_input5)
rnn_r5 = rnn_layer(embedding_r5)
aux_input6 = Input(shape=(1, ), dtype='float32', name='aux_input6')
dot_layer = Dot(axes=1, name='dot')
p1 = dot_layer([rnn_l, rnn_r1])
p2 = dot_layer([rnn_l, rnn_r2])
p3 = dot_layer([rnn_l, rnn_r3])
p4 = dot_layer([rnn_l, rnn_r4])
p5 = dot_layer([rnn_l, rnn_r5])
p = Concatenate(axis=1)([p1, p2, p3, p4, p5])
p = Activation(activation='softmax', name='attention')(p)
p1 = Lambda((lambda x: x[:, 0]))(p)
p2 = Lambda((lambda x: x[:, 1]))(p)
p3 = Lambda((lambda x: x[:, 2]))(p)
p4 = Lambda((lambda x: x[:, 3]))(p)
p5 = Lambda((lambda x: x[:, 4]))(p)
mul_layer = Multiply(name='multiply')
h1 = mul_layer([p1, rnn_r1])
h2 = mul_layer([p2, rnn_r2])
h3 = mul_layer([p3, rnn_r3])
h4 = mul_layer([p4, rnn_r4])
h5 = mul_layer([p5, rnn_r5])
h = Add(name='h')([h1, h2, h3, h4, h5])
added = Add()([h, rnn_l])
output1 = Concatenate(axis=1)([added, aux_input6])
output2 = Dense(MAX_NB_LABELS, activation='sigmoid',
name='classifier')(output1)
model = Model(inputs=[
main_input, aux_input1, aux_input2, aux_input3, aux_input4,
aux_input5, aux_input6
],
outputs=[output2])
# 打印模型
model.summary()
# 编译模型
print('compile...')
rmsprop = RMSprop(lr=self.lr)
model.compile(loss='binary_crossentropy',
optimizer=rmsprop,
metrics=['binary_accuracy'])
# 创建一个实例history
history = LossHistory()
train_x, train_m, train_y, train_u = train_data
index = np.arange(len(train_x))
np.random.shuffle(index)
if self.old_model != '':
model.load_weights(self.old_model)
print('fit...')
model.fit([
train_x[index], train_m[0][index], train_m[1][index],
train_m[2][index], train_m[3][index], train_m[4][index],
train_u[index]
],
train_y[index],
batch_size=self.batch_size,
epochs=self.nb_epoch,
validation_split=self.valid_split,
callbacks=[history])
# 绘制acc-loss曲线
history.loss_plot('epoch', pic_path=self.loss_path)
# 保存模型
model.save(self.new_model)
del model
def get_model_2(num_users, num_items, map_mode='all_map'):
assert map_mode in ["all_map", "main_diagonal", "off_diagonal"],\
'Invalid map_mode {}'.format(map_mode)
num_users = num_users + 1
num_items = num_items + 1
permutation_input = Input(shape=(8,8,), dtype=np.float32, name='permutation_matrix')
######################## attr side ##################################
# Input
user_attr_input = Input(shape=(30,), dtype='float32', name='user_attr_input')
user_attr_embedding = Dense(8, activation='relu', name='user_emb')(user_attr_input)
# permutate user_attr_embedding
user_attr_embedding = Dot(axes=(2,1))([permutation_input, user_attr_embedding])
# ======
user_attr_embedding = Reshape((1, 8))(user_attr_embedding)
item_attr_input = Input(shape=(18,), dtype='float32', name='item_attr_input')
item_attr_embedding = Dense(8, activation='relu', name='item_emb')(item_attr_input)
# permutate item_attr_embedding
item_attr_embedding = Dot(axes=(2,1))([permutation_input, item_attr_embedding])
# ======
item_attr_embedding = Reshape((8, 1))(item_attr_embedding)
merge_attr_embedding = Lambda(lambda x: K.batch_dot(x[0], x[1], axes=[1, 2]))(
[user_attr_embedding, item_attr_embedding])
merge_attr_embedding_global = Flatten()(merge_attr_embedding)
# If using only the diagonal, remove everything not in the diagonal
if map_mode == "main_diagonal":
print("CoupledCF: Using main diagonal elements.")
diagonal = Lambda(lambda x: tf.linalg.diag_part(x))(merge_attr_embedding)
merge_attr_embedding = Lambda(lambda x: tf.linalg.set_diag(K.zeros_like(merge_attr_embedding), x) )(diagonal)
elif map_mode == "off_diagonal":
print("CoupledCF: Using off diagonal elements.")
diagonal = K.zeros_like( Lambda(lambda x: tf.linalg.diag_part(x))(merge_attr_embedding) )
merge_attr_embedding = Lambda(lambda x: tf.linalg.set_diag(x, diagonal) )(merge_attr_embedding)
else:
print("CoupledCF: Using all map elements.")
#merge_attr_embedding_global = Flatten()(merge_attr_embedding)
merge_attr_embedding = Reshape((8, 8, 1))(merge_attr_embedding)
merge_attr_embedding = Conv2D(8, (3, 3), name='conv2d_0')(merge_attr_embedding)
merge_attr_embedding = BatchNormalization(axis=3)(merge_attr_embedding)
merge_attr_embedding = Activation('relu')(merge_attr_embedding)
# merge_attr_embedding = AveragePooling2D((2, 2))(merge_attr_embedding)
# merge_attr_embedding = Dropout(0.35)(merge_attr_embedding)
# merge_attr_embedding = Conv2D(32, (3, 3))(merge_attr_embedding)
# merge_attr_embedding = BatchNormalization(axis=3)(merge_attr_embedding)
# merge_attr_embedding = Activation('relu')(merge_attr_embedding)
# merge_attr_embedding = MaxPooling2D((2, 2))(merge_attr_embedding)
merge_attr_embedding = Conv2D(8, (3, 3), name='conv2d_1')(merge_attr_embedding)
merge_attr_embedding = BatchNormalization(axis=3)(merge_attr_embedding)
merge_attr_embedding = Activation('relu')(merge_attr_embedding)
merge_attr_embedding = Flatten()(merge_attr_embedding)
merge_attr_embedding = Concatenate()([merge_attr_embedding, merge_attr_embedding_global])
attr_1 = Dense(16, name='attr')(merge_attr_embedding)
attr_1 = Activation('relu')(attr_1)
# attr_1=BatchNormalization()(attr_1)
# attr_1=Dropout(0.2)(attr_1)
# attr_2 = Dense(16)(attr_1)
# attr_2 = Activation('relu')(attr_2)
# id_2=BatchNormalization()(id_2)
# id_2=Dropout(0.2)(id_2)
######################## id side ##################################
user_id_input = Input(shape=(1,), dtype='float32', name='user_id_input')
user_id_Embedding = Embedding(input_dim=num_users, output_dim=32, name='user_id_Embedding',
embeddings_initializer=RandomNormal(
mean=0.0, stddev=0.01, seed=None),
embeddings_regularizer=l2(0), input_length=1)
user_id_Embedding = Flatten()(user_id_Embedding(user_id_input))
item_id_input = Input(shape=(1,), dtype='float32', name='item_id_input')
item_id_Embedding = Embedding(input_dim=num_items, output_dim=32, name='item_id_Embedding',
embeddings_initializer=RandomNormal(
mean=0.0, stddev=0.01, seed=None),
embeddings_regularizer=l2(0), input_length=1)
item_id_Embedding = Flatten()(item_id_Embedding(item_id_input))
# id merge embedding
merge_id_embedding = Multiply()([user_id_Embedding, item_id_Embedding])
# id_1 = Dense(64)(merge_id_embedding)
# id_1 = Activation('relu')(id_1)
id_2 = Dense(32, name='merge_id_embedding')(merge_id_embedding)
id_2 = Activation('relu')(id_2)
# merge attr_id embedding
merge_attr_id_embedding = Concatenate()([attr_1, id_2])
dense_1 = Dense(64, name='merge_attr_id_embedding')(merge_attr_id_embedding)
dense_1 = Activation('relu')(dense_1)
# dense_1=BatchNormalization()(dense_1)
# dense_1=Dropout(0.2)(dense_1)
# dense_2=Dense(16)(dense_1)
# dense_2=Activation('relu')(dense_2)
# dense_2=BatchNormalization()(dense_2)
# dense_2=Dropout(0.2)(dense_2)
# dense_3=Dense(8)(dense_2)
# dense_3=Activation('relu')(dense_3)
# dense_3=BatchNormalization()(dense_3)
# dense_3=Dropout(0.2)(dense_3)
topLayer = Dense(1, activation='sigmoid', kernel_initializer='lecun_uniform',
name='topLayer')(dense_1)
# Final prediction layer
model = Model(inputs=[user_attr_input, item_attr_input, user_id_input, item_id_input, permutation_input],
outputs=topLayer)
return model
source_sdv = reshape(max_pool(source_conv))
target_sdv = reshape(max_pool(target_conv))
source_outputs.append(source_sdv)
target_outputs.append(target_sdv)
source_outputs.append(Reshape([filter_num])(AveragePooling1D(seq_length)(source)))
target_outputs.append(Reshape([filter_num])(AveragePooling1D(seq_length)(target)))
source_conc = Concatenate()(source_outputs)
target_conc = Concatenate()(target_outputs)
abs = Lambda(lambda x: kb.abs(x))
h_sub = abs(Subtract()([source_conc, target_conc]))
h_mul = Multiply()([source_conc, target_conc])
w1 = Dense(all_filter_num, activation='tanh', kernel_regularizer=regularizers.l2(regularizer_rate),
bias_regularizer=regularizers.l2(regularizer_rate))
w2 = Dense(all_filter_num, activation='tanh', kernel_regularizer=regularizers.l2(regularizer_rate),
bias_regularizer=regularizers.l2(regularizer_rate))
sdv = Add()([w1(h_sub), w2(h_mul)])
output = Dense(all_filter_num, activation='tanh', kernel_regularizer=regularizers.l2(regularizer_rate),
bias_regularizer=regularizers.l2(regularizer_rate))(sdv)
output = Dropout(drop_out_rate)(output)
logits = Dense(class_num, activation='softmax', kernel_regularizer=regularizers.l2(regularizer_rate),
conv1 = BatchNormalization()(conv1)
conv1 = Conv2D(256, (4, 4))(conv1)
# conv1 = BatchNormalization()(conv1)
conv1 = LeakyReLU()(conv1)
conv1 = Flatten()(conv1)
conv1 = RepeatVector(26)(conv1)
conv1 = Flatten()(conv1)
# conv1 = Dropout(0.25)(conv1)
# conv1 = BatchNormalization()(conv1)
conv2 = RepeatVector(256)(input2)
conv2 = Flatten()(conv2)
outputs = Multiply()([conv1, conv2])
outputs = ReLU()(outputs)
conv1 = Dropout(0.25)(conv1)
outputs = Dense(256, activation='relu')(outputs)
conv1 = Dropout(0.25)(conv1)
outputs = Dense(10, activation='softmax')(outputs)
model = Model(inputs=[input1, input2], outputs=outputs)
model.summary()
model.compile(optimizer=RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0),
loss='categorical_crossentropy',
metrics=['acc'])
check = ModelCheckpoint('./dacon/comp7/bestcheck.hdf5',
def get_model(num_users,
num_items,
num_user_attrs,
num_item_attrs,
mf_dim=10,
layers=[10],
reg_layers=[0],
reg_mf=0):
assert len(layers) == len(reg_layers)
num_layer = len(layers) #Number of layers in the MLP
# Input variables
user_input = Input(shape=(1, ), dtype='int32', name='user_input')
item_input = Input(shape=(1, ), dtype='int32', name='item_input')
user_attr = Input(shape=(num_user_attrs, ), name='user_attr')
item_attr = Input(shape=(num_item_attrs, ), name='item_attr')
# Bias layer
user_bias = Flatten()(Embedding(num_users, 1,
name='user_bias')(user_input))
item_bias = Flatten()(Embedding(num_items, 1,
name='item_bias')(item_input))
# Embedding layer
MF_Embedding_User = Embedding(input_dim=num_users,
output_dim=mf_dim,
name='mf_embedding_user',
embeddings_initializer='uniform',
W_regularizer=l2(reg_mf),
input_length=1)
MF_Embedding_Item = Embedding(input_dim=num_items,
output_dim=mf_dim,
name='mf_embedding_item',
embeddings_initializer='uniform',
W_regularizer=l2(reg_mf),
input_length=1)
MLP_Embedding_User = Embedding(input_dim=num_users,
output_dim=layers[0] // 2,
name="mlp_embedding_user",
embeddings_initializer='uniform',
W_regularizer=l2(reg_layers[0]),
input_length=1)
MLP_Embedding_Item = Embedding(input_dim=num_items,
output_dim=layers[0] // 2,
name='mlp_embedding_item',
embeddings_initializer='uniform',
W_regularizer=l2(reg_layers[0]),
input_length=1)
# MF part
mf_user_latent = Flatten()(MF_Embedding_User(user_input))
mf_item_latent = Flatten()(MF_Embedding_Item(item_input))
mf_vector = Multiply()([mf_user_latent,
mf_item_latent]) # element-wise multiply
# MLP part
mlp_user_latent = Flatten()(MLP_Embedding_User(user_input))
mlp_item_latent = Flatten()(MLP_Embedding_Item(item_input))
mlp_vector = Concatenate()(
[mlp_user_latent, mlp_item_latent, user_attr, item_attr])
for idx in xrange(1, num_layer):
layer = Dense(layers[idx],
W_regularizer=l2(reg_layers[idx]),
activation='relu',
name="layer%d" % idx)
mlp_vector = layer(mlp_vector)
# Concatenate MF and MLP parts
#mf_vector = Lambda(lambda x: x * alpha)(mf_vector)
#mlp_vector = Lambda(lambda x : x * (1-alpha))(mlp_vector)
predict_vector = Concatenate()([mf_vector, mlp_vector])
# Final prediction layer
prediction = Dense(1,
activation='sigmoid',
init='lecun_uniform',
name="prediction")(predict_vector)
# prediction = Add(name='prob')([prediction, user_bias, item_bias])
model = Model(inputs=[user_input, item_input, user_attr, item_attr],
outputs=prediction)
return model
# print X_tfidf
X_train, X_test, y_train, y_test = train_test_split(X_tfidf,
y,
test_size=0.2,
random_state=33)
print 'begin training...'
model_input = Input(shape=(X_train.shape[1], ))
sentence = Dense(1000, activation='tanh')(model_input)
sentence = Dense(200, activation='tanh')(sentence)
attention = Dense(200, activation='tanh')(sentence)
print attention.shape
attention = Activation('softmax')(attention)
sent_representation = Multiply()([sentence, attention])
model_output = Dense(len(tags2ids), activation='softmax')(sent_representation)
model = Model(inputs=model_input, outputs=model_output)
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
history = model.fit(X_train, y_train, batch_size=batch_size, epochs=20)
print 'end training!'
print 'save model!'
model.save('../model/TFIDFANNANNATTRNTIONPC_model.h5')
print 'save model down!'
print 'predicting...'
y_pred = model.predict(X_test)
print 'predicted done'
# model building
inp = Input(shape=(150,))
x = Embedding(5000, 300, weights=[embedding_matrix])(inp)
x = SpatialDropout1D(0.35)(x)
h = Bidirectional(LSTM(128, return_sequences=True, dropout=0.15, recurrent_dropout=0.15))(x)
u = TimeDistributed(Dense(128, activation='relu', use_bias=False))(h)
alpha = TimeDistributed(Dense(1, activation='relu'))(u)
x = Reshape((150,))(alpha)
x = Activation('softmax')(x)
x = Reshape((150, 1))(x)
x = Multiply()([h, x])
x = Lambda(lambda x: be.sum(x, axis=1))(x)
x = Dense(64, activation="relu")(x)
x = Dropout(0.2)(x)
x = Dense(6, activation="sigmoid")(x)
model = Model(inputs=inp, outputs=x)
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
model.summary()
batch_size = 128
model.fit(x_train, y_train, batch_size=batch_size, epochs=10, validation_data=(x_val, y_val))
def build_cnn_return_preds(input_shape, n_authors, vocab_size):
#define conv layers
inputs = Input(shape=input_shape)
conv1 = Conv1D(filters=128,
kernel_size=3,
padding='same',
activation='relu')
conv2 = Conv1D(filters=128,
kernel_size=4,
padding='same',
activation='relu')
conv3 = Conv1D(filters=128,
kernel_size=5,
padding='same',
activation='relu')
conv4 = Conv1D(filters=128,
kernel_size=6,
padding='same',
activation='relu')
attn_maps = []
attn_confidences = []
attn_preds = []
# Embed the words
embed = Embedding(vocab_size, 128, input_length=400)
embedded_inputs = embed(inputs)
#conv block 1
conv1_out = conv1(embedded_inputs)
conv2_out = conv2(conv1_out)
mp1 = MaxPooling1D(pool_size=(5, ), padding='same')
mp1_out = mp1(conv2_out)
#attn block 1
attention1 = attention_layer(mp1_out, 128, n_authors)
attn_maps.append(attention1[0])
attn_confidences.append(attention1[-1])
attn_preds.append(attention1[-2])
#conv block 2
conv3_out = conv3(mp1_out)
conv4_out = conv4(conv3_out)
pool_size = int(math.ceil(input_shape[0] / 5))
mp2 = MaxPooling1D(pool_size=(pool_size, ))
mp2_outs = mp2(conv4_out)
#attn block 2
attention2 = attention_layer(mp2_outs, 128, n_authors)
attn_maps.append(attention2[0])
attn_confidences.append(attention2[-1])
attn_preds.append(attention2[-2])
#predictions
fc_final = Dense(n_authors, activation='softmax')
fc_final_out = fc_final(mp2_outs)
#network without attention confidence score
confidence_layer = Dense(n_authors, activation='sigmoid')
c_out = Lambda(lambda x: K.sum(x, axis=0))(confidence_layer(mp2_outs))
#get how much each attention head should contribute
attn_attributions = calculate_attention_weight(attn_confidences,
attn_preds)
#apply the confidence to the predictions
gated_out = Multiply()([c_out, fc_final_out])
#add the contributions from the attention heads
attention_weighted_out = Add()([gated_out, attn_attributions])
model = Model(inputs=[inputs], outputs=attention_weighted_out)
optimizer = adam(lr=0.003)
model.compile(optimizer=optimizer,
loss=losses(attn_maps),
metrics=['accuracy'])
return (model, attn_maps)
def build_wavenet(n_filters=32,
filter_width=2,
dilated_layers=5,
n_stacks=1,
n_features=1,
output_step=64):
# Complex WaveNet
# convolutional operation parameters
tf.reset_default_graph()
dilation_rates = [2**i for i in range(dilated_layers)] * n_stacks
# define an input history series and pass it through a stack of dilated causal convolution blocks.
history_seq = Input(shape=(None, n_features))
x = history_seq
skips = []
for dilation_rate in dilation_rates:
# preprocessing - equivalent to time-distributed dense
x = Conv1D(16, 1, padding='same', activation='relu')(x)
# filter convolution
x_f = Conv1D(filters=n_filters,
kernel_size=filter_width,
padding='causal',
dilation_rate=dilation_rate)(x)
# gating convolution
x_g = Conv1D(filters=n_filters,
kernel_size=filter_width,
padding='causal',
dilation_rate=dilation_rate)(x)
# multiply filter and gating branches
z = Multiply()([Activation('tanh')(x_f), Activation('sigmoid')(x_g)])
# postprocessing - equivalent to time-distributed dense
z = Conv1D(16, 1, padding='same', activation='relu')(z)
# residual connection
x = Add()([x, z])
# collect skip connections
skips.append(z)
# add all skip connection outputs
out = Activation('relu')(Add()(skips))
# final time-distributed dense layers
out = Conv1D(128, 1, padding='same')(out)
out = Activation('relu')(out)
out = Dropout(.2)(out)
out = Conv1D(1, 1, padding='same')(out)
# extract the last 5 time steps as the training target
def slice(x, seq_length):
return x[:, -seq_length:, :]
pred_seq_train = Lambda(slice, arguments={'seq_length': output_step})(out)
model = Model(history_seq, pred_seq_train)
model.compile(optimizer='adam', loss='mse')
# model.summary()
return model
def _build_model_keras(self):
self.input_tensor = tf.placeholder(tf.float32,
shape=(None, self.board_size / 2, 2,
1))
self.valid_moves_tensor = tf.placeholder(tf.float32,
shape=(None,
self.action_size))
self.input = Input((int(self.board_size / 2), 2, 1))
self.valid_moves_mask = Input((self.action_size, ))
x = self.input
x = Conv2D(self.num_channels,
2,
padding='same',
activation=tf.nn.relu,
kernel_regularizer=regularizers.l2(10e-4))(x)
x = Conv2D(self.num_channels,
2,
padding='same',
activation=tf.nn.relu,
kernel_regularizer=regularizers.l2(10e-4))(x)
x = Flatten()(x)
x = Dropout(self.dropout)(Dense(
2048,
activation=tf.nn.relu,
kernel_regularizer=regularizers.l2(10e-4))(x))
x = Dropout(self.dropout)(Dense(
1024,
activation=tf.nn.relu,
kernel_regularizer=regularizers.l2(10e-4))(x))
x = Dropout(self.dropout)(Dense(
512,
activation=tf.nn.relu,
kernel_regularizer=regularizers.l2(10e-4))(x))
self.pi = Dense(self.action_size,
kernel_regularizer=regularizers.l2(10e-4),
activation=tf.nn.sigmoid)(x)
self.pi_masked = Multiply()([self.pi, self.valid_moves_mask])
self.prob = self.pi_masked * (1 / K.sum(self.pi_masked))
self.v = Dense(1)(x)
self.model = Model(inputs=[self.input, self.valid_moves_mask],
outputs=[self.pi_masked, self.v])
self.model.compile(
loss=['categorical_crossentropy', 'mean_squared_error'],
optimizer=Adam(self.lr))
self.target_pis = tf.placeholder(tf.float32,
shape=[None, self.action_size])
self.target_vs = tf.placeholder(tf.float32, shape=None)
self.loss_v = tf.losses.mean_squared_error(
self.target_vs, tf.reshape(self.v, shape=[
-1,
]))
self.loss_pi = tf.reduce_mean(
tf.reduce_sum(tf.multiply(self.target_pis,
tf.log(self.prob + 10e-7)),
1,
keepdims=True))
self.loss = self.loss_pi + self.loss_v
self.optimizer = tf.train.AdamOptimizer(self.lr)
self.optimize = self.optimizer.minimize(self.loss)
self.entropy = tf.reduce_mean(
tf.distributions.Categorical(probs=self.pi).entropy())
def make_keras_function(self):
from keras.layers import Multiply
layers = [(layer.k if layer.k is not None else layer.keras_layer)
for layer in self.layers]
return Multiply(**self.params)(layers)
def model_construct():
# CONFIG
config = ConfigParser()
config.read('./config.ini')
question_input = Input(shape=(config.getint('pre',
'question_maximum_length'), ),
dtype='int32',
name="question_input")
relation_all_input = Input(shape=(config.getint(
'pre', 'relation_word_maximum_length'), ),
dtype='int32',
name="relation_all_input")
relation_input = Input(shape=(config.getint('pre',
'relation_maximum_length'), ),
dtype='int32',
name="relation_input")
question_emd = np.load('./question_emd_matrix.npy')
relation_emd = np.load('./relation_emd_matrix.npy')
relation_all_emd = np.load('./relation_all_emd_matrix.npy')
question_emd = Embedding(question_emd.shape[0],
config.getint('pre', 'word_emd_length'),
weights=[question_emd],
input_length=config.getint(
'pre', 'question_maximum_length'),
trainable=False,
name="question_emd")(question_input)
sharedEmbd_r_w = Embedding(relation_all_emd.shape[0],
config.getint('pre', 'word_emd_length'),
weights=[relation_all_emd],
input_length=config.getint(
'pre', 'relation_word_maximum_length'),
trainable=False,
name="sharedEmbd_r_w")
relation_word_emd = sharedEmbd_r_w(relation_all_input)
sharedEmbd_r = Embedding(relation_emd.shape[0],
config.getint('pre', 'word_emd_length'),
weights=[relation_emd],
input_length=config.getint(
'pre', 'relation_maximum_length'),
trainable=True,
name="sharedEmbd_r")
relation_emd = sharedEmbd_r(relation_input)
bilstem_layer = Bidirectional(LSTM(units=200,
return_sequences=True,
implementation=2),
name="bilstem_layer")
question_bilstm_1 = bilstem_layer(question_emd)
# question_bilstm_2 = Bidirectional(LSTM(units=200, return_sequences=True, implementation=2),name="question_bilstm_2")(question_bilstm_1)
relation_word_bilstm = bilstem_layer(relation_word_emd)
relation_bilstm = bilstem_layer(relation_emd)
# question_res = Add()([question_bilstm_1, question_bilstm_2])
relation_con = Concatenate(axis=-2)(
[relation_word_bilstm, relation_bilstm])
relation_res = MaxPooling1D(400, padding='same')(relation_con)
relation_flatten = Flatten()(relation_res)
fc_layer1 = Dense(400, use_bias=True, activation='tanh')
fc_layer2 = Dense(1, use_bias=False, activation='softmax')
rel_expand = RepeatVector(30)(relation_flatten)
inputs = Concatenate()([question_bilstm_1, rel_expand])
weights = fc_layer2(fc_layer1(inputs))
question_att = MaxPooling1D(400, padding='same')(
Multiply()([question_bilstm_1, weights]))
result = Dot(axes=-1, normalize=True)([question_att, relation_flatten])
model = Model(inputs=[
question_input,
relation_input,
relation_all_input,
],
outputs=result)
model.compile(optimizer=Adam(), loss=ranking_loss)
return model
def _set_model(self):
inp_doc = Input(shape=(self.max_len_doc_sents,
self.max_len_doc_sent_words, self.d))
inp_summ = Input(shape=(self.max_len_summ_sents,
self.max_len_summ_sent_words, self.d))
lstm_words = LSTM(512,
activation="tanh",
return_sequences=True,
dropout=0.3)
lstm_sents = LSTM(512,
activation="tanh",
return_sequences=True,
dropout=0.3)
# Word Level Doc #
w_doc = TimeDistributed(lstm_words)(inp_doc)
alpha1_doc = TimeDistributed(Dense(1))(w_doc)
alpha1_doc = TimeDistributed(Flatten())(alpha1_doc)
alpha1_doc_o = TimeDistributed(Activation("softmax"))(alpha1_doc)
alpha1_doc = TimeDistributed(RepeatVector(512))(alpha1_doc_o)
alpha1_doc = TimeDistributed(Permute([2, 1]))(alpha1_doc)
s1_doc = Multiply()([w_doc, alpha1_doc])
s1_doc = TimeDistributed(Lambda(lambda x: K.sum(x, axis=-2)))(s1_doc)
# Word Level Summ #
w_summ = TimeDistributed(lstm_words)(inp_summ)
alpha1_summ = TimeDistributed(Dense(1))(w_summ)
alpha1_summ = TimeDistributed(Flatten())(alpha1_summ)
alpha1_summ = TimeDistributed(Activation("softmax"))(alpha1_summ)
alpha1_summ = TimeDistributed(RepeatVector(512))(alpha1_summ)
alpha1_summ = TimeDistributed(Permute([2, 1]))(alpha1_summ)
s1_summ = Multiply()([w_summ, alpha1_summ])
s1_summ = TimeDistributed(Lambda(lambda x: K.sum(x, axis=-2)))(s1_summ)
# Sentence Level Doc #
h_doc = lstm_sents(s1_doc)
alpha2_doc = Dense(1)(h_doc)
alpha2_doc = Flatten()(alpha2_doc)
alpha2_doc_o = Activation("softmax")(alpha2_doc)
alpha2_doc = RepeatVector(512)(alpha2_doc_o)
alpha2_doc = Permute([2, 1])(alpha2_doc)
s2_doc = Multiply()([h_doc, alpha2_doc])
s2_doc = Lambda(lambda x: K.sum(x, axis=-2))(s2_doc)
# Sentence Level Summ #
h_summ = lstm_sents(s1_summ)
alpha2_summ = Dense(1)(h_summ)
alpha2_summ = Flatten()(alpha2_summ)
alpha2_summ = Activation("softmax")(alpha2_summ)
alpha2_summ = RepeatVector(512)(alpha2_summ)
alpha2_summ = Permute([2, 1])(alpha2_summ)
s2_summ = Multiply()([h_summ, alpha2_summ])
s2_summ = Lambda(lambda x: K.sum(x, axis=-2))(s2_summ)
diff = Lambda(lambda x: K.abs(x[0] - x[1]),
output_shape=(512, ))([s2_doc, s2_summ])
h_merged = Concatenate()([s2_doc, s2_summ, diff])
output = Dense(2, activation="softmax")(h_merged)
self.shann_model = Model(inputs=[inp_doc, inp_summ], outputs=output)
self.shann_model.compile(optimizer="adam",
loss="categorical_crossentropy",
metrics=["accuracy"])
self.all_att_model = Model(inputs=inp_doc,
outputs=[alpha1_doc_o, alpha2_doc_o])
def create_model(self):
init_img_width = self.img_width // 4
init_img_height = self.img_height // 4
#GENERATOR ARCHITECTURE
random_input = Input(shape=(self.random_input_dim, ))
text_input1 = Input(shape=(self.text_input_dim, ))
random_dense = Dense(self.random_input_dim)(random_input)
text_layer1 = Dense(1024)(text_input1)
merged = concatenate([random_dense, text_layer1])
generator_layer = Dense(128 * init_img_width * init_img_height,
activation='relu')(merged)
generator_layer = BatchNormalization(momentum=0.9)(generator_layer)
generator_layer = LeakyReLU(alpha=0.1)(generator_layer)
generator_layer = Reshape(
(init_img_width, init_img_height, 128))(generator_layer)
generator_layer = Conv2D(128, kernel_size=4, strides=1,
padding='same')(generator_layer)
generator_layer = BatchNormalization(momentum=0.9)(generator_layer)
generator_layer = LeakyReLU(alpha=0.1)(generator_layer)
generator_layer = Conv2DTranspose(128,
kernel_size=4,
strides=2,
padding='same')(generator_layer)
generator_layer = BatchNormalization(momentum=0.9)(generator_layer)
generator_layer = LeakyReLU(alpha=0.1)(generator_layer)
generator_layer = Conv2D(128, kernel_size=5, strides=1,
padding='same')(generator_layer)
generator_layer = BatchNormalization(momentum=0.9)(generator_layer)
generator_layer = LeakyReLU(alpha=0.1)(generator_layer)
generator_layer = Conv2DTranspose(128,
kernel_size=4,
strides=2,
padding='same')(generator_layer)
generator_layer = BatchNormalization(momentum=0.9)(generator_layer)
generator_layer = LeakyReLU(alpha=0.1)(generator_layer)
generator_layer = Conv2D(128, kernel_size=5, strides=1,
padding='same')(generator_layer)
generator_layer = BatchNormalization(momentum=0.9)(generator_layer)
generator_layer = LeakyReLU(alpha=0.1)(generator_layer)
generator_layer = Conv2D(128, kernel_size=5, strides=1,
padding='same')(generator_layer)
generator_layer = BatchNormalization(momentum=0.9)(generator_layer)
generator_layer = LeakyReLU(alpha=0.1)(generator_layer)
generator_layer = Conv2D(3, kernel_size=5, strides=1,
padding='same')(generator_layer)
generator_output = Activation('tanh')(generator_layer)
self.generator = Model([random_input, text_input1], generator_output)
print('\nGENERATOR:\n')
print('generator: ', self.generator.summary())
print("\n\n")
self.generator.compile(loss='binary_crossentropy',
optimizer=Adam(0.0002, 0.5),
metrics=["accuracy"])
plot_model(self.generator,
to_file="generator_model.jpg",
show_shapes=True)
#DISCRIMINATOR MODEL
text_input2 = Input(shape=(self.text_input_dim, ))
text_layer2 = Dense(1024)(text_input2)
img_input2 = Input(shape=(self.img_width, self.img_height,
self.img_channels))
# first typical convlayer outputs a 20x20x256 matrix
img_layer2 = Conv2D(filters=256,
kernel_size=8,
strides=1,
padding='valid',
name='conv1')(img_input2) #kernel_size=9
img_layer2 = LeakyReLU()(img_layer2)
# original 'Dynamic Routing Between Capsules' paper does not include the batch norm layer after the first conv group
img_layer2 = BatchNormalization(momentum=0.8)(img_layer2)
img_layer2 = Conv2D(filters=256,
kernel_size=8,
strides=2,
padding='valid',
name='conv2')(img_layer2) #kernel_size=9
img_layer2 = LeakyReLU()(img_layer2)
# original 'Dynamic Routing Between Capsules' paper does not include the batch norm layer after the first conv group
img_layer2 = BatchNormalization(momentum=0.8)(img_layer2)
#NOTE: Capsule architecture starts from here.
# primarycaps coming first
# filters 512 (n_vectors=8 * channels=64)
img_layer2 = Conv2D(filters=8 * 64,
kernel_size=8,
strides=2,
padding='valid',
name='primarycap_conv2_1')(img_layer2)
#img_layer2 = Conv2D(filters=8 * 64, kernel_size=8, strides=2, padding='valid', name='primarycap_conv2_2')(img_layer2)
# reshape into the 8D vector for all 32 feature maps combined
# (primary capsule has collections of activations which denote orientation of the digit
# while intensity of the vector which denotes the presence of the digit)
img_layer2 = Reshape(target_shape=[-1, 8],
name='primarycap_reshape')(img_layer2)
# the purpose is to output a number between 0 and 1 for each capsule where the length of the input decides the amount
img_layer2 = Lambda(squash, name='primarycap_squash')(img_layer2)
img_layer2 = BatchNormalization(momentum=0.8)(img_layer2)
# digitcaps are here
img_layer2 = Flatten()(img_layer2)
# capsule (i) in a lower-level layer needs to decide how to send its output vector to higher-level capsules (j)
# it makes this decision by changing scalar weight (c=coupling coefficient) that will multiply its output vector and then be treated as input to a higher-level capsule
# uhat = prediction vector, w = weight matrix but will act as a dense layer, u = output from a previous layer
# uhat = u * w
# neurons 160 (num_capsules=102 * num_vectors=16)
uhat = Dense(1632,
kernel_initializer='he_normal',
bias_initializer='zeros',
name='uhat_digitcaps')(img_layer2)
# c = coupling coefficient (softmax over the bias weights, log prior) | "the coupling coefficients between capsule (i) and all the capsules in the layer above sum to 1"
# we treat the coupling coefficiant as a softmax over bias weights from the previous dense layer
c = Activation('softmax', name='softmax_digitcaps1')(
uhat
) # softmax will make sure that each weight c_ij is a non-negative number and their sum equals to one
# s_j (output of the current capsule level) = uhat * c
c = Dense(1632)(c) # compute s_j
x = Multiply()([uhat, c])
s_j = LeakyReLU()(x)
# we will repeat the routing part 2 more times (num_routing=3) to unfold the loop
c = Activation('softmax', name='softmax_digitcaps2')(
s_j
) # softmax will make sure that each weight c_ij is a non-negative number and their sum equals to one
c = Dense(1632)(c) # compute s_j
x = Multiply()([uhat, c])
s_j = LeakyReLU()(x)
c = Activation('softmax', name='softmax_digitcaps3')(
s_j
) # softmax will make sure that each weight c_ij is a non-negative number and their sum equals to one
c = Dense(1632)(c) # compute s_j
x = Multiply()([uhat, c])
s_j = LeakyReLU()(x)
merged = concatenate([s_j, text_layer2])
discriminator_layer = Activation('relu')(merged)
pred = Dense(1, activation='sigmoid')(discriminator_layer)
self.discriminator = Model([img_input2, text_input2], pred)
print('\nDISCRIMINATOR:\n')
print('discriminator: ', self.discriminator.summary())
print("\n\n")
self.discriminator.compile(loss='binary_crossentropy',
optimizer=Adam(0.0002, 0.5),
metrics=['accuracy'])
plot_model(self.discriminator,
to_file="discriminator_model.jpg",
show_shapes=True)
#ADVERSARIAL MODEL
model_output = self.discriminator([self.generator.output, text_input1])
self.model = Model([random_input, text_input1], model_output)
self.discriminator.trainable = False
print('\nADVERSARIAL MODEL:\n')
print('generator-discriminator:\n', self.model.summary())
print("\n\n")
self.model.compile(loss='binary_crossentropy',
optimizer=Adam(0.0002, 0.5),
metrics=["accuracy"])
plot_model(self.model, to_file="model.jpg", show_shapes=True)
def attention(x, l_name):
x_log = Lambda(logFunc)(x)
x = Multiply(name=l_name)([x, x_log])
return x
def dim_red(intermediate_dim, latent_dim, batch_size, learning_rate, features,
predictions):
# Trains autoencoder and uses it for dimensionality reduction
# Variable Parameters
print('Intermediate Dimensions: ' + str(intermediate_dim))
print('Latent Dimensions: ' + str(latent_dim))
print('Batch Size: ' + str(batch_size))
print('Learning Rate: ' + str(learning_rate))
print('Shape of features: ' + str(features.shape))
original_dim = features.shape[1]
features = features.to_numpy()
predictions = np.array(predictions)
############# Model ##########################
decoder = Sequential([
Dense(intermediate_dim, input_dim=latent_dim, activation='relu'),
Dense(original_dim, activation='sigmoid')
])
x = Input(shape=(original_dim, ))
h = Dense(intermediate_dim, activation='relu')(x)
z_mu = Dense(latent_dim)(h)
z_log_var = Dense(latent_dim)(h)
z_mu, z_log_var = KLDivergenceLayer()([z_mu, z_log_var])
z_sigma = Lambda(lambda t: K.exp(.5 * t))(z_log_var)
eps = Input(tensor=K.random_normal(stddev=epsilon_std,
shape=(K.shape(x)[0], latent_dim)))
z_eps = Multiply()([z_sigma, eps])
z = Add()([z_mu, z_eps])
x_pred = decoder(z)
vae = Model(inputs=[x, eps], outputs=x_pred)
adam = optimizers.Adam(lr=learning_rate)
vae.compile(optimizer=adam, loss=nll)
########### Training Autoencoder ################
x_train, x_test, y_train, y_test = train_test_split(features,
predictions,
test_size=0.2,
random_state=4)
# oversample = SMOTE()
# x_train, y_train = oversample.fit_resample(x_train, y_train)
values, counts = np.unique(predictions, return_counts=True)
print(values)
print(counts)
vae.fit(x_train,
x_train,
shuffle=True,
epochs=epochs,
batch_size=batch_size,
validation_data=(x_test, x_test),
verbose=0)
encoder = Model(x, z_mu)
############### Using Autoencoder as Dimensionality Reduction #############################
encoded_X_train = encoder.predict(x_train)
encoded_X_test = encoder.predict(x_test)
##################### Saving Train/Test Sets ##########################
#uncomment for csv files of processed data
# xtrain_enc = pd.DataFrame(encoded_X_train)
# xtest_enc = pd.DataFrame(encoded_X_test)
# xtrain = pd.DataFrame(x_train)
# xtest = pd.DataFrame(x_test)
# ytrain = pd.DataFrame(y_train)
# ytest = pd.DataFrame(y_test)
# xtrain_enc.to_csv("x_train_enc.csv")
# xtest_enc.to_csv("x_test_enc.csv")
# xtrain.to_csv("x_train_raw.csv")
# xtest.to_csv("x_test_raw.csv")
# ytrain.to_csv("y_train.csv")
# ytest.to_csv("y_test.csv")
#
return encoded_X_train, encoded_X_test, x_train, x_test, y_train, y_test
name="similarity_pred")(L1_distance)
#similarity_prediction_cat = Lambda(K.one_hot,arguments={'num_classes': 2},output_shape=(2,))(similarity_prediction)
#similarity_prediction_cat = Dense(2, activation="softmax", name="a7a_layer") (similarity_prediction)
#Here we try adding #should I add the functional version and should I include the previous embeddings as inputs
diffrentiable_conditional_add = Lambda(lambda x: K.switch(
K.greater_equal(x, 0.5),
Add(name="add_inner")
([xception_model_embeddings_current, xception_model_embeddings_previous]
), xception_model_embeddings_current),
name="add_conditional")(
similarity_prediction)
#diffrentiable_conditional_dot = Lambda( lambda x:K.where(x>=0.5, Dot()([xception_model_embeddings_current, xception_model_embeddings_previous]), xception_model_embeddings_current))(similarity_prediction)
diffrentiable_conditional_multiply = Lambda(lambda x: K.switch(
x >= 0.5,
Multiply()
([xception_model_embeddings_current, xception_model_embeddings_previous]
), xception_model_embeddings_current))(similarity_prediction)
diffrentiable_conditional_average = Lambda(lambda x: K.switch(
x >= 0.5,
Average()
([xception_model_embeddings_current, xception_model_embeddings_previous]
), xception_model_embeddings_current))(similarity_prediction)
#diffrentiable_conidtional_concatenate = Lambda( lambda x:K.where(x>=0.5,Concatenate()([xception_model_embeddings_current, xception_model_embeddings_previous]) , xception_model_embeddings_current))(similarity_prediction)
#Here we try convolution
#Be sure to initialize a different one with var input sizes for concat version
#predictor_convolution = xception_conv_final_predictor(diffrentiable_conditional_add)
final_predictor_1 = Flatten()(diffrentiable_conditional_add)
final_predictor_2 = Dense(1024, activation='relu')(final_predictor_1)
final_predictor_3 = Dense(512, activation='relu')(final_predictor_2)
def stresnet(c_conf=(3, 2, 32, 32), p_conf=(3, 2, 32, 32), t_conf=(3, 2, 32, 32), external_dim=8, nb_residual_unit=3):
'''
C - Temporal Closeness
P - Period
T - Trend
conf = (len_seq, nb_flow, map_height, map_width)
external_dim
'''
# main input
main_inputs = []
outputs = []
# c_conf, p_conf, t_conf
# for conf in [ c_conf]:
# if conf is not None:
# # base 模型
# len_seq, nb_flow, map_height, map_width = conf
# input = Input(shape=(nb_flow * len_seq, map_height, map_width))
# main_inputs.append(input)
# # Conv1
# # conv1 = Convolution2D(nb_filter=64, nb_row=3, nb_col=3, border_mode="same")(input)
# conv1 = Conv2D(padding="same", kernel_size=(stride, stride), filters=64)(input)
# # [nb_residual_unit] Residual Units
# residual_output = ResUnits(_residual_unit, nb_filter=64,
# repetations=nb_residual_unit,)(conv1)
# # Conv2
# activation = Activation('relu')(residual_output)
# # conv2 = Convolution2D(
# # nb_filter=nb_flow, nb_row=3, nb_col=3, border_mode="same")(activation)
# conv2 = Convolution2D(
# nb_filter=nb_flow, nb_row=3, nb_col=3, border_mode="same")(activation)
# outputs.append(conv2)
for conf in [c_conf]:
if conf is not None:
# base 模型
# len_seq, nb_flow, map_height, map_width = conf
# input = Input(shape=(nb_flow * len_seq, map_height, map_width))
# main_inputs.append(input)
# # Conv1
# # conv1 = Convolution2D(nb_filter=64, nb_row=3, nb_col=3, border_mode="same")(input)
# conv1 = Conv2D(padding="same", kernel_size=(3, 3), filters=64)(input)
# # [nb_residual_unit] Residual Units
# residual_output = ResUnits(_residual_unit, nb_filter=64,
# repetations=nb_residual_unit)(conv1)
# # Conv2
# activation = Activation('relu')(residual_output)
# # conv2 = Convolution2D(
# # nb_filter=nb_flow, nb_row=3, nb_col=3, border_mode="same")(activation)
# conv2 = Convolution2D(
# nb_filter=output_nb_flow, nb_row=3, nb_col=3, border_mode="same")(activation)
# outputs.append(conv2)
# 我的模型
len_seq, nb_flow, map_height, map_width = conf
# input=main_inputs[0]
input = Input(shape=(nb_flow * len_seq, map_height, map_width))
# main_inputs[1:3]=main_inputs[0:2]
# main_inputs[0]=input
main_inputs.append(input)
input = Reshape((len_seq, nb_flow, map_height, map_width))(input)
timeSliceOutputs = []
print(input.shape[1])
# 定义共用的CNN模型
# conv1=Reshape((nb_flow, map_height, map_width))(input[:,timeSlice])
# Conv1
aa = Conv2D(padding="same", kernel_size=(stride, stride), filters=64)
# conv1 = Conv2D(padding="same", kernel_size=(3, 3), filters=64)
# [nb_residual_unit] Residual Units
nb_residual_unit = 5
resIntput = Input(shape=(64, map_height, map_width))
# resIntput=Input(shape=aa.output_shape)
bb = ResUnits(_residual_unit, nb_filter=64,
repetations=nb_residual_unit, pool=True)(resIntput)
resModel = Model(resIntput, bb)
resModel.summary()
plot_model(resModel, to_file='resModel.png')
# Conv2
cc = Activation('relu')
# conv2 = Convolution2D(
# nb_filter=nb_flow, nb_row=3, nb_col=3, border_mode="same")(activation)
dd = Convolution2D(
nb_filter=128, nb_row=2, nb_col=2, border_mode="same")
ee = Reshape((1, -1))
for timeSlice in range(len_seq):
ii = sliceLayer(1, timeSlice)(input)
# ii=input[:, timeSlice]
conv2 = ee(dd(cc(resModel(aa(ii)))))
timeSliceOutputs.append(conv2)
convOutput = Concatenate(axis=1)(timeSliceOutputs)
# lstm = GRU(output_nb_flow * map_height * map_width)(convOutput)
# lstm = GRU(2 * map_height * map_width)(convOutput)
lstm = LSTM(600)(convOutput)
# input+lstm
out1 = sliceLayer(1, len_seq - 1)(input)
def antirectifier(x):
# x=np.reshape(x,[-1,18,2,64,64])
# x = tf.reshape(x, [-1, 18, 2, 64, 64])
# x = tf.reduce_sum(x, axis=1)
x = K.reshape(x, [-1, 18, 2, map_height, map_width])
x = K.sum(x, axis=1)
return x
def antirectifier_output_shape(input_shape):
return (input_shape[0], 2, map_height, map_width)
# out1 = Lambda(antirectifier,
# output_shape=antirectifier_output_shape)(out1)
# out2 = Flatten()(lstm)
sig = Dense(output_dim=nb_flow * map_height * map_width, activation='sigmoid')(lstm)
sig = Reshape((nb_flow, map_height, map_width))(sig)
tan = Dense(output_dim=nb_flow * map_height * map_width, activation='tanh')(lstm)
tan = Reshape((nb_flow, map_height, map_width))(tan)
den = Dense(output_dim=nb_flow * map_height * map_width)(lstm)
den = Reshape((nb_flow, map_height, map_width))(den)
# out2=Add()([Multiply()([outputs[0],sig]),tan,out1])
mul=Multiply()([out1, sig])
out2 = Add()([mul, den])
# output = Add()([out1, tan])
# outputs[0]=out2
outputs.append(out2)
# len_seq, nb_flow, map_height, map_width = c_conf
# input = main_inputs[0]
# # input = Input(shape=(nb_flow * len_seq, map_height, map_width))
# input2 = Reshape((len_seq, nb_flow * map_height * map_width))(input)
# lstm = LSTM(output_nb_flow * map_height * map_width)(input)
# output = Reshape((output_nb_flow, map_height, map_width))(lstm)
# outputs.append(output)
# outputs=outputs[1:]
# parameter-matrix-based fusion
if len(outputs) == 1:
main_output = outputs[0]
else:
new_outputs = []
for output in outputs:
# new_outputs.append(iLayer()(output))
new_outputs.append(mulLayer()(output))
main_output = Add()(new_outputs)
# main_output=Add()(outputs)
# fusing with external component
# if external_dim != None and external_dim > 0:
# # external input
# external_input = Input(shape=(external_dim,))
# main_inputs.append(external_input)
# embedding = Dense(output_dim=10)(external_input)
# embedding = Activation('relu')(embedding)
# # h1 = Dense(output_dim=nb_flow * map_height * map_width)(embedding)
# h1 = Dense(output_dim=nb_flow * map_height * map_width)(embedding)
# activation = Activation('relu')(h1)
# # external_output = Reshape((nb_flow, map_height, map_width))(activation)
# external_output = Reshape((nb_flow, map_height, map_width))(activation)
# main_output = merge([main_output, external_output], mode='sum')
# else:
# print('external_dim:', external_dim)
main_output = Activation('tanh')(main_output)
def antirectifier2(x):
#x=np.reshape(x,[-1,18,2,64,64])
x = K.reshape(x,[-1,18,2,map_height,map_width])
x = K.sum(x, axis=1)
return x
# def antirectifier_output_shape(input_shape):
#
# return (input_shape[0],2,64,64)
#
# main_output=Lambda(antirectifier2 )(main_output)
model = Model(input=main_inputs, output=main_output)
return model
def cSE(self):
channel_squeeze = Conv2D(1, (1, 1),
kernel_initializer="he_normal",
activation='sigmoid')(self.layer)
channel_squeeze = Multiply()([self.layer, channel_squeeze])
return channel_squeeze
def __init__(self,
S,
O,
H=200,
N=128,
M=16,
num_heads=4,
lr=0.0001,
alpha_init=0.5,
gamma=0.99,
dic_label=None):
self.S = S
self.H = H
self.O = O
self.N = N
self.M = M
self.n = num_heads
self.alpha = alpha_init
self.lr = lr
self.dic_label = dic_label
self.GAMMA = K.constant(gamma, shape=(self.N, 1))
self.MEMORY = K.zeros(shape=(self.N, self.M))
self.usage_weights = K.zeros(shape=(self.N, 1))
self.read_weights = K.zeros(shape=(self.N, self.n))
Add_layer = Add()
Multiply_layer = Multiply()
COS = Dot(axes=[2, 2], normalize=True)
Dot_layer_2_1 = Dot(axes=[2, 1])
Dot_layer_1_1 = Dot(axes=[1, 1])
Reshape_layer_n_M = Reshape((self.n, self.M))
Reshape_layer_nM_1 = Reshape((self.n * self.M, ))
CONTROLLER = LSTM(units=self.H, activation='tanh')
Dense_read_keys = Dense(self.n * self.M, activation='tanh')
Dense_write_keys = Dense(self.n * self.M, activation='tanh')
Dense_omegas = Dense(self.n, activation='sigmoid')
Complement_layer = Lambda(lambda o: K.ones(shape=(self.N, self.n)) - o)
softmax_layer = Lambda(lambda x: softmax(x, axis=1))
Sum_layer = Lambda(lambda x: K.sum(x, axis=2, keepdims=True))
Output_layer = Dense(self.O, activation='softmax')
# Initial input
controller_input = Input(shape=(1, self.S))
least_usage = Input(shape=(self.N, 1))
# LSTM controller
controller = CONTROLLER(controller_input)
# key outputs for memory dynamics
read_keys = Dense_read_keys(controller) # 1 x n*M
read_keys_reshaped = Reshape_layer_n_M(read_keys)
write_keys = Dense_write_keys(controller) # 1 x n*M
write_keys_reshaped = Reshape_layer_n_M(write_keys)
omegas = Dense_omegas(controller) # 1 x n
#least_usage = Lambda(lambda x: self.build_least_usage(x,self.n))(prev_usage)
## writing to memory
omegas_tiled = Lambda(lambda x: K.tile(K.expand_dims(x, axis=1),
(1, self.N, 1)))(omegas)
rd_part = Multiply_layer([omegas_tiled, self.read_weights])
compl_omegas = Complement_layer(omegas_tiled)
least_usage_tiled = Lambda(lambda x: K.tile(x, (1, 1, self.n)))(
least_usage)
us_part = Multiply_layer([compl_omegas, least_usage_tiled])
write_weights = Add_layer([rd_part, us_part])
print('WRITE WEIGHTS: ', write_weights)
print('MEMORY: ', self.MEMORY)
writing = Dot_layer_2_1([write_weights, write_keys_reshaped])
self.MEMORY = Add_layer([self.MEMORY, writing])
print('NEW MEMORY: ', self.MEMORY)
### reading from memory
print('READ KEYS: ', read_keys_reshaped)
cos_sim = COS([self.MEMORY, read_keys_reshaped
]) # correct normalization? MEMORY OR NEW?
print('COSINE_SIMILARITY: ', cos_sim)
self.read_weights = softmax_layer(
cos_sim) # correct softmax normalization?
print('READ WEIGHTS: ', self.read_weights)
write_weights_summed = Sum_layer(write_weights)
read_weights_summed = Sum_layer(self.read_weights)
decay_usage = Lambda(lambda x: self.GAMMA * x)(self.usage_weights)
self.usage_weights = Add_layer(
[decay_usage, read_weights_summed, write_weights_summed])
print('USAGE WEIGHTS: ', self.usage_weights)
retrieved_memory = Dot_layer_1_1([self.read_weights,
self.MEMORY]) # MEMORY OR NEW?
print('RETRIEVED MEMORY: ', retrieved_memory)
retrieved_memory_reshaped = Reshape_layer_nM_1(retrieved_memory)
print('RETRIEVED MEMORY_RESHAPED: ', retrieved_memory_reshaped)
### concatenation
controller_output = concatenate(
[controller, retrieved_memory_reshaped])
print('CONCATENATED OUTPUT: ', controller_output)
# classifier
main_output = Output_layer(controller_output)
print('FINAL OUTPUT: ', main_output)
if self.O == 2:
loss_fct = 'binary_crossentropy'
else:
loss_fct = 'categorical_crossentropy'
# NTM model: stimulus->controller->concatenation->output
self.NTM = Model(inputs=[controller_input, least_usage],
outputs=[main_output])
self.NTM.compile(loss=loss_fct,
optimizer=RMSprop(lr=self.lr),
metrics=['accuracy'])
def build_pconv_unet(self, train_bn=True, lr=0.0002):
# ENCODER
def encoder_layer(img_in, mask_in, filters, kernel_size, bn=True):
conv, mask = PConv2D(filters,
kernel_size,
strides=2,
padding='same')([img_in, mask_in])
if bn:
conv = BatchNormalization(name='EncBN' +
str(encoder_layer.counter))(
conv, training=train_bn)
conv = Activation('relu')(conv)
encoder_layer.counter += 1
return conv, mask
# DECODER
def decoder_layer(img_in,
mask_in,
e_conv,
e_mask,
filters,
kernel_size,
bn=True):
up_img = UpSampling2D(size=(2, 2))(img_in)
up_mask = UpSampling2D(size=(2, 2))(mask_in)
concat_img = Concatenate(axis=3)([e_conv, up_img])
concat_mask = Concatenate(axis=3)([e_mask, up_mask])
conv, mask = PConv2D(filters, kernel_size,
padding='same')([concat_img, concat_mask])
if bn:
conv = BatchNormalization()(conv)
conv = LeakyReLU(alpha=0.2)(conv)
return conv, mask
# Setup the model inputs / outputs
with tf.device("/cpu:0"):
# INPUTS
inputs_img = Input((self.img_rows, self.img_cols, 3))
inputs_mask = Input((self.img_rows, self.img_cols, 3))
encoder_layer.counter = 0
e_conv1, e_mask1 = encoder_layer(inputs_img,
inputs_mask,
96,
7,
bn=False) # 64*1.5
e_conv2, e_mask2 = encoder_layer(e_conv1, e_mask1, 192,
5) # 128*1.5
e_conv3, e_mask3 = encoder_layer(e_conv2, e_mask2, 384,
5) # 256*1.5
e_conv4, e_mask4 = encoder_layer(e_conv3, e_mask3, 384, 3)
e_conv5, e_mask5 = encoder_layer(e_conv4, e_mask4, 384, 3)
e_conv6, e_mask6 = encoder_layer(e_conv5, e_mask5, 384, 3)
e_conv7, e_mask7 = encoder_layer(e_conv6, e_mask6, 384, 3)
e_conv8, e_mask8 = encoder_layer(e_conv7, e_mask7, 384, 3)
d_conv9, d_mask9 = decoder_layer(e_conv8, e_mask8, e_conv7,
e_mask7, 384, 3)
d_conv10, d_mask10 = decoder_layer(d_conv9, d_mask9, e_conv6,
e_mask6, 384, 3)
d_conv11, d_mask11 = decoder_layer(d_conv10, d_mask10, e_conv5,
e_mask5, 384, 3)
d_conv12, d_mask12 = decoder_layer(d_conv11, d_mask11, e_conv4,
e_mask4, 384, 3)
d_conv13, d_mask13 = decoder_layer(d_conv12, d_mask12, e_conv3,
e_mask3, 384, 3)
d_conv14, d_mask14 = decoder_layer(d_conv13, d_mask13, e_conv2,
e_mask2, 192, 3)
d_conv15, d_mask15 = decoder_layer(d_conv14, d_mask14, e_conv1,
e_mask1, 96, 3)
d_conv16, d_mask16 = decoder_layer(d_conv15,
d_mask15,
inputs_img,
inputs_mask,
3,
3,
bn=False)
x = Conv2D(3, 1, activation='sigmoid')(d_conv16)
ones = Lambda(lambda x: K.expand_dims(K.ones(K.int_shape(x)[1:]), 0
))(inputs_mask)
in_mask = Subtract()([ones, inputs_mask])
x_inmask = Multiply(name="in_mask")([x, in_mask])
x_outmask = Multiply(name="out_mask")([inputs_img, inputs_mask])
outputs = Add(name="last")([x_inmask, x_outmask])
cpu_model = Model(inputs=[inputs_img, inputs_mask],
outputs=outputs)
model = keras.utils.multi_gpu_model(cpu_model, gpus=4)
# Compile the model
model.compile(optimizer=Adam(lr=lr), loss=self.loss_total(inputs_mask))
return model
def model_structure():
X = Input(shape=(T,3),name = "input_x")
c_vec = Input(shape=(U,character_number),name = "input_cvec")
init_window = Input((character_number,),name = "input_window")
init_kappa = Input(shape=(K,1),name = "input_kappa")
h10 = Input(shape=(400,), name='h10')
c10 = Input(shape=(400,), name='c10')
h20 = Input(shape=(400,), name='h20')
c20 = Input(shape=(400,), name='c20')
h30 = Input(shape=(400,), name='h30')
c30 = Input(shape=(400,), name='c30')
window = init_window
kappa_prev = init_kappa
h1 = h10
c1 = c10
h2 = h10
c2 = c10
h3 = h10
c3 = c10
outputs = []
u = np.concatenate([np.expand_dims(np.array([i for i in range(1,U+1)], dtype=np.float32),0) for _ in range(K)], axis = 0) #shape = [K,U]
for t in range(T):
x = Lambda(lambda x: x[:,t,:], name = "lamb1-%i" % t)(X)
conc1 = Concatenate(axis=1, name ="conc1-%i" % t)([x,window])
conc1 = Reshape((1,3+character_number), name = "reshape1-%i" % t)(conc1)
h1, _,c1 = LSTM_cell1(conc1, initial_state = [h1, c1])
output_wl = window_dense(h1)
alpha_hat, beta_hat, kappa_hat = Lambda(lambda x: [x[:,:K],x[:,K:2*K],x[:,2*K:3*K]],name="lamb2-%i" % t)(output_wl)
alpha = Lambda(lambda x: tf.expand_dims(tf.exp(x),axis=2),name="lamb3-%i" % t)(alpha_hat)
beta = Lambda(lambda x: tf.expand_dims(tf.exp(x),axis=2),name="lamb4-%i" % t)(beta_hat)
kappa = Lambda(lambda x: tf.expand_dims(tf.exp(x),axis=2),name="lamb5-%i" % t)(kappa_hat)
kappa = Add(name = "add1-%i" % t)([kappa,kappa_prev])
kappa_prev = kappa
un = Lambda(lambda x: tf.square(x-u), name = "lamb6-%i" % t)(kappa)
deux = Multiply(name = "mult1-%i" % t)([beta,un])
trois = Lambda(lambda x: tf.exp(-x), name = "lamb7-%i" % t)(deux)
quatro = Multiply(name = "mult2-%i" % t)([alpha,trois])
phi = Lambda(lambda x: tf.reduce_sum(x,axis = 1), name = "lamb8-%i" % t)(quatro)
window = Dot(axes = [1,1], name = "dot1-%i" % t)([phi,c_vec])
conc2 = Concatenate(axis = 1, name = "conc2-%i" % t)([x,h1,window])
conc2 = Reshape((1,3+character_number+400), name = "reshape2-%i" % t)(conc2)
h2,_,c2 = LSTM_cell2(conc2, initial_state = [h2, c2])
conc3 = Concatenate(axis = 1, name = "conc3-%i" % t)([x,h2,window])
conc3 = Reshape((1,3+character_number+400), name = "reshape3-%i" % t)(conc2)
h3,_,c3 = LSTM_cell3(conc3, initial_state = [h3, c3])
h = Concatenate(axis=1, name = "conc4-%i" % t)([h1,h2,h3])
y_hat = output_dense(h)
outputs.append(y_hat)
model = Model(inputs = [X,h10,c10,h20,c20,h30,c30,c_vec,init_window,init_kappa], outputs = outputs)
return model
def __call__(self):
logging.debug("Creating model...")
inputs = Input(shape=self._input_shape)
#-------------------------------------------------------------------------------------------------------------------------
x = Conv2D(32,(3,3))(inputs)
x = BatchNormalization(axis=self._channel_axis)(x)
x = Activation('relu')(x)
x_layer1 = AveragePooling2D(2,2)(x)
x = Conv2D(32,(3,3))(x_layer1)
x = BatchNormalization(axis=self._channel_axis)(x)
x = Activation('relu')(x)
x_layer2 = AveragePooling2D(2,2)(x)
x = Conv2D(32,(3,3))(x_layer2)
x = BatchNormalization(axis=self._channel_axis)(x)
x = Activation('relu')(x)
x_layer3 = AveragePooling2D(2,2)(x)
x = Conv2D(32,(3,3))(x_layer3)
x = BatchNormalization(axis=self._channel_axis)(x)
x = Activation('relu')(x)
#-------------------------------------------------------------------------------------------------------------------------
s = Conv2D(16,(3,3))(inputs)
s = BatchNormalization(axis=self._channel_axis)(s)
s = Activation('tanh')(s)
s_layer1 = MaxPooling2D(2,2)(s)
s = Conv2D(16,(3,3))(s_layer1)
s = BatchNormalization(axis=self._channel_axis)(s)
s = Activation('tanh')(s)
s_layer2 = MaxPooling2D(2,2)(s)
s = Conv2D(16,(3,3))(s_layer2)
s = BatchNormalization(axis=self._channel_axis)(s)
s = Activation('tanh')(s)
s_layer3 = MaxPooling2D(2,2)(s)
s = Conv2D(16,(3,3))(s_layer3)
s = BatchNormalization(axis=self._channel_axis)(s)
s = Activation('tanh')(s)
#-------------------------------------------------------------------------------------------------------------------------
# Classifier block
s_layer4 = Conv2D(10,(1,1),activation='relu')(s)
s_layer4 = Flatten()(s_layer4)
s_layer4_mix = Dropout(0.2)(s_layer4)
s_layer4_mix = Dense(units=self.stage_num[0], activation="relu")(s_layer4_mix)
x_layer4 = Conv2D(10,(1,1),activation='relu')(x)
x_layer4 = Flatten()(x_layer4)
x_layer4_mix = Dropout(0.2)(x_layer4)
x_layer4_mix = Dense(units=self.stage_num[0], activation="relu")(x_layer4_mix)
feat_a_s1_pre = Multiply()([s_layer4,x_layer4])
delta_s1 = Dense(1,activation='tanh',name='delta_s1')(feat_a_s1_pre)
feat_a_s1 = Multiply()([s_layer4_mix,x_layer4_mix])
feat_a_s1 = Dense(2*self.stage_num[0],activation='relu')(feat_a_s1)
pred_a_s1 = Dense(units=self.stage_num[0], activation="relu",name='pred_age_stage1')(feat_a_s1)
#feat_local_s1 = Lambda(lambda x: x/10)(feat_a_s1)
#feat_a_s1_local = Dropout(0.2)(pred_a_s1)
local_s1 = Dense(units=self.stage_num[0], activation='tanh', name='local_delta_stage1')(feat_a_s1)
#-------------------------------------------------------------------------------------------------------------------------
s_layer2 = Conv2D(10,(1,1),activation='relu')(s_layer2)
s_layer2 = MaxPooling2D(4,4)(s_layer2)
s_layer2 = Flatten()(s_layer2)
s_layer2_mix = Dropout(0.2)(s_layer2)
s_layer2_mix = Dense(self.stage_num[1],activation='relu')(s_layer2_mix)
x_layer2 = Conv2D(10,(1,1),activation='relu')(x_layer2)
x_layer2 = AveragePooling2D(4,4)(x_layer2)
x_layer2 = Flatten()(x_layer2)
x_layer2_mix = Dropout(0.2)(x_layer2)
x_layer2_mix = Dense(self.stage_num[1],activation='relu')(x_layer2_mix)
feat_a_s2_pre = Multiply()([s_layer2,x_layer2])
delta_s2 = Dense(1,activation='tanh',name='delta_s2')(feat_a_s2_pre)
feat_a_s2 = Multiply()([s_layer2_mix,x_layer2_mix])
feat_a_s2 = Dense(2*self.stage_num[1],activation='relu')(feat_a_s2)
pred_a_s2 = Dense(units=self.stage_num[1], activation="relu",name='pred_age_stage2')(feat_a_s2)
#feat_local_s2 = Lambda(lambda x: x/10)(feat_a_s2)
#feat_a_s2_local = Dropout(0.2)(pred_a_s2)
local_s2 = Dense(units=self.stage_num[1], activation='tanh', name='local_delta_stage2')(feat_a_s2)
#-------------------------------------------------------------------------------------------------------------------------
s_layer1 = Conv2D(10,(1,1),activation='relu')(s_layer1)
s_layer1 = MaxPooling2D(8,8)(s_layer1)
s_layer1 = Flatten()(s_layer1)
s_layer1_mix = Dropout(0.2)(s_layer1)
s_layer1_mix = Dense(self.stage_num[2],activation='relu')(s_layer1_mix)
x_layer1 = Conv2D(10,(1,1),activation='relu')(x_layer1)
x_layer1 = AveragePooling2D(8,8)(x_layer1)
x_layer1 = Flatten()(x_layer1)
x_layer1_mix = Dropout(0.2)(x_layer1)
x_layer1_mix = Dense(self.stage_num[2],activation='relu')(x_layer1_mix)
feat_a_s3_pre = Multiply()([s_layer1,x_layer1])
delta_s3 = Dense(1,activation='tanh',name='delta_s3')(feat_a_s3_pre)
feat_a_s3 = Multiply()([s_layer1_mix,x_layer1_mix])
feat_a_s3 = Dense(2*self.stage_num[2],activation='relu')(feat_a_s3)
pred_a_s3 = Dense(units=self.stage_num[2], activation="relu",name='pred_age_stage3')(feat_a_s3)
#feat_local_s3 = Lambda(lambda x: x/10)(feat_a_s3)
#feat_a_s3_local = Dropout(0.2)(pred_a_s3)
local_s3 = Dense(units=self.stage_num[2], activation='tanh', name='local_delta_stage3')(feat_a_s3)
#-------------------------------------------------------------------------------------------------------------------------
def merge_age(x,s1,s2,s3,lambda_local,lambda_d):
a = x[0][:,0]*0
b = x[0][:,0]*0
c = x[0][:,0]*0
A = s1*s2*s3
V = 101
for i in range(0,s1):
a = a+(i+lambda_local*x[6][:,i])*x[0][:,i]
a = a/(s1*(1+lambda_d*x[3]))
for j in range(0,s2):
b = b+(j+lambda_local*x[7][:,j])*x[1][:,j]
b = b/(s1*(1+lambda_d*x[3]))/(s2*(1+lambda_d*x[4]))
for k in range(0,s3):
c = c+(k+lambda_local*x[8][:,k])*x[2][:,k]
c = c/(s1*(1+lambda_d*x[3]))/(s2*(1+lambda_d*x[4]))/(s3*(1+lambda_d*x[5]))
a = (a+b+c)*V
return a
pred_a = Lambda(merge_age,arguments={'s1':self.stage_num[0],'s2':self.stage_num[1],'s3':self.stage_num[2],'lambda_local':self.lambda_local,'lambda_d':self.lambda_d},output_shape=(1,),name='pred_a')([pred_a_s1,pred_a_s2,pred_a_s3,delta_s1,delta_s2,delta_s3, local_s1, local_s2, local_s3])
model = Model(inputs=inputs, outputs=pred_a)
return model
def prepare_modelSingle(activ_func):
inputX = Input(shape=(
15,
1,
))
modelX = Sequential()
modelX.add(Lambda(lambda x: x[:, 0:10:2], input_shape=(15, 1)))
modelX.add(
LocallyConnected1D(filters=1,
kernel_size=(1),
strides=1,
kernel_initializer='ones',
activation=activ_func,
bias_initializer='ones'))
modelX.add(Flatten())
modelY = Sequential()
modelY.add(Lambda(lambda x: x[:, 1:11:2], input_shape=(15, 1)))
modelY.add(
LocallyConnected1D(filters=1,
kernel_size=(1),
strides=1,
kernel_initializer='ones',
activation=activ_func,
bias_initializer='ones'))
modelY.add(Flatten())
# confidence pairs
modelC = Sequential()
modelC.add(
Lambda(lambda x: 2.8532 * (x[:, 10:15] - 0.5383), input_shape=(15, 1)))
modelC.add(
LocallyConnected1D(filters=1,
kernel_size=(1),
strides=1,
kernel_initializer='ones',
kernel_regularizer=regularizers.l2(0.001),
activation='sigmoid',
use_bias=False))
modelC.add(Flatten())
modelX.build()
#modelX.summary()
modelC.build()
#modelC.summary()
x1 = modelX(inputX)
y1 = modelY(inputX)
c1 = modelC(inputX)
xMult = Multiply()(([x1, c1]))
yMult = Multiply()(([y1, c1]))
xyMerge = Concatenate()(([xMult, yMult]))
d0 = Dense(10,
kernel_initializer='he_normal',
kernel_regularizer=regularizers.l2(0.0001),
activation=activ_func)(xyMerge)
d1 = Dense(10,
kernel_initializer='he_normal',
kernel_regularizer=regularizers.l2(0.0001),
activation=activ_func)(d0)
out = Dense(3, kernel_initializer=my_init)(d1)
model = Model(inputs=inputX, outputs=out)
#model.summary()
return model
def se_block(input, channels, r=8):
x = Dense(channels // r, activation="relu")(input)
x = Dense(channels, activation="sigmoid")(x)
return Multiply()([input, x])
def attention_module_2(X, filters, base):
# Define filter channel
F1, F2, F3 = filters
# Define name
name_base = base
X = res_identity(X, filters, name_base + '/Pre_Residual_id')
X_Trunk = Trunk_block(X, filters, name_base + '/Trunk')
X = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name=name_base + '/Mask/pool_2')(X)
X = res_identity(X, filters, name_base + '/Mask/Residual_id_2_Down')
Residual_id_2_Down_shortcut = X
Residual_id_2_Down_branched = res_identity(
X, filters, name_base + '/Mask/Residual_id_2_Down_branched')
X = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name=name_base + '/Mask/pool_1')(X)
X = res_identity(X, filters, name_base + '/Mask/Residual_id_1_Down')
X = res_identity(X, filters, name_base + '/Mask/Residual_id_1_Up')
temp_name1 = name_base + "/Mask/Interpool_1"
X = Lambda(interpolation,
arguments={
'ref_tensor': Residual_id_2_Down_shortcut,
'name': temp_name1
})(X)
X = Add(name=base +
'/Mask/Add_after_Interpool_1')([X, Residual_id_2_Down_branched])
X = res_identity(X, filters, name_base + '/Mask/Residual_id_2_Up')
temp_name2 = name_base + "/Mask/Interpool_2"
X = Lambda(interpolation,
arguments={
'ref_tensor': X_Trunk,
'name': temp_name2
})(X)
X = BatchNormalization(axis=-1,
name=name_base + '/Mask/Interpool_2/bn_1')(X)
X = Activation('relu', name=name_base + '/Mask/Interpool_2/relu_1')(X)
X = Conv2D(F3,
kernel_size=(1, 1),
strides=(1, 1),
padding='valid',
name=name_base + '/Mask/Interpool_2/conv_1',
kernel_initializer=glorot_uniform())(X)
X = BatchNormalization(axis=-1,
name=name_base + '/Mask/Interpool_2/bn_2')(X)
X = Activation('relu', name=name_base + '/Mask/Interpool_2/relu_2')(X)
X = Conv2D(F3,
kernel_size=(1, 1),
strides=(1, 1),
padding='valid',
name=name_base + '/Mask/Interpool_2/conv_2',
kernel_initializer=glorot_uniform())(X)
X = Activation('sigmoid', name=name_base + '/Mask/sigmoid')(X)
X = Multiply(name=name_base + '/Multiply')([X_Trunk, X])
X = Add(name=name_base + '/Add')([X_Trunk, X])
X = res_identity(X, filters, name_base + '/Post_Residual_id')
return X
x1 = Embedding(train_y_notes.shape[1], 100)(notes_in)
x2 = Embedding(train_y_durations.shape[1], 100)(durations_in)
x = Concatenate()([x1, x2])
x = LSTM(512, return_sequences=True)(x)
x = LSTM(512, return_sequences=True)(x)
e = Dense(1, activation='tanh')(x)
e = Reshape([-1])(e)
alpha = Activation('softmax')(e)
alpha_repeated = Permute([2, 1])(RepeatVector(rnn_units)(alpha))
c = Multiply()([x, alpha_repeated])
c = Lambda(lambda xin: K.sum(xin, axis=1), output_shape=(rnn_units, ))(c)
notes_out = Dense(n_notes, activation='softmax', name='pitch')(c)
durations_out = Dense(n_durations, activation='softmax', name='duration')(c)
model = Model([notes_in, durations_in], [notes_out, durations_out])
notes_out = Dense(train_y_notes.shape[1], activation='softmax',
name='pitch')(c)
durations_out = Dense(train_y_durations.shape[1],
activation='softmax',
name='duration')(c)
model = Model([notes_in, durations_in], [notes_out, durations_out])
def get_model_0(num_users, num_items):
# only global coupling
num_users = num_users + 1
num_items = num_items + 1
######################## attr side ##################################
# Input
user_attr_input = Input(shape=(30,), dtype='float32', name='user_attr_input')
user_attr_embedding = Dense(8, activation='relu')(user_attr_input)
user_attr_embedding = Reshape((1, 8))(user_attr_embedding)
item_attr_input = Input(shape=(18,), dtype='float32', name='item_attr_input')
item_attr_embedding = Dense(8, activation='relu')(item_attr_input)
item_attr_embedding = Reshape((8, 1))(item_attr_embedding)
merge_attr_embedding = Lambda(lambda x: K.batch_dot(x[0], x[1], axes=[1, 2]))(
[user_attr_embedding, item_attr_embedding])
merge_attr_embedding_global = Flatten()(merge_attr_embedding)
#merge_attr_embedding = Reshape((8, 8, 1))(merge_attr_embedding)
#merge_attr_embedding = Conv2D(8, (3, 3))(merge_attr_embedding)
#merge_attr_embedding = BatchNormalization(axis=3)(merge_attr_embedding)
#merge_attr_embedding = Activation('relu')(merge_attr_embedding)
# merge_attr_embedding = AveragePooling2D((2, 2))(merge_attr_embedding)
# merge_attr_embedding = Dropout(0.35)(merge_attr_embedding)
# merge_attr_embedding = Conv2D(32, (3, 3))(merge_attr_embedding)
# merge_attr_embedding = BatchNormalization(axis=3)(merge_attr_embedding)
# merge_attr_embedding = Activation('relu')(merge_attr_embedding)
# merge_attr_embedding = MaxPooling2D((2, 2))(merge_attr_embedding)
#merge_attr_embedding = Conv2D(8, (3, 3))(merge_attr_embedding)
#merge_attr_embedding = BatchNormalization(axis=3)(merge_attr_embedding)
#merge_attr_embedding = Activation('relu')(merge_attr_embedding)
#merge_attr_embedding = Flatten()(merge_attr_embedding)
#merge_attr_embedding = merge([merge_attr_embedding, merge_attr_embedding_global], mode='concat')
attr_1 = Dense(16)(merge_attr_embedding_global)
attr_1 = Activation('relu')(attr_1)
# attr_1=BatchNormalization()(attr_1)
# attr_1=Dropout(0.2)(attr_1)
# attr_2 = Dense(16)(attr_1)
# attr_2 = Activation('relu')(attr_2)
# id_2=BatchNormalization()(id_2)
# id_2=Dropout(0.2)(id_2)
######################## id side ##################################
user_id_input = Input(shape=(1,), dtype='float32', name='user_id_input')
user_id_Embedding = Embedding(input_dim=num_users, output_dim=32, name='user_id_Embedding',
embeddings_initializer=RandomNormal(
mean=0.0, stddev=0.01, seed=None),
embeddings_regularizer=l2(0), input_length=1)
user_id_Embedding = Flatten()(user_id_Embedding(user_id_input))
item_id_input = Input(shape=(1,), dtype='float32', name='item_id_input')
item_id_Embedding = Embedding(input_dim=num_items, output_dim=32, name='item_id_Embedding',
embeddings_initializer=RandomNormal(
mean=0.0, stddev=0.01, seed=None),
embeddings_regularizer=l2(0), input_length=1)
item_id_Embedding = Flatten()(item_id_Embedding(item_id_input))
# id merge embedding
merge_id_embedding = Multiply()([user_id_Embedding, item_id_Embedding])
# id_1 = Dense(64)(merge_id_embedding)
# id_1 = Activation('relu')(id_1)
id_2 = Dense(32)(merge_id_embedding)
id_2 = Activation('relu')(id_2)
# merge attr_id embedding
merge_attr_id_embedding = Concatenate()([attr_1, id_2])
dense_1 = Dense(64)(merge_attr_id_embedding)
dense_1 = Activation('relu')(dense_1)
# dense_1=BatchNormalization()(dense_1)
# dense_1=Dropout(0.2)(dense_1)
# dense_2=Dense(16)(dense_1)
# dense_2=Activation('relu')(dense_2)
# dense_2=BatchNormalization()(dense_2)
# dense_2=Dropout(0.2)(dense_2)
# dense_3=Dense(8)(dense_2)
# dense_3=Activation('relu')(dense_3)
# dense_3=BatchNormalization()(dense_3)
# dense_3=Dropout(0.2)(dense_3)
topLayer = Dense(1, activation='sigmoid', kernel_initializer='lecun_uniform',
name='topLayer')(dense_1)
# Final prediction layer
model = Model(inputs=[user_attr_input, item_attr_input, user_id_input, item_id_input],
outputs=topLayer)
return model
source = embedding_layer(source_input)
target = embedding_layer(target_input)
avg_pool = AveragePooling1D(pool_size=seq_length)
reshape = Reshape([filter_num])
avg_source = reshape(avg_pool(source))
avg_target = reshape(avg_pool(target))
w = Dense(filter_num)
avg_source = w(avg_source)
avg_target = w(avg_target)
abs = Lambda(lambda x: kb.abs(x))
h_sub = abs(Subtract()([avg_source, avg_target]))
h_mul = Multiply()([avg_source, avg_target])
h_conc = Concatenate()([h_sub, h_mul])
logits = Dense(class_num, activation='softmax')(h_conc)
max_dev_pearson = 0.
max_test_pearson = 0.
model = Model(inputs=[source_input, target_input], outputs=logits)
model.compile(optimizer='Adam', loss=kl_distance, metrics=[pearson])
for epoch in range(epochs_num):
print('epoch num %s ' % epoch)
model.fit([train_sources, train_targets],
train_score_probs,
epochs=1,
batch_size=batch_size,
