def get_model_bidirectional_avg(embed_size = 200 , embedding_matrix = None, num_lstm = 50 , rate_drop_dense = 0.1, num_dense = 50): if embedding_matrix is None: print(">> get_model_bidirectional_avg [no pre-trained word embeddings]<<") inp = Input(shape=(maxlen, )) x = Embedding(max_features, embed_size)(inp) else: print(">> get_model_bidirectional_avg [pre-trained word embeddings]<<") embedding_layer = Embedding(max_features,embed_size,weights=[embedding_matrix],input_length=maxlen,trainable=True) inp = Input(shape=(maxlen, ) , dtype='int32') x = embedding_layer(inp) x = Bidirectional(GRU(num_lstm, return_sequences=True))(x) x = Dropout(rate_drop_dense)(x) #add a GlobalAveragePooling1D, which will average the embeddings of all words in the document x = GlobalAveragePooling1D()(x) x = Dense(num_dense, activation="relu")(x) x = Dropout(rate_drop_dense)(x) #x = BatchNormalization()(x) x = Dense(6, activation="sigmoid")(x) model = Model(inputs=inp, outputs=x) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) return model
def build_decoder(self, input_shape, relu_target): '''Build the decoder architecture that reconstructs from a given VGG relu layer. Args: input_shape: Tuple of input tensor shape, needed for channel dimension relu_target: Layer of VGG to decode from ''' decoder_num = dict(zip(['relu1_1', 'relu2_1', 'relu3_1', 'relu4_1', 'relu5_1'], range(1,6)))[relu_target] # Dict specifying the layers for each decoder level. relu5_1 is the deepest decoder and will contain all layers decoder_archs = { 5: [ # layer filts HxW / InC->OutC (Conv2DReflect, 512), # 16x16 / 512->512 (UpSampling2D,), # 16x16 -> 32x32 (Conv2DReflect, 512), # 32x32 / 512->512 (Conv2DReflect, 512), # 32x32 / 512->512 (Conv2DReflect, 512)], # 32x32 / 512->512 4: [ (Conv2DReflect, 256), # 32x32 / 512->256 (UpSampling2D,), # 32x32 -> 64x64 (Conv2DReflect, 256), # 64x64 / 256->256 (Conv2DReflect, 256), # 64x64 / 256->256 (Conv2DReflect, 256)], # 64x64 / 256->256 3: [ (Conv2DReflect, 128), # 64x64 / 256->128 (UpSampling2D,), # 64x64 -> 128x128 (Conv2DReflect, 128)], # 128x128 / 128->128 2: [ (Conv2DReflect, 64), # 128x128 / 128->64 (UpSampling2D,)], # 128x128 -> 256x256 1: [ (Conv2DReflect, 64)] # 256x256 / 64->64 } code = Input(shape=input_shape, name='decoder_input_'+relu_target) x = code ### Work backwards from deepest decoder # and build layer by layer decoders = reversed(range(1, decoder_num+1)) count = 0 for d in decoders: for layer_tup in decoder_archs[d]: # Unique layer names are needed to ensure var naming consistency with multiple decoders in graph layer_name = '{}_{}'.format(relu_target, count) if layer_tup[0] == Conv2DReflect: x = Conv2DReflect(layer_name, filters=layer_tup[1], kernel_size=3, padding='valid', activation='relu', name=layer_name)(x) elif layer_tup[0] == UpSampling2D: x = UpSampling2D(name=layer_name)(x) count += 1 layer_name = '{}_{}'.format(relu_target, count) output = Conv2DReflect(layer_name, filters=3, kernel_size=3, padding='valid', activation=None, name=layer_name)(x) # 256x256 / 64->3 decoder_model = Model(code, output, name='decoder_model_'+relu_target) print(decoder_model.summary()) return decoder_model
def load_DAG_model(weight_file): model = None if weight_file.endswith('.weights'): model = init_model(weight_file, 25) elif weight_file.endswith('.h5') or weight_file.endswith('.hdf5'): darknet = DarkNet() model = SimpleNet(darknet) print model.layers[18] print model.layers[18].input_shape, model.layers[18].output_shape print model.layers[75] print model.layers[75].input_shape, model.layers[75].output_shape map56 = model.layers[18].output map56 = Convolution2D(128,3,3,init='he_uniform',border_mode='same')(map56) map56 = LeakyReLU(alpha=0.1)(map56) map56 = Convolution2D(32,3,3,init='he_uniform',border_mode='same')(map56) map56 = LeakyReLU(alpha=0.1)(map56) # map56 = Convolution2D(8,3,3,init='he_uniform',border_mode='same')(map56) # map56 = LeakyReLU(alpha=0.1)(map56) map56 = Convolution2D(4,3,3,init='he_uniform',border_mode='same')(map56) map56 = LeakyReLU(alpha=0.1)(map56) map56_flat = Flatten()(map56) map7_flat = model.layers[75].output concat = merge([map56_flat, map7_flat], mode='concat') fc = Dense(4096, init='he_uniform')(concat) fc = Dropout(0.5)(fc) fc = LeakyReLU(alpha=0.1)(fc) fc = Dense(1331, init='he_uniform')(fc) new_model = Model(input=model.inputs, output=fc) print new_model.layers[-1].output_shape print len(new_model.layers) if weight_file.endswith('.h5') or weight_file.endswith('.hdf5'): new_model.load_weights(weight_file) return new_model
def define_model(length, vocab_size): # channel 1: 三个 channel 只是对应的 kernel_size 不同, 表示使用不同的窗口大小来控制 n-gram; 4-grams, 6-grams, and 8-grams inputs1 = Input(shape=(length,)) embedding1 = Embedding(vocab_size, 100)(inputs1) conv1 = Conv1D(filters=32, kernel_size=4, activation='relu')(embedding1) drop1 = Dropout(0.5)(conv1) pool1 = MaxPooling1D(pool_size=2)(drop1) flat1 = Flatten()(pool1) # channel 2 inputs2 = Input(shape=(length,)) embedding2 = Embedding(vocab_size, 100)(inputs2) conv2 = Conv1D(filters=32, kernel_size=6, activation='relu')(embedding2) drop2 = Dropout(0.5)(conv2) pool2 = MaxPooling1D(pool_size=2)(drop2) flat2 = Flatten()(pool2) # channel 3 inputs3 = Input(shape=(length,)) embedding3 = Embedding(vocab_size, 100)(inputs3) conv3 = Conv1D(filters=32, kernel_size=8, activation='relu')(embedding3) drop3 = Dropout(0.5)(conv3) pool3 = MaxPooling1D(pool_size=2)(drop3) flat3 = Flatten()(pool3) # merge merged = concatenate([flat1, flat2, flat3]) # interpretation dense1 = Dense(10, activation='relu')(merged) outputs = Dense(1, activation='sigmoid')(dense1) model = Model(inputs=[inputs1, inputs2, inputs3], outputs=outputs) # compile model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) print(model.summary()) plot_model(model, show_shapes=True, to_file='tmp_multichannel.png') return model
def test_saving_multiple_metrics_outputs(): inputs = Input(shape=(5,)) x = Dense(5)(inputs) output1 = Dense(1, name='output1')(x) output2 = Dense(1, name='output2')(x) model = Model(inputs=inputs, outputs=[output1, output2]) metrics = {'output1': ['mse', 'binary_accuracy'], 'output2': ['mse', 'binary_accuracy'] } loss = {'output1': 'mse', 'output2': 'mse'} model.compile(loss=loss, optimizer='sgd', metrics=metrics) # assure that model is working x = np.array([[1, 1, 1, 1, 1]]) out = model.predict(x) _, fname = tempfile.mkstemp('.h5') save_model(model, fname) model = load_model(fname) os.remove(fname) out2 = model.predict(x) assert_allclose(out, out2, atol=1e-05)
def test_layer_sharing_at_heterogeneous_depth_with_concat(): input_shape = (16, 9, 3) input_layer = Input(shape=input_shape) A = Dense(3, name='dense_A') B = Dense(3, name='dense_B') C = Dense(3, name='dense_C') x1 = B(A(input_layer)) x2 = A(C(input_layer)) output = layers.concatenate([x1, x2]) M = Model(inputs=input_layer, outputs=output) x_val = np.random.random((10, 16, 9, 3)) output_val = M.predict(x_val) config = M.get_config() weights = M.get_weights() M2 = Model.from_config(config) M2.set_weights(weights) output_val_2 = M2.predict(x_val) np.testing.assert_allclose(output_val, output_val_2, atol=1e-6)
def originalimages_fine_tune(pic_shape, nb_classes): ''' :param pic_shape:输入向量的shape,由于是微调,所以shape一般是(256, 16, 16) [(filter_num, new_pic_shape, new_pic_shape)] :param nb_classes: :return: ''' input_layer = Input(shape=pic_shape) # 16x16 -> 8x8 conv1 = conv2D_bn(input_layer, 512, 3, 3, subsample=(1, 1), border_mode='same') conv1 = conv2D_bn(conv1, 512, 3, 3, subsample=(1, 1), border_mode='same') pool1 = MaxPooling2D((2, 2), strides=(2, 2), dim_ordering=DIM_ORDERING)(conv1) # 8x8 -> 8x8 conv2 = conv2D_bn(pool1, 512, 3, 3, subsample=(1, 1), border_mode='same') conv2 = conv2D_bn(conv2, 512, 3, 3, subsample=(1, 1), border_mode='same') flatten = merge([pool1, conv2], mode='concat', concat_axis=CONCAT_AXIS) flatten = Flatten()(flatten) flatten = Dropout(0.5)(flatten) fc1 = Dense(2048, activation='relu')(flatten) fc1 = Dropout(0.5)(fc1) fc2 = Dense(1024, activation='relu')(fc1) fc2 = Dropout(0.5)(fc2) preds = Dense(nb_classes, activation='softmax')(fc2) model = Model(input=input_layer, output=preds) print model.summary() return model
def full_model(summary = True): input_img = Input(shape=(m, n, 1)) generator = generator_model(input_img) feat = feat_model(generator) model = Model(input=input_img, output=[generator, feat], name='architect') model.summary() return model
def test_multiple_outputs(): def func(x): return [x * 0.2, x * 0.3] def output_shape(input_shape): return [input_shape, input_shape] def mask(inputs, mask=None): return [None, None] i = layers.Input(shape=(64, 64, 3)) o = layers.Lambda(function=func, output_shape=output_shape, mask=mask)(i) o1, o2 = o assert o1._keras_shape == (None, 64, 64, 3) assert o2._keras_shape == (None, 64, 64, 3) model = Model(i, o) x = np.random.random((4, 64, 64, 3)) out1, out2 = model.predict(x) assert out1.shape == (4, 64, 64, 3) assert out2.shape == (4, 64, 64, 3) assert_allclose(out1, x * 0.2, atol=1e-4) assert_allclose(out2, x * 0.3, atol=1e-4)
def size_inference_model(self, trained_model=None): print('Building size inference model') state_dims = cfg.STATE_DIMS feat_dims = cfg.STATE_DIMS#cfg.FEAT_DIMS ######################################################################## # Input ######################################################################## input_feat = Input(batch_shape=(1, feat_dims[0], feat_dims[1], feat_dims[2]), \ name='input_feat') input_roi = Input(batch_shape=(1, state_dims[0], state_dims[1]), \ name='input_roi') # size branch rois = Reshape((state_dims[0] * state_dims[1], ))(input_roi) rois = RepeatVector(state_dims[2])(rois) rois = Permute((2, 1))(rois) rois = Reshape((state_dims[0], state_dims[1], state_dims[2]))(rois) size_hidden = Conv2D(state_dims[2], (3, 3), dilation_rate=2, padding='same', activation='relu')(input_feat) size_hidden = keras.layers.multiply([size_hidden, rois]) size_hidden = GlobalMaxPooling2D()(size_hidden) size_hidden = Dense(self.size_dims, activation = 'relu')(size_hidden) size_output = Dense(self.size_dims, activation = 'softmax', name = 'output_size')(size_hidden) ######################################################################## # Compile inference model ######################################################################## inference_model = Model(inputs = [input_feat, input_roi], outputs = size_output) # print(inference_model.summary()) if trained_model is not None: inference_model.set_weights(self.get_size_branch_weights(trained_model)) return inference_model
def get_model(embedding_lookup_table, dropout, spatial_dropout): input_layer = Input(shape=(MAX_SEQUENCE_LENGTH,), dtype='int32') embedding_layer = Embedding( input_dim=embedding_lookup_table.shape[0], output_dim=embedding_lookup_table.shape[1], weights=[embedding_lookup_table], # trainable=False )(input_layer) layer = embedding_layer maxpool_embed = GlobalMaxPooling1D()(layer) # spatial_dropout = spatial_dropout - 0.002 + np.random.rand() * 0.004 embed_after_sdp = SpatialDropout1D(spatial_dropout)(layer) print('spatial dropout : {0}'.format(spatial_dropout)) gru_one = Bidirectional(CuDNNGRU(units=64, return_sequences=True))(embed_after_sdp) # hyper-parameter vibration dropout = dropout - 0.002 + np.random.rand() * 0.004 print('dropout : {0}'.format(dropout)) gru_one_after_dp = Dropout(dropout)(gru_one) gru_two = Bidirectional(CuDNNGRU(units=64, return_sequences=True))(gru_one_after_dp) layer = concatenate([gru_two, gru_one, maxpool_embed]) layer = AttentionWeightedAverage()(layer) output_layer = Dense(6, activation='sigmoid')(layer) model = Model(inputs=input_layer, outputs=output_layer) model.compile(loss='binary_crossentropy', optimizer=Nadam(), metrics=['acc']) return model
def autoEncoderGen(path, input_shape=theShape): if os.path.exists(path): print('loading: ' + str(sorted(os.listdir('models/'))[-1])) autoencoder = load_model(os.path.join('models', sorted(os.listdir('models/'))[-1])) name = str(sorted(os.listdir('models/'))[-1]) print('loaded: ' + name) else: print('No previous model found.') print('Building a new model.') input_img = Input(shape=input_shape) # adapt this if using `channels_first` image data format x = UpSampling2D((2, 2))(input_img) x = Conv2D(16, (3, 3), activation='relu', padding='same')(x) x = UpSampling2D((2,2))(x) x = Conv2D(8, (5, 5), activation='relu', padding='same')(x) x = Conv2D(8, (3, 3), activation='relu', padding='same')(x) encoded = x x = Conv2D(8, (3, 3), activation='relu', padding='same')(encoded) x = Conv2D(8, (5, 5), activation='relu', padding='same')(x) x = Conv2D(16, (3, 3), activation='relu', padding='same')(x) decoded = Conv2D(3, (3, 3), activation='relu', padding='same')(x) autoencoder = Model(input_img, decoded) autoencoder.compile(optimizer='adam', loss='binary_crossentropy') autoencoder.save('models/autoencoder.h5') name = 'autoencoderV.h5' eye_temp = name.replace('.h5', '') try: eye = int(eye_temp.replace('autoencoderV', '')) - 10000000 except ValueError: eye = 0 return autoencoder, name, eye
def build_model(processor): logging.info('Build model...') action_input = Input(shape=(INPUT_LENGTH, INPUT_DIM)) actual_flop_input = Input(shape=(INPUT_LENGTH, FLOP_DIM)) flop_input = actual_flop_input # 2 dense layers to encode flop for dim in FLOP_INTER_DIM: flop_input = TimeDistributed(Dense(dim))(flop_input) seq = merge([action_input, flop_input], mode='concat', concat_axis=2) for dim in INTER_DIM: seq = LSTM(dim, return_sequences=True, dropout_W=0.2, dropout_U=0.2, consume_less=processor)(seq) seq = TimeDistributed(Dense(OUTPUT_DIM))(seq) probs = Activation('softmax')(seq) model = Model(input=[action_input, actual_flop_input], output=probs) # try using different optimizers and different optimizer configs model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy']) # plot(model, to_file='model.png', show_shapes=True, show_layer_names=True) return model
class GAN(object): def __init__(self, model_inputs=[],model_outputs=[], name='gan'): self.OPTIMIZER = SGD(lr=2e-4,nesterov=True) self.NAME=name self.inputs = model_inputs self.outputs = model_outputs self.gan_model = Model(inputs = self.inputs, outputs = self.outputs) self.OPTIMIZER = SGD(lr=0.001) self.gan_model.compile(loss=[self_regularization_loss, self_regularization_loss], optimizer=self.OPTIMIZER) self.save_model_graph() self.summary() def summary(self): return self.gan_model.summary() def save_model_graph(self): plot_model(self.gan_model, to_file='/out/GAN_Model.png') def save_model(self,epoch,batch): self.gan_model.save('/out/'+self.NAME+'_Epoch_'+epoch+'_Batch_'+batch+'model.h5') def self_regularization_loss(self,y_true,y_pred): return tf.multiply(0.0002,tf.reduce_sum(tf.abs(y_pred-y_true))) def local_adversarial_loss(self,y_true,y_pred): truth = tf.reshape(y_true,(-1,2)) predicted = tf.reshape(y_pred,(-1,2)) computed_loss = tf.nn.softmax_cross_entropy_with_logits(labels=truth,logits=predicted) output = tf.reduce_mean(computed_loss) return output
def build_model(num_users, num_items, latent_dim): positive_item_input = Input((1, ), name='positive_item_input') negative_item_input = Input((1, ), name='negative_item_input') # Shared embedding layer for positive and negative items item_embedding_layer = Embedding( num_items, latent_dim, name='item_embedding', input_length=1) user_input = Input((1, ), name='user_input') positive_item_embedding = Flatten()(item_embedding_layer( positive_item_input)) negative_item_embedding = Flatten()(item_embedding_layer( negative_item_input)) user_embedding = Flatten()(Embedding( num_users, latent_dim, name='user_embedding', input_length=1)( user_input)) loss = merge( [positive_item_embedding, negative_item_embedding, user_embedding], mode=bpr_triplet_loss, name='loss', output_shape=(1, )) model = Model( input=[positive_item_input, negative_item_input, user_input], output=loss) model.compile(loss=identity_loss, optimizer=Adam()) return model
def compile(self, optimizer, metrics=[]): metrics += [mean_q] # register default metrics # Create target V model. We don't need targets for mu or L. self.target_V_model = clone_model(self.V_model, self.custom_model_objects) self.target_V_model.compile(optimizer='sgd', loss='mse') # Build combined model. observation_shape = self.V_model.input._keras_shape[1:] a_in = Input(shape=(self.nb_actions,), name='action_input') o_in = Input(shape=observation_shape, name='observation_input') L_out = self.L_model([a_in, o_in]) V_out = self.V_model(o_in) mu_out = self.mu_model(o_in) A_out = NAFLayer(self.nb_actions)(merge([L_out, mu_out, a_in], mode='concat')) combined_out = merge([A_out, V_out], mode='sum') combined = Model(input=[a_in, o_in], output=combined_out) # Compile combined model. if self.target_model_update < 1.: # We use the `AdditionalUpdatesOptimizer` to efficiently soft-update the target model. updates = get_soft_target_model_updates(self.target_V_model, self.V_model, self.target_model_update) optimizer = AdditionalUpdatesOptimizer(optimizer, updates) def clipped_mse(y_true, y_pred): delta = K.clip(y_true - y_pred, self.delta_range[0], self.delta_range[1]) return K.mean(K.square(delta), axis=-1) combined.compile(loss=clipped_mse, optimizer=optimizer, metrics=metrics) self.combined_model = combined self.compiled = True
def test_shared_batchnorm(): '''Test that a BN layer can be shared across different data streams. ''' # Test single layer reuse bn = normalization.BatchNormalization(input_shape=(10,), mode=0) x1 = Input(shape=(10,)) bn(x1) x2 = Input(shape=(10,)) y2 = bn(x2) x = np.random.normal(loc=5.0, scale=10.0, size=(2, 10)) model = Model(x2, y2) assert len(model.updates) == 2 model.compile('sgd', 'mse') model.train_on_batch(x, x) # Test model-level reuse x3 = Input(shape=(10,)) y3 = model(x3) new_model = Model(x3, y3) assert len(model.updates) == 2 new_model.compile('sgd', 'mse') new_model.train_on_batch(x, x)
def baseline_train(noise_examples, hidden_size, noise_dim, glove, hypo_len, version): prem_input = Input(shape=(None,), dtype='int32', name='prem_input') hypo_input = Input(shape=(hypo_len + 1,), dtype='int32', name='hypo_input') noise_input = Input(shape=(1,), dtype='int32', name='noise_input') train_input = Input(shape=(None,), dtype='int32', name='train_input') class_input = Input(shape=(3,), name='class_input') concat_dim = hidden_size + noise_dim + 3 prem_embeddings = make_fixed_embeddings(glove, None)(prem_input) hypo_embeddings = make_fixed_embeddings(glove, hypo_len + 1)(hypo_input) premise_layer = LSTM(output_dim=hidden_size, return_sequences=False, inner_activation='sigmoid', name='premise')(prem_embeddings) noise_layer = Embedding(noise_examples, noise_dim, input_length = 1, name='noise_embeddings')(noise_input) flat_noise = Flatten(name='noise_flatten')(noise_layer) merged = merge([premise_layer, class_input, flat_noise], mode='concat') creative = Dense(concat_dim, name = 'cmerge')(merged) fake_merge = Lambda(lambda x:x[0], output_shape=lambda x:x[0])([hypo_embeddings, creative]) hypo_layer = FeedLSTM(output_dim=concat_dim, return_sequences=True, feed_layer = creative, inner_activation='sigmoid', name='attention')([fake_merge]) hs = HierarchicalSoftmax(len(glove), trainable = True, name='hs')([hypo_layer, train_input]) inputs = [prem_input, hypo_input, noise_input, train_input, class_input] model_name = 'version' + str(version) model = Model(input=inputs, output=hs, name = model_name) model.compile(loss=hs_categorical_crossentropy, optimizer='adam') return model
def baseline_test(train_model, glove, batch_size): version = int(train_model.name[-1]) hidden_size = train_model.get_layer('attention').output_shape[-1] premise_input = Input(batch_shape=(batch_size, None, None)) hypo_input = Input(batch_shape=(batch_size, 1), dtype='int32') creative_input = Input(batch_shape=(batch_size, None)) train_input = Input(batch_shape=(batch_size, 1), dtype='int32') hypo_embeddings = make_fixed_embeddings(glove, 1)(hypo_input) hypo_layer = FeedLSTM(output_dim=hidden_size, return_sequences=True, stateful = True, trainable= False, feed_layer = premise_input, name='attention')([hypo_embeddings]) hs = HierarchicalSoftmax(len(glove), trainable = False, name ='hs')([hypo_layer, train_input]) inputs = [hypo_input, creative_input, train_input] outputs = [hs] model = Model(input=inputs, output=outputs, name=train_model.name) model.compile(loss=hs_categorical_crossentropy, optimizer='adam') update_gen_weights(model, train_model) f_inputs = [train_model.get_layer('noise_embeddings').output, train_model.get_layer('class_input').input, train_model.get_layer('prem_input').input] func_noise = theano.function(f_inputs, train_model.get_layer('cmerge').output, allow_input_downcast=True) return model, None, func_noise
def build_generator(self): noise = Input(shape=(self.latent_dim,)) x = Dense(32 * self.img_rows * self.img_cols, activation='relu')(noise) x = Reshape((self.img_rows, self.img_cols, 32))(x) x = Conv2DTranspose(512, kernel_size=3, padding='same')(x) x = BatchNormalization(momentum=0.8)(x) x = Activation("relu")(x) x = Conv2DTranspose(256, kernel_size=3, strides=1, padding="same")(x) x = BatchNormalization(momentum=0.8)(x) x = Activation("relu")(x) x = Conv2DTranspose(128, kernel_size=3, strides=1, padding="same")(x) x = BatchNormalization(momentum=0.8)(x) x = Activation("relu")(x) x = Conv2DTranspose(self.channels, kernel_size=3, padding="same")(x) img = Activation("tanh")(x) model = Model(noise, img) model.summary() return model
def autoe_train(hidden_size, noise_dim, glove, hypo_len, version): prem_input = Input(shape=(None,), dtype='int32', name='prem_input') hypo_input = Input(shape=(hypo_len + 1,), dtype='int32', name='hypo_input') train_input = Input(shape=(None,), dtype='int32', name='train_input') class_input = Input(shape=(3,), name='class_input') prem_embeddings = make_fixed_embeddings(glove, None)(prem_input) hypo_embeddings = make_fixed_embeddings(glove, hypo_len + 1)(hypo_input) premise_encoder = LSTM(output_dim=hidden_size, return_sequences=True, inner_activation='sigmoid', name='premise_encoder')(prem_embeddings) hypo_encoder = LSTM(output_dim=hidden_size, return_sequences=True, inner_activation='sigmoid', name='hypo_encoder')(hypo_embeddings) class_encoder = Dense(hidden_size, activation='tanh')(class_input) encoder = LstmAttentionLayer(output_dim=hidden_size, return_sequences=False, feed_state = True, name='encoder') ([hypo_encoder, premise_encoder, class_encoder]) if version == 6: reduction = Dense(noise_dim, name='reduction', activation='tanh')(encoder) elif version == 7: z_mean = Dense(noise_dim, name='z_mean')(encoder) z_log_sigma = Dense(noise_dim, name='z_log_sigma')(encoder) def sampling(args): z_mean, z_log_sigma = args epsilon = K.random_normal(shape=(64, noise_dim,), mean=0., std=0.01) return z_mean + K.exp(z_log_sigma) * epsilon reduction = Lambda(sampling, output_shape=lambda sh: (sh[0][0], noise_dim,), name = 'reduction')([z_mean, z_log_sigma]) def vae_loss(args): z_mean, z_log_sigma = args return - 0.5 * K.mean(1 + z_log_sigma - K.square(z_mean) - K.exp(z_log_sigma), axis=-1) vae = Lambda(vae_loss, output_shape=lambda sh: (sh[0][0], 1,), name = 'vae_output')([z_mean, z_log_sigma]) merged = merge([class_input, reduction], mode='concat') creative = Dense(hidden_size, name = 'expansion', activation ='tanh')(merged) premise_decoder = LSTM(output_dim=hidden_size, return_sequences=True, inner_activation='sigmoid', name='premise')(prem_embeddings) hypo_decoder = LSTM(output_dim=hidden_size, return_sequences=True, inner_activation='sigmoid', name='hypo')(hypo_embeddings) attention = LstmAttentionLayer(output_dim=hidden_size, return_sequences=True, feed_state = True, name='attention') ([hypo_decoder, premise_decoder, creative]) hs = HierarchicalSoftmax(len(glove), trainable = True, name='hs')([attention, train_input]) inputs = [prem_input, hypo_input, train_input, class_input] model_name = 'version' + str(version) model = Model(input=inputs, output=(hs if version == 6 else [hs, vae]), name = model_name) if version == 6: model.compile(loss=hs_categorical_crossentropy, optimizer='adam') elif version == 7: def minimize(y_true, y_pred): return y_pred def metric(y_true, y_pred): return K.mean(y_pred) model.compile(loss=[hs_categorical_crossentropy, minimize], metrics={'hs':word_loss, 'vae_output': metric}, optimizer='adam') return model
def build_net_CNN(self, load_weights = False): img = Input(batch_shape=(10, self.img_channels, self.img_rows, self.img_cols), name='input_img') model_in = MaskedConvolution2D(self.h,7,7,mask_type='a', direction='Right', border_mode='same', init='he_uniform')(img) for _ in range(15): model_in = MaskedConvolution2D(self.h,3,3,mask_type='b', direction='Right', border_mode='same', init='he_uniform')(model_in) model_out = MaskedConvolution2D(self.h,1,1,mask_type='b', direction='Right', border_mode='same', activation='relu', init='he_uniform')(model_in) model_out = MaskedConvolution2D(256*3,1,1,mask_type='b', direction='Right', border_mode='same', activation='relu', init='he_uniform')(model_out) Red = GetColors(0)(model_out) Green = GetColors(1)(model_out) Blue = GetColors(2)(model_out) Red_out = SoftmaxLayer(name='Red_out')(Red) Green_out = SoftmaxLayer(name='Green_out')(Green) Blue_out = SoftmaxLayer(name='Blue_out')(Blue) Col_Model = Model(img, [Red_out, Green_out, Blue_out]) if load_weights: Col_Model.load_weights('Data/comp_model.h5') print("Compiling...") Col_Model.compile(optimizer=self.optimizer, loss={'Red_out': image_categorical_crossentropy, 'Green_out': image_categorical_crossentropy, 'Blue_out': image_categorical_crossentropy}, metrics={'Red_out': 'accuracy', 'Green_out': 'accuracy', 'Blue_out': 'accuracy'}) self.comp_net = Col_Model
def test_recurrent_wrapper__sequence_inputs(): """The hidden state is not returned, but mapped by an output model. """ def build_recurrent(): input_current = Input(shape=(10,)) input_seq = Input(shape=(None, 10)) hidden = Input(shape=(128,)) seq = GlobalAveragePooling1D()(input_seq) new_hidden = merge([ Dense(128, activation='relu')(seq), Dense(128, activation='relu')(input_current), hidden ], mode='sum') new_hidden = Activation('sigmoid')(new_hidden) return RecurrentWrapper( input=[input_current], sequence_input=[input_seq], output=[new_hidden], bind={ hidden: new_hidden }, return_sequences=True, ) seq = Input((None, 10)) output = build_recurrent()([seq, seq]) m = Model(input=[seq], output=[output]) assert m.predict(np.random.uniform(size=(30, 20, 10))).shape == (30, 20, 128)
def _residual_block(self, injection_index, new_layers, m, member_number): #get output shape of last layer before injection from m if injection_index > 0: input_shape = m.layers[injection_index - 1].output_shape else: input_shape = m.input_shape #make input input_layer = Input(shape = input_shape[1:], name = "Input_BARN_{0}".format(member_number)) #make real layers real_layers = input_layer for i,l in enumerate(new_layers): l['config']['name'] = "BARN-incremental-{0}-{1}".format( member_number, i) real_layers = layer_from_config(l)(real_layers) #make skip layer stride_width = input_shape[2] / real_layers._keras_shape[2] stride_height = input_shape[3] / real_layers._keras_shape[3] equal_channels = real_layers._keras_shape[1] == input_shape[1] shortcut = input_layer # 1 X 1 conv if shape is different. Else identity. if (stride_width > 1 or stride_height > 1 or not equal_channels) and stride_width > 0 and stride_height > 0: shortcut = Convolution2D(nb_filter=real_layers._keras_shape[1], nb_row=1, nb_col=1, subsample=(stride_width, stride_height), init="he_normal", border_mode="same", name="shortcut_BARN_{0}".format(member_number))(input_layer) #make merge merge_layer = merge([real_layers,shortcut], mode="sum", name = "merge_BARN_{0}".format(member_number)) #make model model = Model(input=input_layer,output=merge_layer, name="Model_BARN_{0}".format(member_number)) #make config return {"class_name": "Model", "config": model.get_config()}
def test_recurrent_wrapper__multiple_inputs(): def build_recurrent(): hidden = Input((128,)) input_x = Input((10,)) input_y = Input((5,)) x = Dense(128, activation='relu')(input_x) y = Dense(128, activation='relu')(input_y) x = merge([hidden, x, y], mode='sum') new_hidden = Activation('sigmoid')(x) return RecurrentWrapper( input=[input_x, input_y], output=[new_hidden], bind={hidden: new_hidden}, return_sequences=True, ) x = Input((None, 10)) y = Input((None, 5)) u = build_recurrent()([x, y]) m = Model(input=[x, y], output=[u]) actual = m.predict([ np.random.uniform(size=(30, 20, 10)), np.random.uniform(size=(30, 20, 5)) ]) assert actual.shape == (30, 20, 128)
def cnn_rnn_model(input_dim, filters, kernel_size, conv_stride, conv_border_mode, units, output_dim=29): """ Build a recurrent + convolutional network for speech """ # Main acoustic input input_data = Input(name='the_input', shape=(None, input_dim)) # Add convolutional layer conv_1d = Conv1D(filters, kernel_size, strides=conv_stride, padding=conv_border_mode, activation='relu', name='conv1d')(input_data) # Add batch normalization bn_cnn = BatchNormalization(name='bn_conv_1d')(conv_1d) # Add a recurrent layer #simp_rnn = SimpleRNN(units, activation='relu', simp_rnn = GRU(units, activation='relu', return_sequences=True, implementation=2, name='rnn')(bn_cnn) # TODO-DONE: Add batch normalization bn_rnn = BatchNormalization(name='bn_rnn')(simp_rnn) # TODO-DONE: Add a TimeDistributed(Dense(output_dim)) layer time_dense = TimeDistributed(Dense(output_dim))(bn_rnn) # Add softmax activation layer y_pred = Activation('softmax', name='softmax')(time_dense) # Specify the model model = Model(inputs=input_data, outputs=y_pred) model.output_length = lambda x: cnn_output_length( x, kernel_size, conv_border_mode, conv_stride) print(model.summary()) return model
def VGG16_Model(img_rows=224, img_cols=224, train=False): if K.image_data_format() == 'channels_first': shape_ord = (3, img_rows, img_cols) else: # channel_last shape_ord = (img_rows, img_cols, 3) vgg16_model = vgg16.VGG16(weights=None, include_top=False, input_tensor=Input(shape_ord)) # vgg16_model.summary() for layer in vgg16_model.layers: layer.trainable = train # freeze layer #add last fully-connected layers x = Flatten(input_shape=vgg16_model.output.shape)(vgg16_model.output) x = Dense(4096, activation='relu', name='ft_fc1')(x) x = Dropout(0.5)(x) x = BatchNormalization()(x) predictions = Dense(43, activation='softmax')(x) model = Model(inputs=vgg16_model.input, outputs=predictions) #compile the model model.compile(optimizer=optimizers.SGD(lr=1e-4, momentum=0.9), loss='categorical_crossentropy', metrics=['accuracy']) for layer in model.layers: layer.trainable = train # freeze layer return model
def age_gender_model(input_shape, nb_classes): """ """ resnet_base = ResNet50(include_top = False, weights = 'imagenet',input_tensor = None, input_shape = input_shape ,pooling = 'max') for layer in resnet_base.layers: layer.trainable = False #x = Flatten()(x) x = Dense(1024, activation = "relu",name='dense-1')(resnet_base.output) x = Dropout(rate = 0.5)(x) x = Dense(512, activation = "relu",name='dense-2')(x) x = Dropout(rate = 0.5)(x) x = Dense(512, activation ="relu",name='dense-3')(x) x = Dropout(rate = 0.5)(x) x = Dense(256, activation ="relu",name='dense-4')(x) x = Dropout(rate = 0.5)(x) predictions = Dense(nb_classes, activation="softmax",name="softmax")(x) model = Model(inputs = resnet_base.input, outputs = predictions) print(model.summary()) return model
def test_build_feature_space(replay, epoch_models): from deepreplay.plot import build_2d_grid from keras.models import Model contour_points = 30 _, ax = plt.subplots(1, 1) replay.build_feature_space(ax, 'hidden', contour_points=contour_points, epoch_start=2, epoch_end=19) _, data = replay.feature_space _, bent_line, actual_prediction, _ = data _, _, actual_bent_contour = bent_line contour_lines = build_2d_grid((-1, 1), (-1, 1), contour_points, contour_points).reshape(-1, 2) expected_prediction = [] expected_bent_contour = [] for model in epoch_models[1:-1]: expected_prediction.append(model.predict_classes(contour_lines)) activations = Model(inputs=model.input, outputs=model.get_layer('hidden').output) expected_bent_contour.append(activations.predict(contour_lines)) expected_prediction = np.array(expected_prediction).reshape(18, contour_points, contour_points) expected_bent_contour = np.array(expected_bent_contour).reshape(18, contour_points, contour_points, 2) npt.assert_allclose(actual_prediction.squeeze(), expected_prediction, atol=1e-5) npt.assert_allclose(actual_bent_contour.squeeze(), expected_bent_contour, atol=1e-5)
def get_model(embedding_lookup_table, dropout, spatial_dropout): input_layer = Input(shape=(MAX_SEQUENCE_LENGTH,), dtype='int32') embedding_layer = Embedding( input_dim=embedding_lookup_table.shape[0], output_dim=embedding_lookup_table.shape[1], weights=[embedding_lookup_table], trainable=False )(input_layer) layer = embedding_layer layer = SpatialDropout1D(spatial_dropout)(layer) print('spatial dropout : {0}'.format(spatial_dropout)) # hyper-parameter vibration dropout = dropout - 0.002 + np.random.rand() * 0.004 print('dropout : {0}'.format(dropout)) layer = Bidirectional(CuDNNGRU(units=64, return_sequences=True))(layer) layer = Dropout(dropout)(layer) layer = Bidirectional(CuDNNGRU(units=64, return_sequences=False))(layer) layer = Dense(400, kernel_initializer='he_normal')(layer) layer = PReLU()(layer) layer = BatchNormalization()(layer) layer = Dropout(dropout)(layer) output_layer = Dense(6, activation='sigmoid')(layer) model = Model(inputs=input_layer, outputs=output_layer) model.compile(loss='binary_crossentropy', optimizer=Nadam(), metrics=['acc']) return model
model = load_model("model_9.h5") model._make_predict_function() # In[3]: model_temp = ResNet50(weights="imagenet",input_shape=(224,224,3)) model_temp.summary() # In[4]: model_resnet = Model(model_temp.input,model_temp.layers[-2].output) model_resnet._make_predict_function() # In[5]: def preprocess_img(img): img = image.load_img(img,target_size=(224,224)) img = image.img_to_array(img) img = np.expand_dims(img,axis=0) # Normalisation img = preprocess_input(img) return img # In[6]:
# validation_steps=5000) # classifier.save('catdog_cnn_model.h5') # classifier = load_model('catdog_cnn_model.h5') # classifier.fit(X_train, y_train) # y_pred=classifier.predict(X_test) # k.history.keys() scores = classifier.evaluate(X_validation, Y_validation, verbose=0) print("%s: %.2f%%" % (classifier.metrics_names[1], scores[1] * 100)) # print("%s: %.2f%%" % (classifier.metrics_names[0], scores[0]*100)) from keras.models import Model import matplotlib.pyplot as plt layer_outputs = [layer.output for layer in classifier.layers] activation_model = Model(inputs=classifier.input, outputs=layer_outputs) activations = activation_model.predict(X_train[2].reshape(1, 150, 150, 3)) def display_activation(activations, col_size, row_size, act_index): activation = activations[act_index] activation_index = 0 fig, ax = plt.subplots(row_size, col_size, figsize=(row_size * 2.5, col_size * 1.5)) for row in range(0, row_size): for col in range(0, col_size): ax[row][col].imshow(activation[0, :, :, activation_index], cmap='viridis') activation_index += 1
def train_and_predict(x_train, y_train, x_valid, y_valid, fold): # data augmentation x_train = np.append(x_train, [np.fliplr(x) for x in x_train], axis=0) y_train = np.append(y_train, [np.fliplr(x) for x in y_train], axis=0) print("x_train after hflip", x_train.shape) print("y_train after hflip", y_valid.shape) # model input_layer = Input((img_size_target, img_size_target, 3)) output_layer = build_model(input_layer, 16, 0.5) model1 = Model(input_layer, output_layer) c = optimizers.adam(lr=0.005) model1.compile(loss="binary_crossentropy", optimizer=c, metrics=[my_iou_metric]) save_model_name = f"{basic_name}_stage1_fold{fold}.hdf5" early_stopping = EarlyStopping(monitor='my_iou_metric', mode='max', patience=15, verbose=1) model_checkpoint = ModelCheckpoint(save_model_name, monitor='my_iou_metric', mode='max', save_best_only=True, verbose=1) reduce_lr = ReduceLROnPlateau(monitor='my_iou_metric', mode='max', factor=0.5, patience=5, min_lr=0.0001, verbose=1) epochs = 80 batch_size = 128 if not PREDICT_ONLY: history = model1.fit( x_train, y_train, validation_data=[x_valid, y_valid], epochs=epochs, batch_size=batch_size, callbacks=[early_stopping, model_checkpoint, reduce_lr], verbose=2) model1 = load_model(save_model_name, custom_objects={'my_iou_metric': my_iou_metric}) # remove activation layer and use lovasz loss input_x = model1.layers[0].input output_layer = model1.layers[-1].input model = Model(input_x, output_layer) c = optimizers.adam(lr=0.01) model.compile(loss=lovasz_loss, optimizer=c, metrics=[my_iou_metric_2]) save_model_name = f"{basic_name}_stage2_fold{fold}.hdf5" early_stopping = EarlyStopping(monitor='val_my_iou_metric_2', mode='max', patience=30, verbose=1) model_checkpoint = ModelCheckpoint(save_model_name, monitor='val_my_iou_metric_2', mode='max', save_best_only=True, verbose=1) reduce_lr = ReduceLROnPlateau(monitor='val_my_iou_metric_2', mode='max', factor=0.5, patience=5, min_lr=0.00005, verbose=1) epochs = 120 batch_size = 128 if not PREDICT_ONLY: history = model.fit( x_train, y_train, validation_data=[x_valid, y_valid], epochs=epochs, batch_size=batch_size, callbacks=[model_checkpoint, reduce_lr, early_stopping], verbose=2) model = load_model(save_model_name, custom_objects={ 'my_iou_metric_2': my_iou_metric_2, 'lovasz_loss': lovasz_loss }) def predict_result(model, x_test, img_size_target): # predict both orginal and reflect x x_test_reflect = np.array([np.fliplr(x) for x in x_test]) preds_test = model.predict(x_test).reshape(-1, img_size_target, img_size_target) preds_test2_refect = model.predict(x_test_reflect).reshape( -1, img_size_target, img_size_target) preds_test += np.array([np.fliplr(x) for x in preds_test2_refect]) return preds_test / 2 preds_valid = predict_result(model, x_valid, img_size_target) preds_test = predict_result(model, x_test, img_size_target) return preds_valid, preds_test
input_answer = Input(shape=(maxlen_input,), dtype='int32', name='the answer text up to the current token') LSTM_encoder = LSTM(sentence_embedding_size, kernel_initializer= 'lecun_uniform', name='Encode context') LSTM_decoder = LSTM(sentence_embedding_size, kernel_initializer= 'lecun_uniform', name='Encode answer up to the current token') Shared_Embedding = Embedding(output_dim=word_embedding_size, input_dim=dictionary_size, input_length=maxlen_input, name='Shared') word_embedding_context = Shared_Embedding(input_context) context_embedding = LSTM_encoder(word_embedding_context) word_embedding_answer = Shared_Embedding(input_answer) answer_embedding = LSTM_decoder(word_embedding_answer) merge_layer = concatenate([context_embedding, answer_embedding], axis=1, name='concatenate the embeddings of the context and the answer up to current token') out = Dense(dictionary_size/2, activation="relu", name='relu activation')(merge_layer) out = Dense(dictionary_size, activation="softmax", name='likelihood of the current token using softmax activation')(out) model = Model(inputs=[input_context, input_answer], outputs = [out]) model.compile(loss='categorical_crossentropy', optimizer=ad) # Loading the data: vocabulary = cPickle.load(open(vocabulary_file, 'rb')) print("\n \n \n \n CHAT: \n \n") # Processing the user query: prob = 0 que = '' last_query = ' ' last_last_query = '' text = ' ' last_text = ''
model=applications.VGG16(weights='imagenet',include_top=False) # VGG16是函数式模型 # top_model=Sequential() # top_model.add(Flatten(input_shape=model.output_shape[1:])) # top_model.add(Dense(256,activation='relu')) # top_model.add(Dropout(0.5)) # top_model.add(Dense(1,activation='sigmoid')) x=model.output x = GlobalAveragePooling2D()(x) x = Dense(256, activation='relu', name='fc1')(x) x = Dropout(0.5)(x) predictions=Dense(1,activation='sigmoid')(x) vgg_model=Model(input=model.input,output=predictions) # vgg_model.load_weights('E:/ML/models/vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5') # 两个网络的融合,有错 # model.add(top_model) # 将最后一个卷积块前的卷积参数冻结 for layer in vgg_model.layers[:25]: layer.trainable=False vgg_model.compile(loss='binary_crossentropy',optimizer=optimizers.SGD(lr=1e-4, momentum=0.9),metrics=['accuracy']) datagen=ImageDataGenerator( rescale=1./255,
def CreateModel(self): ''' 定义CNN/LSTM/CTC模型,使用函数式模型 输入层:200维的特征值序列,一条语音数据的最大长度设为1600(大约16s) 隐藏层:3*3卷积层 隐藏层:池化层,池化窗口大小为2 隐藏层:Dropout层,需要断开的神经元的比例为0.2,防止过拟合 隐藏层:全连接层 目标输出层:全连接层,神经元数量为self.MS_OUTPUT_SIZE,使用softmax作为激活函数 输出层:自定义层,即CTC层,使用CTC的loss作为损失函数,实现连接性时序多输出 ''' # 每一帧使用13维mfcc特征及其13维一阶差分和13维二阶差分表示,最大信号序列长度为1500 input_data = Input(name='the_input', shape=(self.AUDIO_LENGTH, self.AUDIO_FEATURE_LENGTH, 1)) layer_h1 = Conv2D(32, (3,3), use_bias=True, activation='relu', padding='same', kernel_initializer='he_normal')(input_data) # 卷积层 layer_h1 = Dropout(0.1)(layer_h1) layer_h2 = Conv2D(32, (3,3), use_bias=True, activation='relu', padding='same', kernel_initializer='he_normal')(layer_h1) # 卷积层 layer_h3 = MaxPooling2D(pool_size=2, strides=None, padding="valid")(layer_h2) # 池化层 #layer_h3 = Dropout(0.2)(layer_h2) # 随机中断部分神经网络连接,防止过拟合 layer_h3 = Dropout(0.1)(layer_h3) layer_h4 = Conv2D(64, (3,3), use_bias=True, activation='relu', padding='same', kernel_initializer='he_normal')(layer_h3) # 卷积层 layer_h4 = Dropout(0.2)(layer_h4) layer_h5 = Conv2D(64, (3,3), use_bias=True, activation='relu', padding='same', kernel_initializer='he_normal')(layer_h4) # 卷积层 layer_h6 = MaxPooling2D(pool_size=2, strides=None, padding="valid")(layer_h5) # 池化层 layer_h6 = Dropout(0.2)(layer_h6) layer_h7 = Conv2D(128, (3,3), use_bias=True, activation='relu', padding='same', kernel_initializer='he_normal')(layer_h6) # 卷积层 layer_h7 = Dropout(0.3)(layer_h7) layer_h8 = Conv2D(128, (3,3), use_bias=True, activation='relu', padding='same', kernel_initializer='he_normal')(layer_h7) # 卷积层 layer_h9 = MaxPooling2D(pool_size=2, strides=None, padding="valid")(layer_h8) # 池化层 layer_h9 = Dropout(0.3)(layer_h9) layer_h10 = Conv2D(128, (3,3), use_bias=True, activation='relu', padding='same', kernel_initializer='he_normal')(layer_h9) # 卷积层 layer_h10 = Dropout(0.4)(layer_h10) layer_h11 = Conv2D(128, (3,3), use_bias=True, activation='relu', padding='same', kernel_initializer='he_normal')(layer_h10) # 卷积层 layer_h12 = MaxPooling2D(pool_size=1, strides=None, padding="valid")(layer_h11) # 池化层 #test=Model(inputs = input_data, outputs = layer_h12) #test.summary() layer_h10 = Reshape((200, 3200))(layer_h12) #Reshape层 #layer_h5 = LSTM(256, activation='relu', use_bias=True, return_sequences=True)(layer_h4) # LSTM层 #layer_h6 = Dropout(0.2)(layer_h5) # 随机中断部分神经网络连接,防止过拟合 layer_h10 = Dropout(0.4)(layer_h10) layer_h11 = Dense(128, activation="relu", use_bias=True, kernel_initializer='he_normal')(layer_h10) # 全连接层 layer_h11 = Dropout(0.5)(layer_h11) layer_h12 = Dense(self.MS_OUTPUT_SIZE, use_bias=True, kernel_initializer='he_normal')(layer_h11) # 全连接层 y_pred = Activation('softmax', name='Activation0')(layer_h12) model_data = Model(inputs = input_data, outputs = y_pred) #model_data.summary() labels = Input(name='the_labels', shape=[self.label_max_string_length], dtype='float32') input_length = Input(name='input_length', shape=[1], dtype='int64') label_length = Input(name='label_length', shape=[1], dtype='int64') # Keras doesn't currently support loss funcs with extra parameters # so CTC loss is implemented in a lambda layer #layer_out = Lambda(ctc_lambda_func,output_shape=(self.MS_OUTPUT_SIZE, ), name='ctc')([y_pred, labels, input_length, label_length])#(layer_h6) # CTC loss_out = Lambda(self.ctc_lambda_func, output_shape=(1,), name='ctc')([y_pred, labels, input_length, label_length]) model = Model(inputs=[input_data, labels, input_length, label_length], outputs=loss_out) #model.summary() # clipnorm seems to speeds up convergence #sgd = SGD(lr=0.0001, decay=1e-6, momentum=0.9, nesterov=True, clipnorm=5) ada_d = Adadelta(lr = 0.01, rho = 0.95, epsilon = 1e-06) #model.compile(loss={'ctc': lambda y_true, y_pred: y_pred}, optimizer=sgd) model.compile(loss={'ctc': lambda y_true, y_pred: y_pred}, optimizer = ada_d) # captures output of softmax so we can decode the output during visualization test_func = K.function([input_data], [y_pred]) print('[*提示] 创建模型成功,模型编译成功') return model, model_data
#print(key, value) train_x, val_x, train_y, val_y = train_test_split(img_x, y, test_size = .2, shuffle = False) inputs = Input(shape=(train_x.shape[1], train_x.shape[2], 1)) # a layer instance is callable on a tensor, and returns a tensor a = Conv2D(12, kernel_size=(7,7), activation='relu', padding = "valid", data_format="channels_last")(inputs) a = MaxPooling2D(2)(a) a = Conv2D(12, kernel_size=(5,5), activation='relu', padding = "valid", data_format="channels_last")(a) a = MaxPooling2D(2)(a) #a = Conv2D(12, kernel_size=(3,3), activation='relu', padding = "valid", data_format="channels_last")(a) #a = MaxPooling2D(2)(a) a = Dense(24, activation='relu')(Flatten()(a)) predictions = Dense(2, activation='relu')(a) # This creates a model that includes # the Input layer and three Dense layers model = Model(inputs=inputs, outputs=predictions) model.compile(optimizer=SGD(args.learning_rate,args.momentum), loss=rmse, metrics=['mse']) hist = model.fit(x = train_x, y = train_y, validation_data = (val_x,val_y), epochs=100, batch_size=20, verbose=1) preds = model.predict(val_x) l2dists_mean, l2dists = l2_dist((preds[:, 0], preds[:, 1]), (val_y["x"], val_y["y"])) print('l2_loss={}'.format(l2dists_mean)) sortedl2_deep = np.sort(l2dists) dist_acc = [] for i in [1, 2, 3, 4, 5]: dist_acc = dist_acc + [np.sum(sortedl2_deep <= i)/np.size(sortedl2_deep)] print(dist_acc)
def get_model(num_users, num_items, layers=[20, 10], reg_layers=[0, 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') # Deprecate: init and W_regularizer ''' MLP_Embedding_User = Embedding(input_dim = num_users, output_dim = layers[0]/2, name = 'user_embedding', init = init_normal, W_regularizer = l2(reg_layers[0]), input_length=1) MLP_Embedding_Item = Embedding(input_dim = num_items, output_dim = layers[0]/2, name = 'item_embedding', init = init_normal, W_regularizer = l2(reg_layers[0]), input_length=1) ''' DMF1_Embedding_User = Embedding(input_dim=num_users, output_dim=layers[0] // 2, name='dmf1_user_embedding', embeddings_initializer='random_normal', embeddings_regularizer=l2(reg_layers[0]), input_length=1) DMF1_Embedding_Item = Embedding(input_dim=num_items, output_dim=layers[0] // 2, name='dmf1_item_embedding', embeddings_initializer='random_normal', embeddings_regularizer=l2(reg_layers[0]), input_length=1) DMF2_Embedding_User = Embedding(input_dim=num_users, output_dim=layers[0] // 2, name='dmf2_user_embedding', embeddings_initializer='random_normal', embeddings_regularizer=l2(reg_layers[0]), input_length=1) DMF2_Embedding_Item = Embedding(input_dim=num_items, output_dim=layers[0] // 2, name='dmf2_item_embedding', embeddings_initializer='random_normal', embeddings_regularizer=l2(reg_layers[0]), input_length=1) # Crucial to flatten an embedding vector! dmf1_user_latent = Flatten()(DMF1_Embedding_User(user_input)) dmf1_item_latent = Flatten()(DMF1_Embedding_Item(item_input)) dmf2_user_latent = Flatten()(DMF2_Embedding_User(user_input)) dmf2_item_latent = Flatten()(DMF2_Embedding_Item(item_input)) # The 0-th layer is the concatenation of embedding layers 1# # vector = Multiply()([user_latent, item_latent]) # The 0-th layer is the concatenation of embedding layers 2# # vector_r = Multiply()([user_latent, item_latent]) # vector_l = Concatenate()([user_latent, item_latent]) # layer = Dense(layers[1], kernel_regularizer=l2(reg_layers[0]), activation='linear', name='pre-layer') # vector_l = layer(vector_l) # vector = Add()([vector_r, vector_l]) # vector = Activation(activation='relu')(vector) # The 0-th layer is the concatenation of embedding layers 3# vector_r = Multiply()([dmf1_user_latent, dmf1_item_latent]) vector_l = Concatenate()([dmf2_user_latent, dmf2_item_latent]) # linear learning layer 3.1# # for idx in range(0, 2): # layer = Dense(layers[idx], kernel_regularizer=l2(reg_layers[0]), activation='linear', name='pre-layer%d' % idx) # vector_l = layer(vector_l) layer = Dense(layers[0] // 2, kernel_regularizer=l2(reg_layers[0]), activation='linear', name='pre-layer') vector_l = layer(vector_l) vector = Concatenate()([vector_r, vector_l]) # The 0-th layer is the concatenation of embedding layers 4# # vector_r = Multiply()([user_latent, item_latent]) # vector_l = Concatenate()([user_latent, item_latent]) # vector = Concatenate()([vector_r, vector_l]) # MLP layers (Dual-wise) for idx in range(1, num_layer-3): # Deprecate: W_W_regularizer '''layer = Dense(layers[idx], W_regularizer=l2(reg_layers[idx]), activation='relu', name='layer%d' % idx)''' layer = Dense(layers[idx], kernel_regularizer=l2(reg_layers[idx]), activation='relu', name='layer%d' % idx) vector = layer(vector) # Final prediction layer # Deprecate: init '''prediction = Dense(1, activation='sigmoid', init='lecun_uniform', name='prediction')(vector)''' prediction = Dense(1, activation='sigmoid', kernel_initializer='lecun_uniform', name='prediction')(vector) model = Model(inputs=[user_input, item_input], outputs=prediction) return model
def vgg16_model(trainFilePath, testFilePath, batch_size, epochs, name, lr, key_file, which_line, which_letter, key_length, test_size, load_weight=False, weight_path=None, evalONtest=True): input_tensor = Input(shape=(35000, 1)) seq = input_tensor seq = SeparableConv1D(64, 3, padding='same', activation=None)(seq) seq = BatchNormalization(axis=1)(seq) seq = ReLU()(seq) seq = SeparableConv1D(64, 3, padding='same', activation=None)(seq) seq = BatchNormalization(axis=1)(seq) seq = ReLU()(seq) seq = MaxPooling1D(pool_size=2, strides=2)(seq) seq = SeparableConv1D(128, 3, padding='same', activation=None)(seq) seq = BatchNormalization(axis=1)(seq) seq = ReLU()(seq) seq = SeparableConv1D(128, 3, padding='same', activation=None)(seq) seq = BatchNormalization(axis=1)(seq) seq = ReLU()(seq) seq = MaxPooling1D(pool_size=2, strides=2)(seq) seq = SeparableConv1D(256, 3, padding='same', activation=None)(seq) seq = BatchNormalization(axis=1)(seq) seq = ReLU()(seq) seq = SeparableConv1D(256, 3, padding='same', activation=None)(seq) seq = BatchNormalization(axis=1)(seq) seq = ReLU()(seq) # seq = SeparableConv1D(256,3,padding='same',activation=None)(seq) seq = MaxPooling1D(pool_size=2, strides=2)(seq) seq = SeparableConv1D(256, 3, padding='same', activation=None)(seq) seq = BatchNormalization(axis=1)(seq) seq = ReLU()(seq) seq = SeparableConv1D(256, 3, padding='same', activation=None)(seq) seq = BatchNormalization(axis=1)(seq) seq = ReLU()(seq) # seq = SeparableConv1D(256,3,padding='same',activation=None)(seq) seq = MaxPooling1D(pool_size=2, strides=2)(seq) seq = SeparableConv1D(512, 3, padding='same', activation=None)(seq) seq = BatchNormalization(axis=1)(seq) seq = ReLU()(seq) seq = SeparableConv1D(512, 3, padding='same', activation=None)(seq) seq = BatchNormalization(axis=1)(seq) seq = ReLU()(seq) # seq = SeparableConv1D(512,3,padding='same',activation=None)(seq) seq = MaxPooling1D(pool_size=2, strides=2)(seq) seq = SeparableConv1D(512, 3, padding='same', activation=None)(seq) seq = BatchNormalization(axis=1)(seq) seq = ReLU()(seq) seq = SeparableConv1D(512, 3, padding='same', activation=None)(seq) seq = BatchNormalization(axis=1)(seq) seq = ReLU()(seq) # seq = SeparableConv1D(512,3,padding='same',activation='relu')(seq) seq = GlobalMaxPooling1D()(seq) # seq = Flatten()(seq) # seq = Dense(1000,activation='relu')(seq) seq = Dense(1000, activation='relu')(seq) output_tensor = Dense(16, activation='softmax')(seq) # model = Model(inputs=[input_tensor], outputs=[output_tensor]) model = Model(inputs=[input_tensor], outputs=[output_tensor]) # model = multi_gpu_model(model,gpus=4) model.summary() if load_weight == True: model.load_weights(weight_path, by_name=True) else: pass from keras.optimizers import Adam model.compile( loss='categorical_crossentropy', # 交叉熵作为loss optimizer=Adam(lr), metrics=['accuracy']) if evalONtest == True: test_model = Model(inputs=[input_tensor], outputs=[output_tensor]) test_model.compile( loss='categorical_crossentropy', # 交叉熵作为loss optimizer=Adam(lr), metrics=['accuracy']) CSV_FILE_PATH2 = testFilePath data_to_test = load_data(CSV_FILE_PATH2) # train_x2, test_x2, train_y2, test_y2, Class_dict2 # train_x2 = np.expand_dims(train_x2, axis=2) # test_x2 = np.expand_dims(test_x2, axis=2) else: pass print('开始加载数据') data_to_train = load_data(trainFilePath) # data_to_train = data_to_train[:10000] label_to_train = cut_letter(key_file, which_line, which_letter, key_length) label_to_train_lb = to_categorical(label_to_train, 16) train_x, test_x, train_y, test_y = train_test_split(data_to_train, label_to_train_lb, test_size=test_size, shuffle=True) train_x = np.expand_dims(train_x, axis=2) test_x = np.expand_dims(test_x, axis=2) b_size = batch_size max_epochs = epochs print("Starting training ") learnratedecay = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=8, verbose=1, mode='auto', epsilon=0.0001, cooldown=0, min_lr=0) os.makedirs('/data/wuchenxi/allmodel/new_simeck_model/' + name + '/model', exist_ok=True) os.makedirs('/data/wuchenxi/allmodel/new_simeck_model/' + name + '/csvlog', exist_ok=True) os.makedirs('/data/wuchenxi/allmodel/new_simeck_model/' + name + '/tensorboard', exist_ok=True) checkpointer = ModelCheckpoint( monitor='val_loss', filepath='/data/wuchenxi/allmodel/new_simeck_model/' + name + '/model/' + name + '.hdf5', verbose=1, save_best_only=True) picture_output = TensorBoard( log_dir='/data/wuchenxi/allmodel/new_simeck_model/' + name + '/tensorboard/' + name + '_log', histogram_freq=0, write_graph=True, write_grads=True, write_images=True, ) csvlog = CSVLogger(filename='/data/wuchenxi/allmodel/new_simeck_model/' + name + '/csvlog/' + name + '.csv', separator=',', append=False) if evalONtest == True: pass # callback = [checkpointer, picture_output, csvlog, learnratedecay, # EvaluateInputTensor(test_model, train_x2, train_y2, # '/data/wuchenxi/allmodel/simeck_key_model/'+name+'/csvlog/' + name + '_test.csv')] else: callback = [checkpointer, picture_output, csvlog, learnratedecay] h = model.fit(train_x, train_y, batch_size=b_size, epochs=max_epochs, validation_data=(test_x, test_y), shuffle=True, verbose=1, callbacks=callback)
x_train = x_train.reshape((len(x_train), np.prod(x_train.shape[1:]))) x_test = x_test.reshape((len(x_test), np.prod(x_test.shape[1:]))) print(x_train.shape) print(x_test.shape) # 构造单隐藏层的自编码器( 784转32再转784) encoding_dim = 32 # 32 floats -> compression of factor 24.5, assuming the input is 784 floats # this is our input placeholder input_img = Input(shape=(784,)) # "encoded" is the encoded representation of the input encoded = Dense(encoding_dim, activation='relu')(input_img) # "decoded" is the lossy reconstruction of the input decoded = Dense(784, activation='sigmoid')(encoded) # this model maps an input to its reconstruction autoencoder = Model(input=input_img, output=decoded) # 定义编码器(784转32) # this model maps an input to its encoded representation encoder = Model(input=input_img, output=encoded) # 定义解码器(32转784) # create a placeholder for an encoded (32-dimensional) input encoded_input = Input(shape=(encoding_dim,)) # retrieve the last layer of the autoencoder model decoder_layer = Dense(784, activation='sigmoid') # create the decoder model decoder = Model(input=encoded_input, output=decoder_layer(encoded_input)) # 编译和训练自编码器 autoencoder.compile(optimizer='adadelta', loss='binary_crossentropy')
def SqueezeUNet(inputs, num_classes=None, deconv_ksize=3, dropout=0.5, activation='sigmoid'): """SqueezeUNet is a implementation based in SqueezeNetv1.1 and unet for semantic segmentation :param inputs: input layer. :param num_classes: number of classes. :param deconv_ksize: (width and height) or integer of the 2D deconvolution window. :param dropout: dropout rate :param activation: type of activation at the top layer. :returns: SqueezeUNet model """ channel_axis = 1 if K.image_data_format() == 'channels_first' else -1 if num_classes is None: num_classes = K.int_shape(inputs)[channel_axis] x01 = Conv2D(64, (3, 3), strides=(2, 2), padding='same', activation='relu', name='conv1')(inputs) x02 = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name='pool1', padding='same')(x01) x03 = fire_module(x02, fire_id=2, squeeze=16, expand_1x1=64, expand_3x3=64) x04 = fire_module(x03, fire_id=3, squeeze=16, expand_1x1=64, expand_3x3=64) x05 = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name='pool3', padding="same")(x04) x06 = fire_module(x05, fire_id=4, squeeze=32, expand_1x1=128, expand_3x3=128) x07 = fire_module(x06, fire_id=5, squeeze=32, expand_1x1=128, expand_3x3=128) x08 = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name='pool5', padding="same")(x07) x09 = fire_module(x08, fire_id=6, squeeze=48, expand_1x1=192, expand_3x3=192) x10 = fire_module(x09, fire_id=7, squeeze=48, expand_1x1=192, expand_3x3=192) x11 = fire_module(x10, fire_id=8, squeeze=64, expand_1x1=256, expand_3x3=256) x12 = fire_module(x11, fire_id=9, squeeze=64, expand_1x1=256, expand_3x3=256) if dropout != 0.0: x12 = Dropout(dropout)(x12) up1 = concatenate([ Conv2DTranspose(192, deconv_ksize, strides=(1, 1), padding='same')(x12), x10, ], axis=channel_axis) up1 = fire_module(up1, fire_id=10, squeeze=48, expand=192) up2 = concatenate([ Conv2DTranspose(128, deconv_ksize, strides=(1, 1), padding='same')(up1), x08, ], axis=channel_axis) up2 = fire_module(up2, fire_id=11, squeeze=32, expand=128) up3 = concatenate([ Conv2DTranspose(64, deconv_ksize, strides=(2, 2), padding='same')(up2), x05, ], axis=channel_axis) up3 = fire_module(up3, fire_id=12, squeeze=16, expand=64) up4 = concatenate([ Conv2DTranspose(32, deconv_ksize, strides=(2, 2), padding='same')(up3), x02, ], axis=channel_axis) up4 = fire_module(up4, fire_id=13, squeeze=16, expand=32) up4 = UpSampling2D(size=(2, 2))(up4) x = concatenate([up4, x01], axis=channel_axis) x = Conv2D(64, (3, 3), strides=(1, 1), padding='same', activation='relu')(x) x = UpSampling2D(size=(2, 2))(x) x = Conv2D(num_classes, (1, 1), activation=activation)(x) return Model(inputs=inputs, outputs=x)
class Model(): def __init__(self, max_len=30, max_words=10000, batch_size=128, loss='binary_crossentropy', optimizer='adam', n_epochs=10): self.max_len = max_len self.max_words = max_words self.batch_size = batch_size self.loss = loss self.optimizer = optimizer self.n_epochs = n_epochs self.model = Model() def build_lstm(self, word_index, emb_mat, d_rate=0.3): """ Builds an LSTM model Parameters ---------- word_index : numpy array an array of index for all words emb_mat : numpy matrix a matrix of embedding values d_rate : float a float number indicating the dropout ratio. """ lstm_input = layers.Input((70, )) lstm_layer = layers.Embedding(len(word_index) + 1, 300, weights=[emb_mat], trainable=False)(lstm_input) lstm_layer = layers.SpatialDropout1D(0.3)(lstm_layer) lstm_layer = SpatialDropout1D(d_rate)(lstm_layer) lstm_layer = Bidirectional(LSTM(128, return_sequences=True))(lstm_layer) lstm_layer = Bidirectional(LSTM(128, return_sequences=True))(lstm_layer) hidden = concatenate([ GlobalMaxPooling1D()(lstm_layer), GlobalAveragePooling1D()(lstm_layer), ]) hidden = add([hidden, Dense(512, activation='relu')(hidden)]) hidden = add([hidden, Dense(512, activation='relu')(hidden)]) lstm_output = Dense(1, activation='sigmoid')(hidden) self.model = Model(lstm_input, lstm_output) def build_cnn(self, word_index, emb_mat): """ Builds a CNN model Parameters ---------- word_index : numpy array an array of index for all words emb_mat : numpy matrix a matrix of embedding values """ cnn_input = layers.Input((70, )) emb_layer = layers.Embedding(len(word_index) + 1, 300, weights=[emb_mat], trainable=False)(cnn_input) emb_layer = layers.SpatialDropout1D(0.3)(emb_layer) conv_layer = layers.Convolution1D(100, 3, activation="relu")(emb_layer) pooling_layer = layers.GlobalMaxPool1D()(conv_layer) output_layer1 = layers.Dense(50, activation="relu")(pooling_layer) output_layer1 = layers.Dropout(0.25)(output_layer1) cnn_output = layers.Dense(1, activation="sigmoid")(output_layer1) self.model = Model(inputs=cnn_input, outputs=cnn_output) def train(self, X_train, y_train, class_weight={0: 1.0, 1: 1.0}, metrics=[fmeasure]): """ trains the model Parameters ---------- X_train : numpy matrix a matrix of input text in the sequence format y_train : numpy array an array of input labels """ self.model.compile(loss=self.loss, optimizer=optimizer) self.model.fit(X_train, y_train, class_weight=class_weight) def predict(self, X_test, test_df, submission_file): """ predicts labels for unseen data and stores them in a file for submission Parameters ---------- X_test : numpy matrix a matrix of test text in the sequence format test_df : pandas dataframe the test test in the format of dataframe submission_file : string the path to the output dataframe ready to be submitted """ predict = self.model.predict(X_test) test_df['prediction'] = predict test_df = test_df[['id', 'prediction']] test_df.to_csv(submission_file, index=False) def plot(self, outfile): """ plots the model Parameters ---------- outfile : string the path to the output png file """ plot_model(self.model, to_file=outfile, show_shapes=True)
def small_POD_body(inputs, num_anchors, num_classes): podnet = Model(inputs, small_PODnet_body()(inputs)) x = DarknetConv2D_BN_Leaky(num_anchors * (num_classes + 5), (1, 1))(podnet.output) return Model(inputs, x)
# Be careful, the returned output should be a batch of sequences. X = LSTM(128,return_sequences=True)(embeddings) # Add dropout with a probability of 0.5 X = Dropout(0.5)(X) # Propagate X trough another LSTM layer with 128-dimensional hidden state # Be careful, the returned output should be a single hidden state, not a batch of sequences. X = LSTM(128,return_sequences=False)(X) # Add dropout with a probability of 0.5 X = Dropout(0.5)(X) # Propagate X through a Dense layer with softmax activation to get back a batch of 5-dimensional vectors. X = Dense(5)(X) # Add a softmax activation X = Activation('softmax')(X) # Create Model instance which converts sentence_indices into X. model = Model(inputs = sentence_indices,outputs = X) ### END CODE HERE ### return model # Run the following cell to create your model and check its summary. Because all sentences in the dataset are less than 10 words, we chose `max_len = 10`. You should see your architecture, it uses "20,223,927" parameters, of which 20,000,050 (the word embeddings) are non-trainable, and the remaining 223,877 are. Because our vocabulary size has 400,001 words (with valid indices from 0 to 400,000) there are 400,001\*50 = 20,000,050 non-trainable parameters. # In[53]: model = Emojify_V2((maxLen,), word_to_vec_map, word_to_index) model.summary() # As usual, after creating your model in Keras, you need to compile it and define what loss, optimizer and metrics your are want to use. Compile your model using `categorical_crossentropy` loss, `adam` optimizer and `['accuracy']` metrics:
print ('Successfully Added', file=fh) np_epochs = 5 batch_size = 32 input_shape = (200,200,3) inception = InceptionV3(include_top = False, weights='imagenet', input_shape=input_shape, pooling='max') for layer in inception.layers: layer.trainable = False output = inception.output output = Dense(50, activation = 'relu')(output) output = Dense(10, activation = 'relu')(output) output = Dense(1, activation='linear')(output) model = Model(inputs = inception.input, outputs=output) model.compile(optimizer='adam', loss='mse', metrics=['accuracy']) model.summary() model_yaml = model.to_yaml() with open('inception_model.yaml', 'w') as yaml_file: yaml_file.write(model_yaml) print ('model.yaml saved to disk') filepath="weights_inception.hdf5" checkpoint = ModelCheckpoint(filepath, monitor='val_loss', verbose=1, save_best_only=True, mode='min') callbacks_list = [checkpoint] train_samples = X_train.shape[0] val_samples = X_val.shape[0] test_samples = X_test.shape[0]
def yolo3_body(inputs, num_anchors, num_classes): base_yolo3 = Model(inputs, darknet53_body(inputs)) x = DarknetConv2D_BN_Leaky(num_anchors * (num_classes + 5), (1, 1))(base_yolo3.output) yolo3 = Model(inputs, x) yolo3.summary()
def make_nested_func_model(input_shape, layer, level=1): input = Input(input_shape) model = layer for i in range(level): model = Model(input, model(input)) return model
output23,output24,output25,output26,output27,output28,output29,output30] concat_output = Concatenate(axis = -1)(my_outputs) predictions = Flatten()(concat_output) predictions = Dense(300, activation='relu')(predictions) predictions = Dense(200, activation='relu')(predictions) predictions = Dense(100, activation='relu')(predictions) predictions = Dense(2, activation='softmax')(predictions) from keras.optimizers import SGD opt = SGD(lr=0.001) model = Model(inputs=my_inputs, outputs=predictions) model.compile(optimizer=opt, loss='categorical_crossentropy', metrics=['accuracy']) print(model.summary()) # In[23]: from glob import glob from random import shuffle pat_list0 = glob('C:/Users/korea/Desktop/sungmo_RESNET/data/30image/0/*') pat_list1 = glob('C:/Users/korea/Desktop/sungmo_RESNET/data/30image/1/*') from pprint import pprint
def regression_model(input_shapes): inputs, x = TrainData_image.base_model(input_shapes) predictions = Dense(2, activation='linear', init='normal')(x) return Model(inputs=inputs, outputs=predictions)
class VAE(object): def __init__(self, original_img_size, latent_dim, intermediate_dim, epsilon_std, epochs, batch_size): self.original_img_size = original_img_size self.latent_dim = latent_dim self.intermediate_dim = intermediate_dim self.epsilon_std = epsilon_std self.epochs = epochs self.batch_size = batch_size x, z_mean, z_log_var = self.build_encoder() def sampling(args): z_mean, z_log_var = args epsilon = K.random_normal(shape=(batch_size, latent_dim), mean=0., stddev=epsilon_std) return z_mean + K.exp(z_log_var) * epsilon def vae_loss(x, x_decoded_mean_squash): x = K.flatten(x) x_decoded_mean_squash = K.flatten(x_decoded_mean_squash) xent_loss = img_rows * img_cols * metrics.binary_crossentropy( x, x_decoded_mean_squash) kl_loss = -0.5 * K.mean( 1 + z_log_var - K.square(z_mean) - K.exp(z_log_var), axis=-1) return K.mean(xent_loss + kl_loss) # note that "output_shape" isn't necessary with the TensorFlow backend # so you could write `Lambda(sampling)([z_mean, z_log_var])` self.z = Lambda(sampling, output_shape=(self.latent_dim, ))([z_mean, z_log_var]) self.generator, x_decoded_mean_squash = self.build_decoder() # build a model to project inputs on the latent space self.encoder = Model(x, z_mean) # where is z_var here? self.vae = Model(x, x_decoded_mean_squash) self.vae.compile(optimizer='rmsprop', loss=vae_loss) def build_encoder(self): x = Input(batch_shape=(batch_size, ) + original_img_size) conv_1 = Conv2D(img_chns, kernel_size=(2, 2), padding='same', activation='relu')(x) conv_2 = Conv2D(filters, kernel_size=(2, 2), padding='same', activation='relu', strides=(2, 2))(conv_1) conv_3 = Conv2D(filters, kernel_size=num_conv, padding='same', activation='relu', strides=1)(conv_2) conv_4 = Conv2D(filters, kernel_size=num_conv, padding='same', activation='relu', strides=1)(conv_3) flat = Flatten()(conv_4) hidden = Dense(self.intermediate_dim, activation='relu')(flat) z_mean = Dense(self.latent_dim)(hidden) z_log_var = Dense(self.latent_dim)(hidden) return x, z_mean, z_log_var def build_decoder(self): # we instantiate these layers separately so as to reuse them later decoder_hid = Dense(intermediate_dim, activation='relu') decoder_upsample = Dense(filters * 14 * 14, activation='relu') if K.image_data_format() == 'channels_first': output_shape = (batch_size, filters, 14, 14) else: output_shape = (batch_size, 14, 14, filters) decoder_reshape = Reshape(output_shape[1:]) decoder_deconv_1 = Conv2DTranspose(filters, kernel_size=num_conv, padding='same', strides=1, activation='relu') decoder_deconv_2 = Conv2DTranspose(filters, num_conv, padding='same', strides=1, activation='relu') if K.image_data_format() == 'channels_first': output_shape = (batch_size, filters, 29, 29) else: output_shape = (batch_size, 29, 29, filters) decoder_deconv_3_upsamp = Conv2DTranspose(filters, kernel_size=(3, 3), strides=(2, 2), padding='valid', activation='relu') decoder_mean_squash = Conv2D(img_chns, kernel_size=2, padding='valid', activation='sigmoid') hid_decoded = decoder_hid(self.z) up_decoded = decoder_upsample(hid_decoded) reshape_decoded = decoder_reshape(up_decoded) deconv_1_decoded = decoder_deconv_1(reshape_decoded) deconv_2_decoded = decoder_deconv_2(deconv_1_decoded) x_decoded_relu = decoder_deconv_3_upsamp(deconv_2_decoded) x_decoded_mean_squash = decoder_mean_squash(x_decoded_relu) # build a digit generator that can sample from the learned distribution decoder_input = Input(shape=(self.latent_dim, )) _hid_decoded = decoder_hid(decoder_input) _up_decoded = decoder_upsample(_hid_decoded) _reshape_decoded = decoder_reshape(_up_decoded) _deconv_1_decoded = decoder_deconv_1(_reshape_decoded) _deconv_2_decoded = decoder_deconv_2(_deconv_1_decoded) _x_decoded_relu = decoder_deconv_3_upsamp(_deconv_2_decoded) _x_decoded_mean_squash = decoder_mean_squash(_x_decoded_relu) generator = Model(decoder_input, _x_decoded_mean_squash) return generator, x_decoded_mean_squash def train(self, x_train, x_test, y_test): self.vae.fit(x_train, x_train, shuffle=True, epochs=self.epochs, batch_size=self.batch_size, validation_data=(x_test, x_test)) def save(self, output_dir): self.vae.save_weights(os.path.join(output_dir, 'vae_model.h5')) self.encoder.save_weights(os.path.join(output_dir, 'encoder_model.h5')) self.generator.save_weights( os.path.join(output_dir, 'generator_model.h5')) def load(self, output_dir): vae_filename = os.path.join(output_dir, 'vae_model.h5') encoder_filename = os.path.join(output_dir, 'encoder_model.h5') generator_filename = os.path.join(output_dir, 'generator_model.h5') self.encoder.load_weights(encoder_filename) self.vae.load_weights(vae_filename) self.generator.load_weights(generator_filename)
categorical_features, categorical_names, class_names, epochs=1, batch_size=128, ) model = nn_with_embedding.model with open('logs/nn_with_embedding_model_architecture.json', 'r') as f: model = model_from_json(f.read()) model.load_weights('logs/nn_with_embedding_model_weights.h5') layer_name = 'fully-connected' previous_layer_name = 'embedding' intermediate_layer_model = KerasModel(inputs=model.input, outputs=model.get_layer(previous_layer_name).output) intermediate_output = intermediate_layer_model.predict(preprocessing(X_test)) layer_names = [layer.name for layer in model.layers] layer_idx = layer_names.index(layer_name) # get the input shape of the desired layer input_shape = model.layers[layer_idx].get_input_shape_at(0) new_input = Input(shape=(input_shape[1],)) # create the new nodes for each layer in the path x = new_input for layer in model.layers[layer_idx:]: x = layer(x) new_model = KerasModel(new_input, x) a = new_model.predict(intermediate_output)
def classification_model(input_shapes, nclasses): inputs, x = TrainData_image.base_model(input_shapes) predictions = Dense(nclasses, activation='softmax', kernel_initializer='lecun_uniform')(x) return Model(inputs=inputs, outputs=predictions)
class GANUnetNoGapFillingModel(): def __init__(self): K.set_image_data_format('channels_last') # set format K.set_image_dim_ordering('tf') self.DEBUG = 1 # Input shape self.img_rows = 192 self.img_cols = 192 self.img_vols = 192 self.channels = 1 self.batch_sz = 1 # for testing locally to avoid memory allocation self.crop_size = (self.img_rows, self.img_cols, self.img_vols) self.img_shape = self.crop_size + (self.channels,) self.output_size = 192 self.output_shape_g = self.crop_size + (3,) # phi has three outputs. one for each X, Y, and Z dimensions self.input_shape_d = self.crop_size + (1,) # Calculate output shape of D patch = int(self.output_size / 2 ** 4) self.output_shape_d = (patch, patch, patch, self.channels) self.batch_sz = 1 # for testing locally to avoid memory allocation # Number of filters in the first layer of G and D self.gf = 32 self.df = 32 # Train the discriminator faster than the generator #optimizerD = SGD(lr=0.001, decay=1e-6, momentum=0.9, nesterov=True) # in the paper the learning rate is 0.001 and weight decay is 0.5 optimizerD = Adam(0.001, decay=0.05) # in the paper the decay after 50K iterations by 0.5 self.decay = 0.5 self.iterations_decay = 50 self.learning_rate = 0.001 #optimizerG = SGD(lr=0.001, decay=1e-6, momentum=0.9, nesterov=True) # in the paper the decay after 50K iterations by 0.5 optimizerG = Adam(0.001, decay=0.05) # in the paper the decay after 50K iterations by 0.5 # Build the discriminator self.discriminator = self.build_discriminator() self.discriminator.summary() self.discriminator.compile(loss='binary_crossentropy', optimizer=optimizerD, metrics=['accuracy']) # Build the generator self.generator = self.build_generator() self.generator.summary() # Build the deformable transformation layer self.transformation = self.build_transformation() self.transformation.summary() # Input images and their conditioning images img_S = Input(shape=self.img_shape) img_T = Input(shape=self.img_shape) # By conditioning on T generate a warped transformation function of S phi = self.generator([img_S, img_T]) # Transform S warped_S = self.transformation([img_S, phi]) # Use Python partial to provide loss function with additional deformable field argument partial_gp_loss = partial(self.gradient_penalty_loss, phi=phi) partial_gp_loss.__name__ = 'gradient_penalty' # Keras requires function names # For the combined model we will only train the generator self.discriminator.trainable = False # Discriminators determines validity of translated images / condition pairs validity = self.discriminator([warped_S, img_T]) self.combined = Model(inputs=[img_S, img_T], outputs=validity) self.combined.summary() self.combined.compile(loss = partial_gp_loss, optimizer=optimizerG) if self.DEBUG: log_path = '/nrs/scicompsoft/elmalakis/GAN_Registration_Data/flydata/forSalma/lo_res/logs_ganunet_nogap/' os.makedirs(log_path, exist_ok=True) self.callback = TensorBoard(log_path) self.callback.set_model(self.combined) self.data_loader = DataLoader(batch_sz=self.batch_sz, crop_size=self.crop_size, dataset_name='fly', min_max=False, restricted_mask=False, use_hist_equilized_data=False, use_golden=False) """ Generator Network """ def build_generator(self): """U-Net Generator""" def conv3d(input_tensor, n_filters, kernel_size=(3, 3, 3), batch_normalization=True, scale=True, padding='valid', use_bias=False, name=''): """ 3D convolutional layer (+ batch normalization) followed by ReLu activation """ layer = Conv3D(filters=n_filters, kernel_size=kernel_size, padding=padding, use_bias=use_bias, name=name + '_conv3d')(input_tensor) if batch_normalization: layer = BatchNormalization(momentum=0.8, name=name+'_bn', scale=scale)(layer) #layer = LeakyReLU(alpha=0.2, name=name + '_actleakyrelu')(layer) layer = Activation("relu")(layer) return layer def deconv3d(input_tensor, n_filters, kernel_size=(3, 3, 3), batch_normalization=True, scale=True, padding='valid', use_bias=False, name=''): """ 3D deconvolutional layer (+ batch normalization) followed by ReLu activation """ layer = UpSampling3D(size=2)(input_tensor) layer = Conv3D(filters=n_filters, kernel_size=kernel_size, padding=padding, use_bias=use_bias, name=name + '_conv3d')(layer) if batch_normalization: layer = BatchNormalization(momentum=0.8, name=name+'_bn', scale=scale)(layer) #layer = LeakyReLU(alpha=0.2, name=name + '_actleakyrelu')(layer) layer = Activation("relu")(layer) return layer img_S = Input(shape=self.img_shape, name='input_img_S') img_T = Input(shape=self.img_shape, name='input_img_T') combined_imgs = Add(name='combine_imgs_g')([img_S,img_T]) # downsampling down1 = conv3d(input_tensor=combined_imgs, n_filters=self.gf, padding='same', name='down1_1') # 192 down1 = conv3d(input_tensor=down1, n_filters=self.gf, padding='same', name='down1_2') # 192 pool1 = MaxPooling3D(pool_size=(2, 2, 2), name='pool1')(down1) # 96 down2 = conv3d(input_tensor=pool1, n_filters=2 * self.gf, padding='same', name='down2_1') # 96 down2 = conv3d(input_tensor=down2, n_filters=2 * self.gf, padding='same', name='down2_2') # 96 pool2 = MaxPooling3D(pool_size=(2, 2, 2), name='pool2')(down2) # 48 down3 = conv3d(input_tensor=pool2, n_filters=4 * self.gf, padding='same', name='down3_1') # 48 down3 = conv3d(input_tensor=down3, n_filters=4 * self.gf, padding='same', name='down3_2') # 48 pool3 = MaxPooling3D(pool_size=(2, 2, 2), name='pool3')(down3) #24 down4 = conv3d(input_tensor=pool3, n_filters=8 * self.gf, padding='same', name='down4_1') # 24 down4 = conv3d(input_tensor=down4, n_filters=8 * self.gf, padding='same', name='down4_2') # 24 pool4 = MaxPooling3D(pool_size=(2, 2, 2), name='pool4')(down4) # 12 down5 = conv3d(input_tensor=pool4, n_filters=8 * self.gf, padding='same', name='down5_1') # 12 down5 = conv3d(input_tensor=down5, n_filters=8 * self.gf, padding='same', name='down5_2') # 12 pool5 = MaxPooling3D(pool_size=(2, 2, 2), name='pool5')(down5) # 6 center = conv3d(input_tensor=pool5, n_filters=16 * self.gf, padding='same', name='center1') # 6 center = conv3d(input_tensor=center, n_filters=16 * self.gf, padding='same', name='center2') # 6 # upsampling up5 = deconv3d(input_tensor=center, n_filters = 8*self.gf, padding='same', name='up5') # 12 up5 = concatenate([up5,down5]) # 12 up5 = conv3d(input_tensor=up5, n_filters=8 * self.gf, padding='same', name='up5_1') # 12 up5 = conv3d(input_tensor=up5, n_filters=8 * self.gf, padding='same', name='up5_2') # 12 up4 = deconv3d(input_tensor=up5, n_filters=8 * self.gf, padding='same', name='up4') #24 up4 = concatenate([up4, down4]) # 24 up4 = conv3d(input_tensor=up4, n_filters=8 * self.gf, padding='same', name='up4_1') # 24 up4 = conv3d(input_tensor=up4, n_filters=8 * self.gf, padding='same', name='up4_2') # 24 up3 = deconv3d(input_tensor=up4, n_filters=4 * self.gf, padding='same', name='up3') #48 up3 = concatenate([up3, down3]) # 48 up3 = conv3d(input_tensor=up3, n_filters=4 * self.gf, padding='same', name='up3_1') # 48 up3 = conv3d(input_tensor=up3, n_filters=4 * self.gf, padding='same', name='up3_2') # 48 up2 = deconv3d(input_tensor=up3, n_filters=2 * self.gf, padding='same', name='up2') # 96 up2 = concatenate([up2, down2]) # 96 up2 = conv3d(input_tensor=up2, n_filters=2 * self.gf, padding='same', name='up2_1') # 96 up2 = conv3d(input_tensor=up2, n_filters=2 * self.gf, padding='same', name='up2_2') # 96 up1 = deconv3d(input_tensor=up2, n_filters=self.gf, padding='same', name='up1') # 192 up1 = concatenate([up1, down1]) # 192 up1 = conv3d(input_tensor=up1, n_filters=self.gf, padding='same', name='up1_1') # 192 up1 = conv3d(input_tensor=up1, n_filters=self.gf, padding='same', name='up1_2') # 192 phi = Conv3D(filters=3, kernel_size=(1, 1, 1), strides=1, use_bias=False, padding='same', name='phi')(up1) #192 model = Model([img_S, img_T], outputs=phi, name='generator_model') return model """ Discriminator Network """ def build_discriminator(self): def d_layer(layer_input, filters, f_size=4, bn=True): """Discriminator layer""" d = Conv3D(filters, kernel_size=f_size, strides=2, padding='same')(layer_input) if bn: d = BatchNormalization(momentum=0.8)(d) #d = LeakyReLU(alpha=0.2)(d) d = Activation("relu")(d) return d img_S = Input(shape=self.img_shape) #192 S img_T = Input(shape=self.img_shape) #192 T combined_imgs = Add()([img_S, img_T]) d1 = d_layer(combined_imgs, self.df, bn=False) d2 = d_layer(d1, self.df*2) d3 = d_layer(d2, self.df*4) d4 = d_layer(d3, self.df*8) validity = Conv3D(1, kernel_size=4, strides=1, padding='same', activation='sigmoid', name='disc_sig')(d4) return Model([img_S, img_T], validity, name='discriminator_model') """ Transformation Network """ def build_transformation(self): img_S = Input(shape=self.img_shape, name='input_img_S_transform') # 192 phi = Input(shape=self.output_shape_g, name='input_phi_transform') # 192 warped_S = Lambda(dense_image_warp_3D, output_shape=self.input_shape_d)([img_S, phi]) return Model([img_S, phi], warped_S, name='transformation_layer') """ Define losses """ def gradient_penalty_loss(self, y_true, y_pred, phi): """ Computes gradient penalty on phi to ensure smoothness """ lr = K.mean(K.binary_crossentropy(y_true, y_pred), axis=-1) # compute the numerical gradient of phi gradients = numerical_gradient_3D(phi) # #if self.DEBUG: gradients = K.print_tensor(gradients, message='gradients are:') # # compute the euclidean norm by squaring ... gradients_sqr = K.square(gradients) # ... summing over the rows ... gradients_sqr_sum = K.sum(gradients_sqr, axis=np.arange(1, len(gradients_sqr.shape))) # # ... and sqrt gradient_l2_norm = K.sqrt(gradients_sqr_sum) # # compute lambda * (1 - ||grad||)^2 still for each single sample # #gradient_penalty = K.square(1 - gradient_l2_norm) # # return the mean as loss over all the batch samples return K.mean(gradient_l2_norm) + lr #return gradients_sqr_sum + lr """ Training """ def train(self, epochs, batch_size=1, sample_interval=50): # Adversarial loss ground truths # hard labels valid = np.ones((self.batch_sz,) + self.output_shape_d) fake = np.zeros((self.batch_sz,) + self.output_shape_d) start_time = datetime.datetime.now() for epoch in range(epochs): for batch_i, (batch_img, batch_img_template, batch_img_golden) in enumerate(self.data_loader.load_batch()): # --------------------- # Train Discriminator # --------------------- # Condition on B and generate a translate phi = self.generator.predict([batch_img, batch_img_template]) transform = self.transformation.predict([batch_img, phi]) # 256x256x256 # Create a ref image by perturbing th subject image with the template image perturbation_factor_alpha = 0.1 if epoch > epochs / 2 else 0.2 batch_ref = perturbation_factor_alpha * batch_img + (1 - perturbation_factor_alpha) * batch_img_template d_loss_real = self.discriminator.train_on_batch([batch_ref, batch_img_template], valid) d_loss_fake = self.discriminator.train_on_batch([transform, batch_img_template], fake) d_loss = 0.5 * np.add(d_loss_real, d_loss_fake) # --------------------- # Train Generator # --------------------- g_loss = self.combined.train_on_batch([batch_img, batch_img_template], valid) elapsed_time = datetime.datetime.now() - start_time print( "[Epoch %d/%d] [Batch %d/%d] [D loss average: %f, acc average: %3d%%, D loss fake:%f, acc: %3d%%, D loss real: %f, acc: %3d%%] [G loss: %f] time: %s" % (epoch, epochs, batch_i, self.data_loader.n_batches, d_loss[0], 100 * d_loss[1], d_loss_fake[0], 100 * d_loss_fake[1], d_loss_real[0], 100 * d_loss_real[1], g_loss, elapsed_time)) if self.DEBUG: self.write_log(self.callback, ['g_loss'], [g_loss], batch_i) self.write_log(self.callback, ['d_loss'], [d_loss[0]], batch_i) # If at save interval => save generated image samples if batch_i % sample_interval == 0 and epoch != 0 and epoch % 5 == 0: self.sample_images(epoch, batch_i) def write_log(self, callback, names, logs, batch_no): #https://github.com/eriklindernoren/Keras-GAN/issues/52 for name, value in zip(names, logs): summary = tf.Summary() summary_value = summary.value.add() summary_value.simple_value = value summary_value.tag = name callback.writer.add_summary(summary, batch_no) callback.writer.flush() def sample_images(self, epoch, batch_i): path = '/nrs/scicompsoft/elmalakis/GAN_Registration_Data/flydata/forSalma/lo_res/' os.makedirs(path+'generated_unet_nogap/' , exist_ok=True) idx, imgs_S = self.data_loader.load_data(is_validation=True) imgs_T = self.data_loader.img_template predict_img = np.zeros(imgs_S.shape, dtype=imgs_S.dtype) predict_phi = np.zeros(imgs_S.shape + (3,), dtype=imgs_S.dtype) input_sz = self.crop_size output_sz = (self.output_size, self.output_size, self.output_size) step = (64, 64, 64) start_time = datetime.datetime.now() for row in range(0, imgs_S.shape[0] - input_sz[0], step[0]): for col in range(0, imgs_S.shape[1] - input_sz[1], step[1]): for vol in range(0, imgs_S.shape[2] - input_sz[2], step[2]): patch_sub_img = np.zeros((1, input_sz[0], input_sz[1], input_sz[2], 1), dtype=imgs_S.dtype) patch_templ_img = np.zeros((1, input_sz[0], input_sz[1], input_sz[2], 1), dtype=imgs_T.dtype) patch_sub_img[0, :, :, :, 0] = imgs_S[row:row + input_sz[0], col:col + input_sz[1], vol:vol + input_sz[2]] patch_templ_img[0, :, :, :, 0] = imgs_T[row:row + input_sz[0], col:col + input_sz[1], vol:vol + input_sz[2]] patch_predict_phi = self.generator.predict([patch_sub_img, patch_templ_img]) patch_predict_warped = self.transformation.predict([patch_sub_img, patch_predict_phi]) predict_img[row:row + output_sz[0], col:col + output_sz[1], vol:vol + output_sz[2]] = patch_predict_warped[0, :, :, :, 0] predict_phi[row :row + output_sz[0], col :col + output_sz[1], vol :vol + output_sz[2],:] = patch_predict_phi[0, :, :, :, :] elapsed_time = datetime.datetime.now() - start_time print(" --- Prediction time: %s" % (elapsed_time)) nrrd.write(path+"generated_unet_nogap/%d_%d_%d" % (epoch, batch_i, idx), predict_img) self.data_loader._write_nifti(path+"generated_unet_nogap/phi%d_%d_%d" % (epoch, batch_i, idx), predict_phi) if epoch%10 == 0: file_name = 'gan_network'+ str(epoch) # save the whole network self.combined.save(path+ 'generated_unet_nogap/'+ file_name + '.whole.h5', overwrite=True) print('Save the whole network to disk as a .whole.h5 file') model_jason = self.combined.to_json() with open(path+ 'generated_unet_nogap/'+file_name + '_arch.json', 'w') as json_file: json_file.write(model_jason) self.combined.save_weights(path+ 'generated_unet_nogap/'+file_name + '_weights.h5', overwrite=True) print('Save the network architecture in .json file and weights in .h5 file')
# binary 'classifier' Fully connected layer #model.add(Conv2D(filters=1, kernel_size=(8, 8), name='fcn', activation="sigmoid")) return model, 'trained' trainSamples = aux.createSamples(xTrain, yTrain) validationSamples = aux.createSamples(xVal, yVal) sourceModel, modelName = train() x = sourceModel.output #x = Flatten()(x) #comment if using CNN model = Model(inputs=sourceModel.input, outputs=x) print(model.summary()) #loss is 'mse' or 'binary_crossentropy' model.compile(optimizer='adam', loss='mse', metrics=['accuracy']) useFlips= True batchSize = aux.promptForInt(message='Please specify the batch size (32, 64, etc.): ') epochCount = aux.promptForInt(message='Please specify the number of epochs: ') trainGen =aux. generator(samples=trainSamples,batchSize=batchSize) #,useFlips=useFlips) validGen = aux.generator(samples=validationSamples,batchSize=batchSize)#, useFlips=useFlips)
def get_unet(the_lr=1e-1, num_class=2, num_channel=10, size=2048 * 25): inputs = Input((size, num_channel)) # 2^11 print(inputs.shape) num_blocks = 4 # 128*25 -> 200 initial_filter = num_channel * 2 #15 scale_filter = 2 size_kernel = 7 activation = 'relu' padding = 'same' layer_down = [] layer_up = [] conv0 = BatchNormalization()(Conv1D(initial_filter, size_kernel, \ activation=activation, padding=padding)(inputs)) conv0 = BatchNormalization()(Conv1D(initial_filter, size_kernel, \ activation=activation, padding=padding)(conv0)) layer_down.append(conv0) num = initial_filter for i in range(num_blocks): num = int(num * scale_filter) the_layer = pcc(layer_down[i], num, size_kernel, activation=activation, padding=padding) layer_down.append(the_layer) layer_up.append(the_layer) for i in range(num_blocks): num = int(num / scale_filter) the_layer = ucc(layer_up[i], layer_down[-(i + 2)], num, size_kernel, activation=activation, padding=padding) layer_up.append(the_layer) #convn = Conv1D(1, 1, activation='sigmoid')(layer_up[-1]) #convn = Conv1D(1, 1, activation='relu')(layer_up[-1]) # output 25bp pool1 = MaxPooling1D(pool_size=5)(layer_up[-1]) convn = BatchNormalization()(Conv1D(int(initial_filter * 5), size_kernel, activation=activation, padding=padding)(pool1)) convn = BatchNormalization()(Conv1D(int(initial_filter * 5), size_kernel, activation=activation, padding=padding)(convn)) pool2 = MaxPooling1D(pool_size=5)(convn) convn = BatchNormalization()(Conv1D(int(initial_filter * 5), size_kernel, activation=activation, padding=padding)(pool2)) convn = BatchNormalization()(Conv1D(int(initial_filter * 5), size_kernel, activation=activation, padding=padding)(convn)) convn = Conv1D(num_class, 1, activation='relu')(convn) model = Model(inputs=[inputs], outputs=[convn]) # model.compile(optimizer=Adam(lr=the_lr,beta_1=0.9, beta_2=0.999,decay=1e-5), loss=dice_coef_loss, metrics=[dice_coef]) model.compile(optimizer=Adam(lr=the_lr, beta_1=0.9, beta_2=0.999, decay=1e-5), loss='mean_squared_error', metrics=[abse]) # model.compile(optimizer=Adam(lr=the_lr,beta_1=0.9, beta_2=0.999,decay=1e-5), loss=abse, metrics=[mse_loss]) # model.compile(optimizer=Adam(lr=the_lr,beta_1=0.9, beta_2=0.999,decay=1e-5), loss='mean_squared_error', metrics=[mse_loss]) return model
def __init__(self): K.set_image_data_format('channels_last') # set format K.set_image_dim_ordering('tf') self.DEBUG = 1 # Input shape self.img_rows = 192 self.img_cols = 192 self.img_vols = 192 self.channels = 1 self.batch_sz = 1 # for testing locally to avoid memory allocation self.crop_size = (self.img_rows, self.img_cols, self.img_vols) self.img_shape = self.crop_size + (self.channels,) self.output_size = 192 self.output_shape_g = self.crop_size + (3,) # phi has three outputs. one for each X, Y, and Z dimensions self.input_shape_d = self.crop_size + (1,) # Calculate output shape of D patch = int(self.output_size / 2 ** 4) self.output_shape_d = (patch, patch, patch, self.channels) self.batch_sz = 1 # for testing locally to avoid memory allocation # Number of filters in the first layer of G and D self.gf = 32 self.df = 32 # Train the discriminator faster than the generator #optimizerD = SGD(lr=0.001, decay=1e-6, momentum=0.9, nesterov=True) # in the paper the learning rate is 0.001 and weight decay is 0.5 optimizerD = Adam(0.001, decay=0.05) # in the paper the decay after 50K iterations by 0.5 self.decay = 0.5 self.iterations_decay = 50 self.learning_rate = 0.001 #optimizerG = SGD(lr=0.001, decay=1e-6, momentum=0.9, nesterov=True) # in the paper the decay after 50K iterations by 0.5 optimizerG = Adam(0.001, decay=0.05) # in the paper the decay after 50K iterations by 0.5 # Build the discriminator self.discriminator = self.build_discriminator() self.discriminator.summary() self.discriminator.compile(loss='binary_crossentropy', optimizer=optimizerD, metrics=['accuracy']) # Build the generator self.generator = self.build_generator() self.generator.summary() # Build the deformable transformation layer self.transformation = self.build_transformation() self.transformation.summary() # Input images and their conditioning images img_S = Input(shape=self.img_shape) img_T = Input(shape=self.img_shape) # By conditioning on T generate a warped transformation function of S phi = self.generator([img_S, img_T]) # Transform S warped_S = self.transformation([img_S, phi]) # Use Python partial to provide loss function with additional deformable field argument partial_gp_loss = partial(self.gradient_penalty_loss, phi=phi) partial_gp_loss.__name__ = 'gradient_penalty' # Keras requires function names # For the combined model we will only train the generator self.discriminator.trainable = False # Discriminators determines validity of translated images / condition pairs validity = self.discriminator([warped_S, img_T]) self.combined = Model(inputs=[img_S, img_T], outputs=validity) self.combined.summary() self.combined.compile(loss = partial_gp_loss, optimizer=optimizerG) if self.DEBUG: log_path = '/nrs/scicompsoft/elmalakis/GAN_Registration_Data/flydata/forSalma/lo_res/logs_ganunet_nogap/' os.makedirs(log_path, exist_ok=True) self.callback = TensorBoard(log_path) self.callback.set_model(self.combined) self.data_loader = DataLoader(batch_sz=self.batch_sz, crop_size=self.crop_size, dataset_name='fly', min_max=False, restricted_mask=False, use_hist_equilized_data=False, use_golden=False)
#x = GlobalAveragePooling2D()(x) x = Flatten()(x) x = concatenate([x, angle_layer]) # x = Dense(1024, activation='relu')(x) x = Dense(512, activation='relu')(x) #x = Dropout(0.2)(x) #x = Dropout(0.25)(x) #x = Dense(256, activation='relu')(x) x = Dropout(0.5)(x) #x = Dropout(0.25)(x) predictions = Dense(1, activation='sigmoid')(x) #model = Model(inputs=[input_tensor,input_2], outputs=predictions) model = Model(inputs=[base_model.input, input_2], outputs=predictions) #for layer in base_model.layers: # layer.trainable = False for layer in model.layers[:15]: layer.trainable = False for layer in model.layers[15:]: layer.trainable = True from keras.optimizers import SGD from keras.optimizers import Adam from keras.optimizers import RMSprop from keras.optimizers import Adagrad from keras.optimizers import Adadelta from keras.optimizers import Adamax from keras.optimizers import Nadam
def build_generator(self): """U-Net Generator""" def conv3d(input_tensor, n_filters, kernel_size=(3, 3, 3), batch_normalization=True, scale=True, padding='valid', use_bias=False, name=''): """ 3D convolutional layer (+ batch normalization) followed by ReLu activation """ layer = Conv3D(filters=n_filters, kernel_size=kernel_size, padding=padding, use_bias=use_bias, name=name + '_conv3d')(input_tensor) if batch_normalization: layer = BatchNormalization(momentum=0.8, name=name+'_bn', scale=scale)(layer) #layer = LeakyReLU(alpha=0.2, name=name + '_actleakyrelu')(layer) layer = Activation("relu")(layer) return layer def deconv3d(input_tensor, n_filters, kernel_size=(3, 3, 3), batch_normalization=True, scale=True, padding='valid', use_bias=False, name=''): """ 3D deconvolutional layer (+ batch normalization) followed by ReLu activation """ layer = UpSampling3D(size=2)(input_tensor) layer = Conv3D(filters=n_filters, kernel_size=kernel_size, padding=padding, use_bias=use_bias, name=name + '_conv3d')(layer) if batch_normalization: layer = BatchNormalization(momentum=0.8, name=name+'_bn', scale=scale)(layer) #layer = LeakyReLU(alpha=0.2, name=name + '_actleakyrelu')(layer) layer = Activation("relu")(layer) return layer img_S = Input(shape=self.img_shape, name='input_img_S') img_T = Input(shape=self.img_shape, name='input_img_T') combined_imgs = Add(name='combine_imgs_g')([img_S,img_T]) # downsampling down1 = conv3d(input_tensor=combined_imgs, n_filters=self.gf, padding='same', name='down1_1') # 192 down1 = conv3d(input_tensor=down1, n_filters=self.gf, padding='same', name='down1_2') # 192 pool1 = MaxPooling3D(pool_size=(2, 2, 2), name='pool1')(down1) # 96 down2 = conv3d(input_tensor=pool1, n_filters=2 * self.gf, padding='same', name='down2_1') # 96 down2 = conv3d(input_tensor=down2, n_filters=2 * self.gf, padding='same', name='down2_2') # 96 pool2 = MaxPooling3D(pool_size=(2, 2, 2), name='pool2')(down2) # 48 down3 = conv3d(input_tensor=pool2, n_filters=4 * self.gf, padding='same', name='down3_1') # 48 down3 = conv3d(input_tensor=down3, n_filters=4 * self.gf, padding='same', name='down3_2') # 48 pool3 = MaxPooling3D(pool_size=(2, 2, 2), name='pool3')(down3) #24 down4 = conv3d(input_tensor=pool3, n_filters=8 * self.gf, padding='same', name='down4_1') # 24 down4 = conv3d(input_tensor=down4, n_filters=8 * self.gf, padding='same', name='down4_2') # 24 pool4 = MaxPooling3D(pool_size=(2, 2, 2), name='pool4')(down4) # 12 down5 = conv3d(input_tensor=pool4, n_filters=8 * self.gf, padding='same', name='down5_1') # 12 down5 = conv3d(input_tensor=down5, n_filters=8 * self.gf, padding='same', name='down5_2') # 12 pool5 = MaxPooling3D(pool_size=(2, 2, 2), name='pool5')(down5) # 6 center = conv3d(input_tensor=pool5, n_filters=16 * self.gf, padding='same', name='center1') # 6 center = conv3d(input_tensor=center, n_filters=16 * self.gf, padding='same', name='center2') # 6 # upsampling up5 = deconv3d(input_tensor=center, n_filters = 8*self.gf, padding='same', name='up5') # 12 up5 = concatenate([up5,down5]) # 12 up5 = conv3d(input_tensor=up5, n_filters=8 * self.gf, padding='same', name='up5_1') # 12 up5 = conv3d(input_tensor=up5, n_filters=8 * self.gf, padding='same', name='up5_2') # 12 up4 = deconv3d(input_tensor=up5, n_filters=8 * self.gf, padding='same', name='up4') #24 up4 = concatenate([up4, down4]) # 24 up4 = conv3d(input_tensor=up4, n_filters=8 * self.gf, padding='same', name='up4_1') # 24 up4 = conv3d(input_tensor=up4, n_filters=8 * self.gf, padding='same', name='up4_2') # 24 up3 = deconv3d(input_tensor=up4, n_filters=4 * self.gf, padding='same', name='up3') #48 up3 = concatenate([up3, down3]) # 48 up3 = conv3d(input_tensor=up3, n_filters=4 * self.gf, padding='same', name='up3_1') # 48 up3 = conv3d(input_tensor=up3, n_filters=4 * self.gf, padding='same', name='up3_2') # 48 up2 = deconv3d(input_tensor=up3, n_filters=2 * self.gf, padding='same', name='up2') # 96 up2 = concatenate([up2, down2]) # 96 up2 = conv3d(input_tensor=up2, n_filters=2 * self.gf, padding='same', name='up2_1') # 96 up2 = conv3d(input_tensor=up2, n_filters=2 * self.gf, padding='same', name='up2_2') # 96 up1 = deconv3d(input_tensor=up2, n_filters=self.gf, padding='same', name='up1') # 192 up1 = concatenate([up1, down1]) # 192 up1 = conv3d(input_tensor=up1, n_filters=self.gf, padding='same', name='up1_1') # 192 up1 = conv3d(input_tensor=up1, n_filters=self.gf, padding='same', name='up1_2') # 192 phi = Conv3D(filters=3, kernel_size=(1, 1, 1), strides=1, use_bias=False, padding='same', name='phi')(up1) #192 model = Model([img_S, img_T], outputs=phi, name='generator_model') return model
def unet(num_filters=16, factor=2, optimizer="adam", loss="binary_crossentropy", img_size=(None, None), num_channels=3, max_val=255., **kwargs): settings_str = "\tnum_filters: {num_filters}\n" \ "\tfactor: {factor}\n" \ "\toptimizer: {optimizer}\n" \ "\tloss: {loss}\n" \ "\timg_size: {img_size}\n" \ "\tnum_channels: {num_channels}\n" \ "\tmax_val: {max_val}\n".format(num_filters=num_filters, factor=factor, optimizer=optimizer, loss=loss, img_size=img_size, num_channels=num_channels, max_val=max_val) logging.info("Creating keras unet model with settings:\n" + settings_str) inputs = Input(tuple(img_size) + (num_channels,), name="input") s = BatchNormalization()(Conv2D(num_filters, (1, 1), padding='same')(Lambda(lambda x: (1./max_val) * x)(inputs))) c1 = Activation('relu')(BatchNormalization()(Conv2D(num_filters, (3, 3), padding='same')(s))) c1 = Dropout(0.1)(c1) c1 = Activation('relu')(BatchNormalization()(Conv2D(num_filters, (3, 3), padding='same')(c1))) p1 = MaxPooling2D((2, 2))(c1) num_filters *= factor c2 = Activation('relu')(BatchNormalization()(Conv2D(num_filters, (3, 3), padding='same')(p1))) c2 = Dropout(0.1)(c2) c2 = Activation('relu')(BatchNormalization()(Conv2D(num_filters, (3, 3), padding='same')(c2))) p2 = MaxPooling2D((2, 2))(c2) num_filters *= factor c3 = Activation('relu')(BatchNormalization()(Conv2D(num_filters, (3, 3), padding='same')(p2))) c3 = Dropout(0.2)(c3) c3 = Activation('relu')(BatchNormalization()(Conv2D(num_filters, (3, 3), padding='same')(c3))) p3 = MaxPooling2D((2, 2))(c3) num_filters *= factor c4 = Activation('relu')(BatchNormalization()(Conv2D(num_filters, (3, 3), padding='same')(p3))) c4 = Dropout(0.2)(c4) c4 = Activation('relu')(BatchNormalization()(Conv2D(num_filters, (3, 3), padding='same')(c4))) p4 = MaxPooling2D(pool_size=(2, 2))(c4) num_filters *= factor c5 = Activation('relu')(BatchNormalization()(Conv2D(num_filters, (3, 3), padding='same')(p4))) c5 = Dropout(0.3)(c5) c5 = Activation('relu')(BatchNormalization()(Conv2D(num_filters, (3, 3), padding='same')(c5))) num_filters //= factor u6 = UpSampling2D(size=(2, 2))(c5) u6 = concatenate([u6, c4]) c6 = Activation('relu')(BatchNormalization()(Conv2D(num_filters, (3, 3), padding='same')(u6))) c6 = Dropout(0.2)(c6) c6 = Activation('relu')(BatchNormalization()(Conv2D(num_filters, (3, 3), padding='same')(c6))) num_filters //= factor u7 = UpSampling2D(size=(2, 2))(c6) u7 = concatenate([u7, c3]) c7 = Activation('relu')(BatchNormalization()(Conv2D(num_filters, (3, 3), padding='same')(u7))) c7 = Dropout(0.2)(c7) c7 = Activation('relu')(BatchNormalization()(Conv2D(num_filters, (3, 3), padding='same')(c7))) num_filters //= factor u8 = UpSampling2D(size=(2, 2))(c7) u8 = concatenate([u8, c2]) c8 = Activation('relu')(BatchNormalization()(Conv2D(num_filters, (3, 3), padding='same')(u8))) c8 = Dropout(0.1)(c8) c8 = Activation('relu')(BatchNormalization()(Conv2D(num_filters, (3, 3), padding='same')(c8))) num_filters //= factor u9 = UpSampling2D(size=(2, 2))(c8) u9 = concatenate([u9, c1], axis=3) c9 = Activation('relu')(BatchNormalization()(Conv2D(num_filters, (3, 3), padding='same')(u9))) c9 = Dropout(0.1)(c9) c9 = Activation('relu')(BatchNormalization()(Conv2D(num_filters, (3, 3), padding='same')(c9))) outputs = Conv2D(1, (1, 1), activation='sigmoid')(c9) model = Model(inputs=[inputs], outputs=[outputs]) model.compile(optimizer=optimizer, loss=get_loss(loss), metrics=[model_utils.mean_iou]) model.summary() return model
def train_sampled_softmax(self): ### Encoder model in_encoder = Input(shape=(self.encoder_length, ), dtype='int32', name='encoder_input') embed_encoder = Embedding(self.vocab_size, self.embedding_dim, input_length=self.encoder_length, name='embedding_encoder') in_enc_embedded = embed_encoder(in_encoder) fwd_encoder = GRU(self.birnn_dim, return_state=True, name='fwd_encoder') bwd_encoder = GRU(self.birnn_dim, return_state=True, name='bwd_encoder', go_backwards=True) out_encoder_1, _eh1 = fwd_encoder(in_enc_embedded) out_encoder_2, _eh2 = bwd_encoder(in_enc_embedded) out_bidir_encoder = concatenate([out_encoder_1, out_encoder_2], axis=-1, name='bidir_encoder') encoder_model = Model(inputs=in_encoder, outputs=out_bidir_encoder) self.encoder_model = encoder_model ### Decoder model in_decoder = Input(shape=(None, ), name='decoder_input', dtype='int32') embed_decoder = Embedding(self.vocab_size, self.embedding_dim, name='embedding_decoder') in_dec_embedded = embed_decoder(in_decoder) labels = Input((self.decoder_length + 1, 1), dtype='int32', name='labels_') fwd_decoder = GRU(self.rnn_dim, return_state=True) sampling_softmax = SamplingLayer(self.num_samples, self.vocab_size, mode='train') s0 = Input(shape=(self.rnn_dim, ), name='s0') s = [s0] losses = [] for t in range(self.decoder_length + 1): label_t = Lambda(lambda x: labels[:, t, :], name='label-%s' % t)(labels) x_dec = Lambda(lambda x: in_dec_embedded[:, t, :], name='dec_embedding-%s' % t)(in_dec_embedded) x_dec = Reshape((1, self.embedding_dim))(x_dec) if t == 0: s = out_bidir_encoder s, _ = fwd_decoder(x_dec, initial_state=s) loss = sampling_softmax([s, label_t]) losses.append(loss) s = [s] model = Model(inputs=[in_encoder, in_decoder, s0, labels], outputs=losses) self.train_model = model self.in_encoder = in_encoder self.out_bidir_encoder = out_bidir_encoder self.in_decoder = in_decoder self.embed_decoder = embed_decoder self.in_dec_embedded = in_dec_embedded self.labels = labels self.fwd_decoder = fwd_decoder return self.train_model