def test_training_model_bka_to_step_12_c(self): from keras import Model from dlnn.tests.ml.cnn_func_test import inputs from dlnn.util import MoorePenrose # # Feed Beta # feed = Model(inputs=inputs, outputs=step_11_c_activation) output = feed.predict(normalized) w_10_b = feed.get_layer(index=10).get_weights() w_12_b = [K.eval(K.dot(MoorePenrose.pinv3(output), K.variable(categorical_label_init)))] for i in range(12): layer = feed.get_layer(index=i).get_weights() self.assertIsNotNone(layer) # print("step_%d" % (i + 1), layer) # # Training Model # network = Model(inputs=inputs, outputs=step_12_c_dense) network.compile(optimizer=keras.optimizers.RMSprop(lr=0.0, rho=0.0, epsilon=None, decay=0.0), loss=keras.losses.categorical_crossentropy, metrics=[keras.metrics.categorical_accuracy, keras.metrics.mape]) network.get_layer(index=10).set_weights(w_10_b) network.get_layer(index=12).set_weights(w_12_b) network.fit(normalized, categorical_label_init, batch_size=normalized.shape[0]) self.assertTrue(numpy.allclose(w_10_b[0], network.get_layer(index=10).get_weights()[0], rtol=0)) self.assertTrue(numpy.allclose(w_12_b[0], network.get_layer(index=12).get_weights()[0], rtol=0)) result = network.predict(normalized, batch_size=normalized.shape[0]) self.assertIsNotNone(result)
def resnet_50(input_shape): img_input = Input(input_shape) x = Conv2D(64, (7, 7), strides=(2, 2), padding='same', name='conv1')(img_input) if input_shape[-1] > 3: x = Conv2D(64, (7, 7), strides=(2, 2), padding='same', name='conv1_changed')(img_input) x = BatchNormalization(name='bn_conv1')(x) x = Activation('relu')(x) x = MaxPooling2D((3, 3), strides=(2, 2), padding="same")(x) x = conv_block(x, 3, [64, 64, 256], stage=2, block='a', strides=(1, 1)) x = identity_block(x, 3, [64, 64, 256], stage=2, block='b') x = identity_block(x, 3, [64, 64, 256], stage=2, block='c') x = conv_block(x, 3, [128, 128, 512], stage=3, block='a') x = identity_block(x, 3, [128, 128, 512], stage=3, block='b') x = identity_block(x, 3, [128, 128, 512], stage=3, block='c') x = identity_block(x, 3, [128, 128, 512], stage=3, block='d') x = conv_block(x, 3, [256, 256, 1024], stage=4, block='a') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='b') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='c') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='d') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='e') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='f') x = conv_block(x, 3, [512, 512, 2048], stage=5, block='a') x = identity_block(x, 3, [512, 512, 2048], stage=5, block='b') x = identity_block(x, 3, [512, 512, 2048], stage=5, block='c') print("Loading pretrained weights for Resnet50...") weights_path = get_file( 'resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5', resnet50_padding.WEIGHTS_PATH_NO_TOP, cache_subdir='models', md5_hash='a268eb855778b3df3c7506639542a6af') model = Model(img_input, x) model.load_weights(weights_path, by_name=True) if input_shape[-1] > 3: print( "Loading weights for conv1 layer separately for the first 3 channels" ) conv1_weights = np.zeros((7, 7, input_shape[-1], 64), dtype="float32") resnet_ori = ResNet50(include_top=False, input_shape=(224, 224, 3)) conv1_weights[:, :, :3, :] = resnet_ori.get_layer( "conv1").get_weights()[0][:, :, :, :] # random init conv1_weights[:, :, 3:, :] = model.get_layer( 'conv1_changed').get_weights()[0][:, :, 3:, :] bias = resnet_ori.get_layer("conv1").get_weights()[1] model.get_layer('conv1_changed').set_weights((conv1_weights, bias)) model.get_layer('conv1_changed').name = 'conv1' return model
def get_model_cut_at(model: Model, cut_layer_name): cut_layer_output = model.get_layer(cut_layer_name).output cut_model = Model(inputs=[ model.get_layer("forward_image_input").input, model.get_layer("info_input").input, model.get_layer("hlc_input").input ], outputs=cut_layer_output) return cut_model
def test_check_weights_layer(self): from keras import Model from dlnn.tests.ml.cnn_func_test import inputs network = Model(inputs=inputs, outputs=step_11_a_activation) network.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) for i in range(12): layer = network.get_layer(index=i).get_weights() self.assertIsNotNone(layer) # print("step_%d" % (i + 1), layer) network.predict(normalized) for i in range(12): layer = network.get_layer(index=i).get_weights() self.assertIsNotNone(layer)
def test_predict(net, probe_path, gallery_path, pid_path, score_path): net = Model(inputs=[net.get_layer('resnet50').get_input_at(0)], outputs=[net.get_layer('resnet50').get_output_at(0)]) # net = Model(inputs=[net.input], outputs=[net.get_layer('avg_pool').output]) test_f, test_info = extract_feature(gallery_path, net) query_f, query_info = extract_feature(probe_path, net) result, result_argsort = sort_similarity(query_f, test_f) for i in range(len(result)): result[i] = result[i][result_argsort[i]] result = np.array(result) safe_remove(pid_path) safe_remove(score_path) np.savetxt(pid_path, result_argsort, fmt='%d') np.savetxt(score_path, result, fmt='%.4f')
def resnet_50(input_shape): img_input = Input(input_shape) x = Conv2D(64, (7, 7), strides=(2, 2), padding='same', name='conv1')(img_input) if input_shape[-1] > 3: x = Conv2D(64, (7, 7), strides=(2, 2), padding='same', name='conv1_changed')(img_input) x = BatchNormalization(name='bn_conv1')(x) x = Activation('relu')(x) x = MaxPooling2D((3, 3), strides=(2, 2), padding="same")(x) x = conv_block(x, 3, [64, 64, 256], stage=2, block='a', strides=(1, 1)) x = identity_block(x, 3, [64, 64, 256], stage=2, block='b') x = identity_block(x, 3, [64, 64, 256], stage=2, block='c') x = conv_block(x, 3, [128, 128, 512], stage=3, block='a') x = identity_block(x, 3, [128, 128, 512], stage=3, block='b') x = identity_block(x, 3, [128, 128, 512], stage=3, block='c') x = identity_block(x, 3, [128, 128, 512], stage=3, block='d') x = conv_block(x, 3, [256, 256, 1024], stage=4, block='a') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='b') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='c') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='d') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='e') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='f') x = conv_block(x, 3, [512, 512, 2048], stage=5, block='a') x = identity_block(x, 3, [512, 512, 2048], stage=5, block='b') x = identity_block(x, 3, [512, 512, 2048], stage=5, block='c') print("Loading pretrained weights for Resnet50...") weights_path = get_file('resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5', resnet50_padding.WEIGHTS_PATH_NO_TOP, cache_subdir='models', md5_hash='a268eb855778b3df3c7506639542a6af') model = Model(img_input, x) model.load_weights(weights_path, by_name=True) if input_shape[-1] > 3: print("Loading weights for conv1 layer separately for the first 3 channels") conv1_weights = np.zeros((7, 7, input_shape[-1], 64), dtype="float32") resnet_ori = ResNet50(include_top=False, input_shape=(224, 224, 3)) conv1_weights[:, :, :3, :] = resnet_ori.get_layer("conv1").get_weights()[0][:, :, :, :] # random init conv1_weights[:, :, 3:, :] = model.get_layer('conv1_changed').get_weights()[0][:, :, 3:, :] bias = resnet_ori.get_layer("conv1").get_weights()[1] model.get_layer('conv1_changed').set_weights((conv1_weights, bias)) model.get_layer('conv1_changed').name = 'conv1' return model
def build_cnn(): vgg_inst = vgg19.VGG19(include_top=True, weights='imagenet', input_tensor=None, input_shape=(224, 224, 3), pooling=None, classes=1000) x = vgg_inst.output x = Dense(64, activation="relu")(x) x = Dense(2, activation="softmax")(x) model = Model(inputs=vgg_inst.inputs, outputs=x) for i in model.layers: i.trainable = False trainable_layers = [ "block3_pool", "block4_conv1", "block4_conv2", "block4_conv3", "block4_conv4", "block4_pool", "block5_conv1", "block5_conv2", "block5_conv3", "block5_conv4", "block5_pool", "flatten", "fc1", "fc2", "predictions", "dense_1", "dense_2" ] for i in trainable_layers: model.get_layer(i).trainable = True sgd = SGD(lr=1e-6, decay=1e-6, momentum=0.9, nesterov=True) model.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=['accuracy']) return model
def build_combined_conv_model(word_indices, word_vectors, output_dim): learning_rate = args.learning_rate pos_model, _ = build_pos_sequence_conv_model(output_dim=64) word_model, _ = build_word_sequence_conv_model(word_indices, word_vectors, output_dim=64) char_model, _ = build_char_sequence_conv_model(output_dim=64) mrg = Concatenate(name='final_layer_mrg')( [pos_model.output, word_model.output, char_model.output]) dense = Dense(output_dim, activation='softmax')(mrg) model = Model(inputs=[pos_model.input, word_model.input, char_model.input], outputs=dense) print("\tLearning rate:", learning_rate) rmsprop = RMSprop(lr=learning_rate) model.compile(optimizer=rmsprop, loss='categorical_crossentropy', metrics=['categorical_accuracy']) final_layer = Model(inputs=model.input, outputs=model.get_layer('final_layer_mrg').output) return model, final_layer
def build_char_sequence_conv_model(output_dim): char_doc_input = Input(shape=(max_num_of_sentences, max_num_of_chars), dtype='int64') char_sent_input = Input(shape=(max_num_of_chars,), dtype='int64') embedded = Lambda(binarize_char, output_shape=binarize_char_outshape)(char_sent_input) block2 = char_block(embedded, (128, 256), filter_length=(5, 5), subsample=(1, 1), pool_length=(2, 2)) block3 = char_block(embedded, (192, 320), filter_length=(7, 5), subsample=(1, 1), pool_length=(2, 2)) sent_encode = concatenate([block2, block3], axis=-1) # sent_encode = Dropout(0.2)(sent_encode) encoder = Model(inputs=char_sent_input, outputs=sent_encode) encoder.summary() encoded = TimeDistributed(encoder)(char_doc_input) lstm_h = 92 lstm_layer = LSTM(lstm_h, return_sequences=True, dropout=0.1, recurrent_dropout=0.1, implementation=0)(encoded) lstm_layer2 = LSTM(lstm_h, return_sequences=False, dropout=0.1, recurrent_dropout=0.1, implementation=0, name='final_layer_char')(lstm_layer) # output = Dropout(0.2)(bi_lstm) output = Dense(output_dim, activation='softmax')(lstm_layer2) model = Model(outputs=output, inputs=char_doc_input) optimizer = 'rmsprop' model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=['categorical_accuracy']) final_layer = Model(inputs=model.input, outputs=model.get_layer('final_layer_char').output) return model, final_layer
class Autoencoder: def __init__(self, n_items, n_users, k=80, verbose=True): self.n_users = n_users self.n_items = n_items self.k = k self.verbose = verbose self._compile() def _compile(self): layer_item_id = Input(shape=(1,), name='item_id') layer_item_vector_compressed = Embedding(self.n_items, self.k, name='items_vectors') layer_item_ratings = Dense(self.n_users)(layer_item_vector_compressed(layer_item_id)) self.model = Model(layer_item_id, layer_item_ratings) self.model.compile('adam', 'mse') def train(self, rating_matrix, epochs=80): x_train = np.arange(self.n_items) y_train = rating_matrix.T.reshape(self.n_items, 1, self.n_users) self.model.fit(x=x_train, y=y_train, epochs=epochs, verbose=(1 if self.verbose else 0), validation_split=0) self.items_vectors = self.model.get_layer(name='items_vectors').get_weights()[0] def recommend(self, index_item, n): return KNN(index_item, self.items_vectors, n, cosine=False)
def create_prediction_model(self, model: Model, pyramids: List[str] = ('P3', 'P4', 'P5', 'P6', 'P7'), use_nms=True, name='retinanet-prediction'): # Get Pyramid Features pyramids = list(map(lambda p: p.lower(), pyramids)) pyramid_features = [ model.get_layer(p_name).output for p_name in pyramids ] anchors = self.generate_anchors(pyramid_features) clf_output = model.outputs[0] # (1, points 360360, n_labels) reg_output = model.outputs[1] # (1, points 360360, 4) boxes = RegressBoxes(name='boxes')([anchors, reg_output]) boxes = ClipBoxes(name='clipped_boxes')([model.inputs[0], boxes]) # Apply NMS / Score threshold / Select top-k outputs = FilterDetections(nms=use_nms, parallel_iterations=128, name='nms_filter')([boxes, clf_output]) # construct the model pred_model = keras.models.Model(inputs=model.inputs, outputs=outputs, name=name) return pred_model
def create_train_visual_feature_main(): from config import VISUAL_SIZE, last_layer from create_pickle_file import TRAIN_PICKLE, IMAGE_SIZE, NUM_CHANNELS from dataset_utils import FILE_NAME_CID_PATH all_train_fine_labels = read_pickle_file( FILE_NAME_CID_PATH)['all_train_fine_labels'] print('LOADING CLASSIFIER AT {} ...'.format(BEST_CLASSIFY_CKPT_FILE)) model = load_model(BEST_CLASSIFY_CKPT_FILE) model = Model(inputs=model.input, outputs=model.get_layer(last_layer).output) print('LOADING TRAIN DATA....') X = read_pickle_file(TRAIN_PICKLE)['data'] X = X.reshape(-1, IMAGE_SIZE, IMAGE_SIZE, NUM_CHANNELS) print('Creating training visual feature .... ') features = model.predict(X, verbose=1).reshape(-1, VISUAL_SIZE) features_f = open(TRAIN_FEATURE_PATH, 'wb') pickle.dump( { 'features': features, 'fine_label_names': all_train_fine_labels }, features_f, protocol=4) features_f.close() print("Done.")
def mobilenet_3d(input_shape: tuple, model_2d: Model): input_image = Input(input_shape) x = ZeroPadding3D()(input_image) x = conv2d3d(model_2d.get_layer('conv1'))(x) x = BatchNormalization()(x) x = Activation('relu')(x) x = ZeroPadding3D()(x) x = DepthwiseConv2D()(x)
def build_word_sequence_lstm_model(word_indices, word_vectors, output_dim): lstm_unit_size = args.lstm_unit_size learning_rate = args.learning_rate dropout = 0.6 # from word_indices of all word vocabulary to word_embedded for one sentence of text word_symbols = len(word_indices) + 1 word_embedding_weights = np.zeros((word_symbols, word_embeddings_size)) for word, index in word_indices.items(): try: word_embedding_weights[index, :] = word_vectors[word] except KeyError: word_embedding_weights[ index, :] = np.ones(word_embeddings_size) * -1 doc_word_input = Input(shape=(max_num_of_sentences, max_num_of_tokens_per_sentence), dtype='int64', name="doc_word_input") sent_word_input = Input(shape=(max_num_of_tokens_per_sentence, ), dtype='int64', name="sent_word_input") word_embedding_layer = Embedding(output_dim=word_embeddings_size, input_dim=word_symbols, mask_zero=True) word_embedding_layer.build( (None, )) # if you don't do this, the next step won't work word_embedding_layer.set_weights([word_embedding_weights]) word_embedded = word_embedding_layer(sent_word_input) bi_lstm_word_sent = Bidirectional( GRU(lstm_unit_size, return_sequences=rueT))(word_embedded) #attention_word = AttentionWithContext()(bi_lstm_word_sent) word_sent_encode = Dropout(dropout)(bi_lstm_word_sent) #(attention_word) word_encoder = Model(inputs=sent_word_input, outputs=word_sent_encode) word_encoded = TimeDistributed(word_encoder)(doc_word_input) b_lstm_word_doc = Bidirectional(GRU(lstm_unit_size, return_sequences=False))(word_encoded) word_output = Dropout(dropout, name='final_layer_word')( b_lstm_word_doc) #(attention_doc) word_output = Dense(output_dim, activation='softmax')(word_output) #(word_output) model = Model(inputs=doc_word_input, outputs=word_output) rmsprop = RMSprop(lr=learning_rate) model.compile(optimizer=rmsprop, loss='categorical_crossentropy', metrics=['categorical_accuracy']) final_layer = Model(inputs=model.input, outputs=model.get_layer('final_layer_word').output) # final_layer = Model(inputs=model.input, outputs=model.get_layer('final_layer_word').output) return model, final_layer
def _get_outputs(model: keras.Model, input_specs: Optional[Sequence[NodeSpec]]): if input_specs is None: return model.outputs return [ tensor for input_spec in input_specs for tensor in _iterate_tensors( model.get_layer(input_spec.layer_name).get_output_at( input_spec.node_index)) ]
def deepspeech_custom(is_gpu: bool, layers: List[dict], input_dim: int, to_freeze: List[dict] = [], random_state=1) -> Model: np.random.seed(random_state) set_random_seed(random_state) constructors = { 'BatchNormalization': lambda params: BatchNormalization(**params), 'Conv2D': lambda params: Conv2D(**params, name=name), 'Dense': lambda params: TimeDistributed(Dense(**params), name=name), 'Dropout': lambda params: Dropout(**params), 'LSTM': lambda params: Bidirectional(CuDNNLSTM(**params) if is_gpu else LSTM( activation='tanh', recurrent_activation='sigmoid', **params), merge_mode='sum', name=name), 'ReLU': lambda params: ReLU(**params), 'ZeroPadding2D': lambda params: ZeroPadding2D(**params), 'expand_dims': lambda params: Lambda(expand_dims, arguments=params), 'squeeze': lambda params: Lambda(squeeze, arguments=params), 'squeeze_last_dims': lambda params: Reshape([-1, params['units']]) } with tf.device('/cpu:0'): input_tensor = Input([None, input_dim], name='X') x = input_tensor for params in layers: constructor_name = params.pop('constructor') name = params.pop( 'name' ) if 'name' in params else None # `name` is implicit passed to constructors constructor = constructors[ constructor_name] # Conv2D, TimeDistributed and Bidirectional. layer = constructor(params) x = layer(x) output_tensor = x model = Model(input_tensor, output_tensor, name='DeepSpeech') for params in to_freeze: name = params.pop('name') layer = model.get_layer(name) layer.trainable = False return model
def get_embedding(encoder, image_data): # get the encoder layer layer_name = 'encoded' encoder = Model(inputs=encoder.input, outputs=encoder.get_layer(layer_name).output) image_data = np.expand_dims( image_data, 0) if not len(image_data.shape) == 4 else image_data image_data = image_data.astype('float32') / 255. encoded_img = encoder.predict(image_data) return encoded_img
def transfer_weights(model_2d: Model, model_3d: Model): for l2 in model_2d.layers: if type(l2).__name__ == 'Conv2D': n2 = l2.name try: l3 = model_3d.get_layer(n2) s = l3.kernel.shape[0] w = l2.get_weights() w[0] = np.array(w[0] * s) l3.set_weights(w) except ValueError: pass
def _get_inputs(model: keras.Model, input_specs: Optional[Sequence[NodeSpec]]): if input_specs is None: return [ Input(tensor=tensor, data_format=_get_data_format(tensor)) for tensor in model.inputs ] return [ Input(tensor=tensor, data_format=_get_data_format(tensor)) for input_spec in input_specs for tensor in _iterate_tensors( model.get_layer(input_spec.layer_name).get_input_at( input_spec.node_index)) ]
def build_char_sequence_lstm_model(char_indices, char_vectors, output_dim): lstm_unit_size = args.lstm_unit_size learning_rate = args.learning_rate lstm_dropout = 0.15 dropout = 0.3 doc_char_input = Input(shape=(max_num_of_sentences, max_num_of_chars), dtype='int64', name="doc_char_input") sent_char_input = Input(shape=(max_num_of_chars,), dtype='int64', name="sent_char_input") char_symbols = len(char_indices) + 1 char_embedding_weights = np.zeros((char_symbols, char_embeddings_size)) for char, index in char_indices.items(): char_embedding_weights[index, :] = char_vectors[char] char_embedding_layer = Embedding(output_dim=char_embeddings_size, input_dim=char_symbols, mask_zero=True) char_embedding_layer.build((None,)) # if you don't do this, the next step won't work char_embedding_layer.set_weights([char_embedding_weights]) char_embedded = char_embedding_layer(sent_char_input) # filter_length = [5, 3, 3] # nb_filter = [196, 196, 256] # pool_length = 2 # char_embedded = Lambda(binarize_char, output_shape=binarize_char_outshape)(sent_char_input) # for i in range(len(nb_filter)): # char_embedded = Conv1D(filters=nb_filter[i], kernel_size=filter_length[i], padding='valid', activation='relu', # kernel_initializer='glorot_normal', strides=1)(char_embedded) # # char_embedded = Dropout(0.1)(char_embedded) # char_embedded = MaxPooling1D(pool_size=pool_length)(char_embedded) bi_lstm_char_sent = Bidirectional( LSTM(lstm_unit_size, return_sequences=False, dropout=lstm_dropout, recurrent_dropout=lstm_dropout))( char_embedded) char_sent_encode = Dropout(dropout)(bi_lstm_char_sent) char_encoder = Model(inputs=sent_char_input, outputs=char_sent_encode) char_encoded = TimeDistributed(char_encoder)(doc_char_input) b_lstm_char_doc = Bidirectional( LSTM(lstm_unit_size, return_sequences=False, dropout=lstm_dropout, recurrent_dropout=lstm_dropout))( char_encoded) char_output = Dropout(dropout, name='final_layer_char')(b_lstm_char_doc) char_output = Dense(output_dim, activation='softmax')(char_output) model = Model(inputs=doc_char_input, outputs=char_output) rmsprop = RMSprop(lr=learning_rate) model.compile(optimizer=rmsprop, loss='categorical_crossentropy', metrics=['categorical_accuracy']) final_layer = Model(inputs=model.input, outputs=model.get_layer('final_layer_char').output) return model, final_layer
def test_manual_merge_categorical_value(self): from keras import Model from dlnn.tests.ml.cnn_func_test import inputs from dlnn.util import MoorePenrose import tensorflow as tf # # Feed Beta # feed = Model(inputs=inputs, outputs=step_11_a_activation) output = feed.predict(normalized) w_10_a = feed.get_layer(index=10).get_weights() w_12_a = [K.eval(K.dot(MoorePenrose.pinv3(output), K.variable(categorical_label_init)))] feed = Model(inputs=inputs, outputs=step_11_b_activation) output = feed.predict(normalized) w_10_b = feed.get_layer(index=10).get_weights() w_12_b = [K.eval(K.dot(MoorePenrose.pinv3(output), K.variable(categorical_label_init)))] feed = Model(inputs=inputs, outputs=step_11_c_activation) output = feed.predict(normalized) w_10_c = feed.get_layer(index=10).get_weights() w_12_c = [K.eval(K.dot(MoorePenrose.pinv3(output), K.variable(categorical_label_init)))] # # Training Model # network = Model(inputs=inputs, outputs=step_14_reshape) network.compile(optimizer=keras.optimizers.RMSprop(lr=0.0, rho=0.0, epsilon=None, decay=0.0), loss=keras.losses.categorical_crossentropy, metrics=[keras.metrics.categorical_accuracy, keras.metrics.mape]) network.get_layer(index=10).set_weights(w_10_a) network.get_layer(index=11).set_weights(w_10_b) network.get_layer(index=12).set_weights(w_10_c) network.get_layer(index=16).set_weights(w_12_a) network.get_layer(index=17).set_weights(w_12_b) network.get_layer(index=18).set_weights(w_12_c) result = network.predict(normalized, batch_size=normalized.shape[0]) # print(result) result = K.cast(K.argmax(result), dtype=tf.int32) # print(K.eval(result)) result = tf.map_fn(lambda x: tf.bincount(x, minlength=3), result) # print(K.eval(result)) result = K.argmax(result) # print(K.eval(result)) self.assertIsNotNone(result)
def __train(self, x, y): assert self.layer is not None yc = to_categorical(y, self.category_num) elm_1_beta_net = Model(inputs=self.layer['input'], outputs=self.layer['elm_1_activation_1']) elm_1_activation_1_o = elm_1_beta_net.predict(x) elm_1_dense_1_w = elm_1_beta_net.get_layer( name='elm_1_dense_1').get_weights() elm_1_dense_2_w = [ K.eval(K.dot(MoorePenrose.pinv3(elm_1_activation_1_o), yc)) ] elm_2_beta_net = Model(inputs=self.layer['input'], outputs=self.layer['elm_2_activation_1']) elm_2_activation_1_o = elm_2_beta_net.predict(x) elm_2_dense_1_w = elm_2_beta_net.get_layer( name='elm_2_dense_1').get_weights() elm_2_dense_2_w = [ K.eval(K.dot(MoorePenrose.pinv3(elm_2_activation_1_o), yc)) ] elm_3_beta_net = Model(inputs=self.layer['input'], outputs=self.layer['elm_3_activation_1']) elm_3_activation_1_o = elm_3_beta_net.predict(x) elm_3_dense_1_w = elm_3_beta_net.get_layer( name='elm_3_dense_1').get_weights() elm_3_dense_2_w = [ K.eval(K.dot(MoorePenrose.pinv3(elm_3_activation_1_o), yc)) ] network = Model(inputs=self.layer['input'], outputs=self.layer['fully_connected_merge']) network.compile(optimizer=RMSprop(lr=0.0, rho=0.0, epsilon=None, decay=0.0), loss=categorical_crossentropy, metrics=[categorical_accuracy, mape]) network.get_layer(name='elm_1_dense_1').set_weights(elm_1_dense_1_w) network.get_layer(name='elm_1_dense_2').set_weights(elm_1_dense_2_w) network.get_layer(name='elm_2_dense_1').set_weights(elm_2_dense_1_w) network.get_layer(name='elm_2_dense_2').set_weights(elm_2_dense_2_w) network.get_layer(name='elm_3_dense_1').set_weights(elm_3_dense_1_w) network.get_layer(name='elm_3_dense_2').set_weights(elm_3_dense_2_w) network.fit(x, yc) network.save(self.network_path)
def vae_classifier(vae_model: keras.Model): for layer in vae_model.layers: layer.trainable = False encoded = vae_model.get_layer(name=VAE_ENCODER_LAYER).output x = Flatten()(encoded) x = Dense(512)(x) x = Activation("relu")(x) x = Dense(len(DAN_LIST))(x) x = Activation("softmax")(x) model = Model(vae_model.input, x) model.compile("adam", loss="mean_squared_error", metrics=["accuracy"]) model.summary() return model
def std_net(self): out = self.g(self.feature_layers_num) center_cls, scale_regr, offset, angle = HEAD(1)(out) m = Model(inputs=self.inp, outputs=[center_cls, scale_regr, offset]) conv2d_6 = m.get_layer('conv2d_6').output x = self.up_2x(conv2d_6, 32, self.mode) stage1 = m.get_layer('block1_pool').output x = Concatenate(axis=-1)([x, stage1]) bn1 = BatchNormalization()(x) conv_1 = Conv2D(32, 1, activation='relu', padding='same')(bn1) bn2 = BatchNormalization()(conv_1) conv_2 = Conv2D(32, 3, activation='relu', padding='same')(bn2) x = self.up_2x(conv_2, 32, self.mode) x = Conv2D(16, (3, 3), padding='same', activation='relu')(x) center_line = Conv2D(1, kernel_size=1, strides=1, activation='sigmoid', name='cl')(x) outs = m.outputs return Model(m.input, [center_line] + outs)
def createAndSaveVGGVectors(trainData, testData, classSize): vggModel: Model = keras.applications.vgg16.VGG16(include_top=False, weights='imagenet', input_shape=(200, 200, 3), pooling='max') vggModel.summary() vggModel = Model(inputs=vggModel.input, outputs=vggModel.get_layer("fc1").output) vggModel.summary() intermediate_prediction = vggModel.predict(trainData) print(intermediate_prediction.shape) np.save("predictionVGG.npy", intermediate_prediction) intermediate_prediction = vggModel.predict(testData) print(intermediate_prediction.shape) np.save("predictionTestVGG.npy", intermediate_prediction) print("Kaydedildi.")
def create_test_visual_feature_main(): from config import VISUAL_SIZE, last_layer from create_pickle_file import TEST_PICKLE, IMAGE_SIZE, NUM_CHANNELS from read_zjl import read_pickle_file print('LOADING TEST DATA....') X = read_pickle_file(TEST_PICKLE).reshape(-1, IMAGE_SIZE, IMAGE_SIZE, NUM_CHANNELS) print('LOADING CLASSIFIER AT {} ...'.format(BEST_CLASSIFY_CKPT_FILE)) model = load_model(BEST_CLASSIFY_CKPT_FILE) model = Model(inputs=model.input, outputs=model.get_layer(last_layer).output) print('Creating Test Feature...') features = model.predict(X, verbose=1).reshape(-1, VISUAL_SIZE) with open(TEST_FEATURE_PATH, 'wb') as features_f: pickle.dump({'features': features}, features_f, protocol=4) print("Done.")
def layer_learned(model: Model, layer_name, img_path): img = np.load(img_path) img = img[np.newaxis, :, :, :, np.newaxis] img = (img - np.min(img)) / (np.max(img) - np.min(img)) layer_output = model.get_layer(layer_name).output activation_mode = models.Model(inputs=model.input, outputs=layer_output) activations = activation_mode.predict(img) activations = np.mean(activations, -1) activations = np.squeeze(activations) plt.figure() for i in range(9): plt.subplot(3, 3, 1 + i) plt.imshow(activations[:, :, 20 + i], cmap='viridis') plt.savefig(os.path.join(pic_path, 'second_conv_learned.png')) plt.show()
def proper_scoring_method(X_train, X_val, X_test, y_train): # Transform data for neural network X_train = StandardScaler().fit_transform(X_train) X_val = StandardScaler().fit_transform(X_val) X_test = StandardScaler().fit_transform(X_test) # Build training model, one hidden layer with 1000 neurons inputs = Input(shape=(X_train.shape[1], )) x = Dense(1000, activation='tanh')(inputs) mu, sigma = ProperScoringLayer(1, name='main_output')(x) model = Model(inputs, mu) model.compile(loss=custom_loss(sigma), optimizer=Adam(lr=1e-3)) # Implements early stopping callback = [ tf.keras.callbacks.EarlyStopping(monitor='loss', patience=3, min_delta=0.04) ] # Train model model.fit(X_train, y_train, epochs=500, callbacks=callback, batch_size=150) # Allows us to make predictions with our model get_intermediate = K.function( inputs=[model.input], outputs=model.get_layer('main_output').output) # Make predictions for mean and variance test_predictions, sigmas = [], [] for record in X_test: mu, sigma = get_intermediate(np.array([record])) test_predictions.append(mu.reshape(1, )[0]) sigmas.append(sigma.reshape(1, )[0]) variance = np.abs(np.array(sigmas)) # Validation set predictions for kNN ICP val_predictions, _ = get_intermediate(X_val) print_log('Done proper scoring method training and predictions') return np.array(test_predictions), val_predictions.ravel(), variance
def getFeature(modelpath, imglist): x = fe.img2array(imglist) model = load_model(modelpath) oriimgclass = model.predict(x) imgclass = [] for i in range(0, len(imglist)): max = 0 maxindex = 0 for j in range(0, 10): if (oriimgclass[i][j] > max): max = oriimgclass[i][j] maxindex = j print((max, maxindex + 1)) imgclass.append(maxindex + 1) imgclass = np.array(imgclass) model = Model(inputs=model.input, outputs=model.get_layer('fc-final').output) imgfeature = model.predict(x) return imgclass, imgfeature
def build_cnn(): nasnet_inst = resnet50.ResNet50(include_top=True, weights='imagenet', input_tensor=None, input_shape=(HEIGHT,WIDTH,3), pooling=None, classes=1000) x = nasnet_inst.get_layer("flatten_1").output x = Dense(1000, activation="relu")(x) x = Dense(64, activation="relu")(x) x = Dense(2, activation="softmax")(x) model = Model(inputs=nasnet_inst.inputs, outputs=x) for i in model.layers: i.trainable = True non_trainable = ["input_1","conv1_pad","conv1","bn_conv1","activation_1","max_pooling2d_1", "res2a_branch2a","bn2a_branch2a","activation_2", "res2a_branch2b","bn2a_branch2b","activation_3","res2a_branch2c","res2a_branch1","bn2a_branch2c","bn2a_branch1", "add_1","bn2a_branch1","activation_4","res2b_branch2a","bn2b_branch2a","activation_5","res2b_branch2b","bn2b_branch2b","activation_6","res2b_branch2c","bn2b_branch2c", "add_2","activation_4","activation_7","res2c_branch2a","bn2c_branch2a","activation_8","res2c_branch2b","bn2c_branch2b","activation_9","res2c_branch2c","bn2c_branch2c", "add_3","activation_7","activation_10","res3a_branch2a","bn3a_branch2a","activation_11","res3a_branch2b","bn3a_branch2b","activation_12","res3a_branch2c","res3a_branch1","bn3a_branch2c","bn3a_branch1"] # "add_4","bn3a_branch1","activation_13","res3b_branch2a","bn3b_branch2a","activation_14","res3b_branch2b","bn3b_branch2b","activation_15","res3b_branch2c","bn3b_branch2c", # "add_5","activation_13","activation_16","res3c_branch2a","bn3c_branch2a","activation_17","res3c_branch2b","bn3c_branch2b","activation_18","res3c_branch2c","bn3c_branch2c", # "add_6","activation_16","activation_19","res3d_branch2a","bn3d_branch2a","activation_20","res3d_branch2b","bn3d_branch2b","activation_21","res3d_branch2c","bn3d_branch2c", # "add_7","activation_19","activation_22","res4a_branch2a","bn4a_branch2a","activation_23","res4a_branch2b","bn4a_branch2b","activation_24","res4a_branch2c","res4a_branch1","bn4a_branch2c","bn4a_branch1", # "add_8","bn4a_branch1[0][0]","activation_25","res4b_branch2a","bn4b_branch2a","activation_26","res4b_branch2b","bn4b_branch2b","activation_27","res4b_branch2c","bn4b_branch2c", # "add_9","activation_25[0][0]","activation_28","res4c_branch2a","bn4c_branch2a","activation_29","res4c_branch2b","bn4c_branch2b","activation_30","res4c_branch2c","bn4c_branch2c", # "add_10","activation_28[0][0]","activation_31","res4d_branch2a","bn4d_branch2a","activation_32","res4d_branch2b","bn4d_branch2b","activation_33","res4d_branch2c","bn4d_branch2c", # "add_11","activation_31[0][0]","activation_34","res4e_branch2a","bn4e_branch2a","activation_35","res4e_branch2b","bn4e_branch2b","activation_36","res4e_branch2c","bn4e_branch2c", # "add_12","activation_34","activation_37","res4f_branch2a","bn4f_branch2a","activation_38","res4f_branch2b","bn4f_branch2b","activation_39","res4f_branch2c","bn4f_branch2c", # "add_13","activation_37","activation_40","res5a_branch2a","bn5a_branch2a","activation_41","res5a_branch2b","bn5a_branch2b","activation_42","res5a_branch2c","res5a_branch1","bn5a_branch2c","bn5a_branch1", # "add_14","bn5a_branch1","activation_43","res5b_branch2a","bn5b_branch2a","activation_44","res5b_branch2b","bn5b_branch2b","activation_45","res5b_branch2c","bn5b_branch2c", # "add_15","activation_43","activation_46","res5c_branch2a","bn5c_branch2a","activation_47","res5c_branch2b","bn5c_branch2b","activation_48","res5c_branch2c","bn5c_branch2c", # "add_16","activation_46","activation_49","avg_pool","flatten_1","fc1000"] for i in non_trainable: try: model.get_layer(i).trainable = False except ValueError: print("Layer does not exist: ",i) sgd = SGD(lr=1e-6, decay=1e-6, momentum=0.9, nesterov=True) model.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=['accuracy']) return model
def build_word_sequence_conv_model(word_indices, word_vectors, output_dim): word_symbols = len(word_indices) + 1 word_embedding_weights = np.zeros((word_symbols, word_embeddings_size)) for word, index in word_indices.items(): word_embedding_weights[index, :] = word_vectors[word] word_doc_input = Input(shape=(max_num_of_sentences, max_num_of_tokens_per_sentence), dtype='int64') word_sent_input = Input(shape=(max_num_of_tokens_per_sentence,), dtype='int64') word_embedding_layer = Embedding(output_dim=word_embeddings_size, input_dim=word_symbols, mask_zero=False) word_embedding_layer.build((None,)) # if you don't do this, the next step won't work word_embedding_layer.set_weights([word_embedding_weights]) word_embedded = word_embedding_layer(word_sent_input) block2 = char_block(word_embedded, (128, 256), filter_length=(5, 5), subsample=(1, 1), pool_length=(2, 2)) block3 = char_block(word_embedded, (192, 320), filter_length=(7, 5), subsample=(1, 1), pool_length=(2, 2)) sent_encode = concatenate([block2, block3], axis=-1) # sent_encode = Dropout(0.2)(sent_encode) encoder = Model(inputs=word_sent_input, outputs=sent_encode) encoder.summary() encoded = TimeDistributed(encoder)(word_doc_input) lstm_h = 92 lstm_layer = LSTM(lstm_h, return_sequences=True, dropout=0.1, recurrent_dropout=0.1, implementation=0)(encoded) lstm_layer2 = LSTM(lstm_h, return_sequences=False, dropout=0.1, recurrent_dropout=0.1, implementation=0, name='final_layer_word')(lstm_layer) # output = Dropout(0.2)(bi_lstm) output = Dense(output_dim, activation='softmax')(lstm_layer2) model = Model(outputs=output, inputs=word_doc_input) optimizer = 'rmsprop' model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=['categorical_accuracy']) final_layer = Model(inputs=model.input, outputs=model.get_layer('final_layer_word').output) return model, final_layer