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,