Example #1
0
 def net(self, x):
     data_input = Input(shape=x.shape[1:])
     f2,f3, f4, f5 = self.__call__(data_input)
     net = Model(inputs=data_input, outputs=f5)
     net.build(x.shape)
     net.summary()
     return net
Example #2
0
def build_model():

    state_emb_input = Input(shape=(1, ))
    county_emb_input = Input(shape=(1, ))
    data_input = Input(shape=(sequence_length, 3))

    state_emb = Embedding(input_dim=n_state_labels,
                          output_dim=8,
                          input_length=1)(state_emb_input)
    county_emb = Embedding(input_dim=n_county_labels,
                           output_dim=8,
                           input_length=1)(county_emb_input)
    embedding = Concatenate()([state_emb, county_emb])
    embedding = Flatten()(embedding)
    embedding = Dense(sequence_length, activation='linear')(embedding)
    embedding = Reshape((sequence_length, 1))(embedding)
    concat = Concatenate()([data_input, embedding])

    out = LSTM(128, dropout=0.2, return_sequences=True)(concat)
    out = LSTM(256, dropout=0.2, return_sequences=False)(out)
    out1 = Dense(1, activation='linear', name='Confirmed_Cases')(out)
    out2 = Dense(1, activation='linear', name='Total_Deaths')(out)

    model = Model([state_emb_input, county_emb_input, data_input],
                  [out1, out2])
    model.build(input_shape=((1, ), (1, ), (sequence_length, 1)))
    model.summary()
    return model
Example #3
0
def construct_bert(model_dir,
                   timesteps,
                   classes,
                   dense_dropout=0.5,
                   attention_dropout=0.3,
                   hidden_dropout=0.3,
                   adapter_size=8):
    bert_ckpt_file = os.path.join(model_dir, "bert_model.ckpt")
    bert_config_file = os.path.join(model_dir, "bert_config.json")
    bert_params = bert.params_from_pretrained_ckpt(model_dir)
    bert_model = bert.BertModelLayer.from_params(bert_params, name="bert")

    input_ids = Input(shape=(timesteps, ), dtype='int32', name="input_ids_1")
    token_type_ids = Input(shape=(timesteps, ),
                           dtype='int32',
                           name="token_type_ids_1")

    dense = Dense(units=768, activation="tanh", name="dense")
    output = bert_model([input_ids, token_type_ids
                         ])  # output: [batch_size, max_seq_len, hidden_size]

    print("bert shape", output.shape)
    cls_out = Lambda(lambda seq: seq[:, 0:1, :])(output)
    cls_out = Dropout(dense_dropout)(cls_out)
    logits = dense(cls_out)
    logits = Dropout(dense_dropout)(logits)
    logits = Dense(units=classes, activation="softmax",
                   name="output_1")(logits)

    model = Model(inputs=[input_ids, token_type_ids], outputs=logits)
    model.build(input_shape=(None, timesteps))

    # load the pre-trained model weights
    load_stock_weights(bert_model, bert_ckpt_file)
    return model
Example #4
0
    def build_model(self):
        x = Input(shape=(self.input_shape, ))
        outputs = self.regime(x, self.num_stages, self.hidden_size,
                              self.num_class, self.graph_model,
                              self.graph_param)
        model = Model(inputs=[x], outputs=[outputs])
        model.build(input_shape=[self.input_shape])

        return model
Example #5
0
def build_model(n_features):
    print("--model--ly")
    ly = MyLayer(10,2)
    print("--model--Input")
    input_layer = Input(shape=[10, 10], dtype='float32', name="input_ids")
    print("--model--output")
    output = ly(input_layer)
    print("--model--new")
    model = Model(inputs=input_layer, outputs=output)
    print("--model--build")
    model.build(input_shape=(None, n_features))
    print("--model--compile")
    model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
    model.summary()
    return model
bert_layer = bert.BertModelLayer.from_params(bert_params, name="BERT")
bert_layer.apply_adapter_freeze()

print("Definisce la rete neurale transformer e ne stampa la struttura...")

# We arrange our layers by composing them as functions, with the input layer as inmost one
input_layer = Input(shape=(MAX_LENGTH, ), dtype='int32', name='input_ids')
output_layer = bert_layer(input_layer)

output_layer = GlobalAveragePooling1D()(output_layer)
output_layer = Dense(128, activation="relu")(output_layer)
output_layer = Dropout(0.1)(output_layer)
output_layer = Dense(1, activation="relu")(output_layer)

neural_network = Model(inputs=input_layer, outputs=output_layer)
neural_network.build(input_shape=(None, MAX_LENGTH))
neural_network.compile(loss="mse", optimizer=Adam(learning_rate=3e-5))

neural_network.summary()

try:
    print("Se ho salvato in precedenza la rete la carico da file...")
    neural_network.load_weights("pesi_rete")
except:
    print("No! La alleno e poi la salvo...")
    neural_network.fit(training_set,
                       training_scores,
                       batch_size=128,
                       shuffle=True,
                       epochs=4,
                       validation_data=(testing_set, testing_scores),
    def CreateModel(self):
        '''
		定义CNN/LSTM/CTC模型,使用函数式模型
		输入层:200维的特征值序列,一条语音数据的最大长度设为1600(大约16s)
		隐藏层:卷积池化层,卷积核大小为3x3,池化窗口大小为2
		隐藏层:全连接层
		输出层:全连接层,神经元数量为self.MS_OUTPUT_SIZE,使用softmax作为激活函数,
		CTC层:使用CTC的loss作为损失函数,实现连接性时序多输出
		
		'''

        input_data = Input(name='the_input',
                           shape=(self.AUDIO_LENGTH, self.AUDIO_FEATURE_LENGTH,
                                  1))

        layer_h1 = Conv2D(32, (3, 3),
                          use_bias=False,
                          activation='relu',
                          padding='same',
                          kernel_initializer='he_normal')(input_data)  # 卷积层
        layer_h1 = Dropout(0.05)(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.05)(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.1)(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.1)(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.15)(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.15)(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.2)(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)  # 池化层

        layer_h12 = Dropout(0.2)(layer_h12)
        layer_h13 = Conv2D(128, (3, 3),
                           use_bias=True,
                           activation='relu',
                           padding='same',
                           kernel_initializer='he_normal')(layer_h12)  # 卷积层
        layer_h13 = Dropout(0.3)(layer_h13)
        layer_h14 = Conv2D(128, (3, 3),
                           use_bias=True,
                           activation='relu',
                           padding='same',
                           kernel_initializer='he_normal')(layer_h13)  # 卷积层
        layer_h15 = MaxPooling2D(pool_size=1, strides=None,
                                 padding="valid")(layer_h14)  # 池化层

        #test=Model(inputs = input_data, outputs = layer_h12)
        #test.summary()

        layer_h16 = Reshape((200, 3200))(layer_h15)  #Reshape层
        #layer_h5 = LSTM(256, activation='relu', use_bias=True, return_sequences=True)(layer_h4) # LSTM层
        #layer_h6 = Dropout(0.2)(layer_h5) # 随机中断部分神经网络连接,防止过拟合
        layer_h16 = Dropout(0.3)(layer_h16)
        layer_h17 = Dense(128,
                          activation="relu",
                          use_bias=True,
                          kernel_initializer='he_normal')(layer_h16)  # 全连接层
        layer_h17 = Dropout(0.3)(layer_h17)
        layer_h18 = Dense(self.MS_OUTPUT_SIZE,
                          use_bias=True,
                          kernel_initializer='he_normal')(layer_h17)  # 全连接层

        y_pred = Activation('softmax', name='Activation0')(layer_h18)
        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')
        # tensorflow.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)
        opt = Adam(lr=0.001,
                   beta_1=0.9,
                   beta_2=0.999,
                   decay=0.0,
                   epsilon=10e-8)
        #model.compile(loss={'ctc': lambda y_true, y_pred: y_pred}, optimizer=sgd)

        model.build((self.AUDIO_LENGTH, self.AUDIO_FEATURE_LENGTH, 1))
        model = ParallelModel(model, NUM_GPU)

        model.compile(loss={
            'ctc': lambda y_true, y_pred: y_pred
        },
                      optimizer=opt)

        # captures output of softmax so we can decode the output during visualization
        test_func = K.function([input_data], [y_pred])

        #print('[*提示] 创建模型成功,模型编译成功')
        print('[*Info] Create Model Successful, Compiles Model Successful. ')
        return model, model_data
Example #8
0
        return model


# -

dim_hidden_layres = [2**i for i in range(4, 8)]

# +
df_accuracy = pd.DataFrame()

for hid_dim_0 in dim_hidden_layres:
    for hid_dim_1 in dim_hidden_layres:
        print('========', 'hid_dim_0:', hid_dim_0, '; hid_dim_1:', hid_dim_1,
              '========')
        model = CNNModel(hid_dim_0=hid_dim_0, hid_dim_1=hid_dim_1)
        model = model.build()
        model.compile(optimizer='adam',
                      loss='sparse_categorical_crossentropy',
                      metrics=['acc'])
        callbacks = [
            EarlyStopping(patience=3),
            ModelCheckpoint(filepath=os.path.join(
                'models', 'CNN', 'model_{}_{}.h5'.format(hid_dim_0,
                                                         hid_dim_1)),
                            save_best_only=True),
        ]
        n_param = model.count_params()
        model.fit(x=x_train,
                  y=y_train,
                  batch_size=128,
                  epochs=100,
Example #9
0
          kernel_regularizer=l2(0.01),
          bias_regularizer=l2(0.01))(x)  # dense layer 3
x = Dropout(0.5)(x)
preds = Dense(num_classes,
              activation='softmax')(x)  # final layer with softmax activation
model = Model(inputs=base_model.input, outputs=preds)
for layer in model.layers[:20]:
    layer.trainable = False
for layer in model.layers[20:]:
    layer.trainable = True
model.load_weights(
    '/home/ivo/Projects/auto_image_rotator/auto_image_flip/app/static/saved_model/image_rotate_weights.h5'
)
optimizer = tf.optimizers.Adam(1e-5)

model.build([None, 224, 224, 3])

model.summary()
model.compile(optimizer=optimizer,
              loss='categorical_crossentropy',
              metrics=['accuracy'])
model.summary()

# Convert model to TFLite

TFLITE_MODEL = "models/export/image_flip.tflite"
TFLITE_QUANT_MODEL = "models/export/image_flip_quant.tflite"

# Get the concrete function from the Keras model.
run_model = tf.function(lambda x: model(x))
Example #10
0
def build_bilstm(start_pointer,
                 end_pointer,
                 emb_dim,
                 max_passage_length=None,
                 max_query_length=None,
                 num_highway_layer=2,
                 num_decoder=1,
                 encoder_dropout=0,
                 decoder_dropout=0):

    passage_input = Input(shape=(max_passage_length, emb_dim),
                          dtype='float32',
                          name='passage_input')
    query_input = Input(shape=(max_query_length, emb_dim),
                        dtype='float32',
                        name='query_input')

    passage_embedding = passage_input
    query_embedding = query_input

    for i in range(num_highway_layer):
        highway_layer = Highway(name='highway_{}'.format(i))
        query_layer = TimeDistributed(highway_layer,
                                      name=highway_layer.name + '_qtd')
        query_embedding = query_layer(query_embedding)
        passage_layer = TimeDistributed(highway_layer,
                                        name=highway_layer.name + '_ptd')
        passage_embedding = passage_layer(passage_embedding)

    encoder_layer_p = Bidirectional(LSTM(emb_dim,
                                         recurrent_dropout=encoder_dropout,
                                         return_sequences=True),
                                    name='bidirectional_encoder_p')
    encoder_layer_q = Bidirectional(LSTM(emb_dim,
                                         recurrent_dropout=encoder_dropout,
                                         return_sequences=True),
                                    name='bidirectional_encoder_q')

    passage_encoded = encoder_layer_p(passage_embedding)
    query_encoded = encoder_layer_q(query_embedding)

    passage_outs = []
    query_outs = []
    num_lstm_layers = 3

    for i in range(num_lstm_layers):

        deca_encoder_p = Bidirectional(LSTM(emb_dim, return_sequences=True),
                                       name='deca_encoder_p_{}'.format(i))
        deca_encoder_q = Bidirectional(LSTM(emb_dim, return_sequences=True),
                                       name='deca_encoder_q_{}'.format(i))

        passage_deca = deca_encoder_p(passage_encoded)
        query_deca = deca_encoder_q(query_encoded)

        passage_outs.append(passage_deca)
        query_outs.append(query_deca)

    passage_c = tf.concat(passage_outs, 2)
    query_c = tf.concat(query_outs, 2)

    passage_connecters = []
    query_connecters = []

    for i in range(num_lstm_layers):
        for j in range(num_lstm_layers):
            bac_layer = BAC(name='bac_layer_p_{}_q_{}'.format(i, j))
            connecter_p, connecter_q = bac_layer(
                tf.concat([passage_outs[i], query_outs[j]], 1))

            passage_connecters.append(connecter_p)
            query_connecters.append(connecter_q)

    connecter_pc = tf.concat(passage_connecters, 2)
    connecter_qc = tf.concat(query_connecters, 2)

    passage_decaout = tf.concat([passage_c, connecter_pc], 2)
    query_decaout = tf.concat([query_c, connecter_qc], 2)

    print(passage_decaout.shape, query_decaout.shape)

    gated_attention_layer = Gated_attention_with_self()
    gated_atten_op, gated_self_atten_op = gated_attention_layer(
        tf.concat([passage_decaout, query_decaout], 1))

    atten_outs = [gated_atten_op, gated_self_atten_op]

    conn_list = []

    print(atten_outs[0].shape, query_outs[0].shape)

    for i in range(2):
        for j in range(num_lstm_layers):
            one_sided_bac = BAC(name='one_sided_bac_u{}_q{}'.format(i, j))
            connecter_1, connecter_2 = one_sided_bac(
                tf.concat([atten_outs[i], query_outs[j]], 1))

            conn_list.append(connecter_1)
            # conn_list.append(connecter_2)     #TODO: Check Upper BAC in code.

    for k in range(len(conn_list)):
        print(conn_list[k].shape)
    conn_c = tf.concat(conn_list, 2)

    m_mat = tf.concat([gated_self_atten_op, conn_c], 2)

    start_projection = Bidirectional(
        LSTM(emb_dim, name='bilstm_span_start', return_sequences=True))
    end_projection = Bidirectional(
        LSTM(emb_dim, name='bilstm_span_end', return_sequences=True))

    softamx_start = Dense(1,
                          activation=softmax,
                          use_bias=False,
                          name='start_softmax')
    softamx_end = Dense(1,
                        activation=softmax,
                        use_bias=False,
                        name='end_softmax')

    span_start = start_projection(m_mat)
    span_end = end_projection(span_start)

    start_pred = softamx_start(span_start)
    end_pred = softamx_end(span_end)

    # start_pointer = tf.zeros((32, 200, 1))
    # end_pointer = tf.zeros((32, 200, 1))

    # loss_start = tf.math.log(tf.reduce_sum(tf.multiply(start_pred, start_pointer)))
    # loss_end = tf.math.log(tf.reduce_sum(tf.multiply(end_pred, end_pointer)))

    loss_start = tf.math.log(
        tf.reduce_sum(tf.multiply(start_pred, start_pred), axis=1))
    loss_end = tf.math.log(
        tf.reduce_sum(tf.multiply(end_pred, end_pred), axis=1))

    cost = tf.reduce_mean(tf.math.add(loss_start, loss_end), axis=0)

    print(loss_start.shape, loss_end.shape, cost.shape)

    model = Model(inputs=[passage_input, query_input],
                  outputs=[start_pred, end_pred])
    model.build(input_shape=(max_passage_length, emb_dim))
    model.summary()