Beispiel #1
0
def main():
    X, y, words, tags = load_dataset(DATA_PATH)
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.15)

    inp = Input(shape=(MAX_LEN, ))
    model = Embedding(input_dim=len(words) + 2,
                      output_dim=EMBEDDING_SIZE,
                      input_length=MAX_LEN,
                      mask_zero=True)(inp)
    model = Bidirectional(
        LSTM(units=50, return_sequences=True, recurrent_dropout=0.1))(model)
    model = TimeDistributed(Dense(50, activation="relu"))(model)
    crf = CRF(len(tags) + 1)  # CRF layer
    out = crf(model)  # output

    model = Model(inp, out)
    model.compile(optimizer="rmsprop", loss=crf.loss, metrics=[crf.accuracy])

    model.summary()

    checkpointer = ModelCheckpoint(filepath='model.h5',
                                   verbose=0,
                                   mode='auto',
                                   save_best_only=True,
                                   monitor='val_loss')

    history = model.fit(X_train,
                        np.array(y_train),
                        batch_size=BATCH_SIZE,
                        epochs=EPOCHS,
                        validation_split=0.1,
                        callbacks=[checkpointer])
                                                    test_size=0.2,
                                                    random_state=1)

from tensorflow.keras import Model, Input
from tensorflow.keras.layers import LSTM, Embedding, Dense
from tensorflow.keras.layers import TimeDistributed, SpatialDropout1D, Bidirectional

input_word = Input(shape=(max_len, ))
model = Embedding(input_dim=num_words, output_dim=50,
                  input_length=max_len)(input_word)
model = SpatialDropout1D(0.1)(model)
model = Bidirectional(
    LSTM(units=100, return_sequences=True, recurrent_dropout=0.1))(model)
out = TimeDistributed(Dense(num_tags, activation="softmax"))(model)
model = Model(input_word, out)
model.summary()

model.compile(optimizer="adam",
              loss="sparse_categorical_crossentropy",
              metrics=["accuracy"])

from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping
from livelossplot.tf_keras import PlotLossesCallback

# chkpt = ModelCheckpoint("model_weights.h5", monitor='val_loss',verbose=1, save_best_only=True, save_weights_only=True, mode='min')
#
# early_stopping = EarlyStopping(monitor='val_accuracy', min_delta=0, patience=1, verbose=0, mode='max', baseline=None, restore_best_weights=False)
#
# callbacks = [PlotLossesCallback(), chkpt, early_stopping]
#
# history = model.fit(
Beispiel #3
0
def model_akty(seq_len_middle, tag_index, embedding_dim, word_index,
               word_index_morf, embedding_matrix_1, embedding_matrix_2):
    ## main model
    input = Input(shape=(seq_len_middle, ))
    model = Embedding(
        len(word_index) + 1,
        embedding_dim,
        embeddings_initializer=initializers.Constant(embedding_matrix_1),
        input_length=seq_len_middle,
        trainable=False)(input)
    # model = Bidirectional (LSTM (units=85, return_sequences=True, dropout=drop), merge_mode="mul") (model)
    # model = TimeDistributed (Dense (100, activation="relu")) (model)

    model = Bidirectional(
        LSTM(128, return_sequences=True, dropout=0.2,
             recurrent_dropout=0.2))(model)
    model = LSTM(128,
                 return_sequences=True,
                 dropout=0.2,
                 recurrent_dropout=0.2)(model)
    model = GRU(64,
                dropout=0.1,
                recurrent_dropout=0.5,
                activation='tanh',
                recurrent_activation='sigmoid')(model)

    model = Flatten()(model)

    input3 = Input(shape=(seq_len_middle, ))
    model3 = Embedding(
        len(word_index_morf) + 1,
        embedding_dim,
        embeddings_initializer=initializers.Constant(embedding_matrix_2),
        input_length=seq_len_middle,
        trainable=True)(input3)
    model3 = Bidirectional(
        LSTM(128, return_sequences=True, dropout=0.2,
             recurrent_dropout=0.2))(model3)
    model3 = LSTM(128,
                  return_sequences=True,
                  dropout=0.2,
                  recurrent_dropout=0.2)(model3)
    model3 = GRU(64,
                 dropout=0.1,
                 recurrent_dropout=0.5,
                 activation='tanh',
                 recurrent_activation='sigmoid')(model3)

    model3 = Flatten()(model3)

    merged = tf.keras.layers.concatenate([model, model3])
    model = Dense(64, activation='relu')(merged)
    # model = Dropout(0.20) (model)
    # model = Dense (10, activation='relu') (model)
    # out = (Dense (2, activation='softmax')) (model)
    out = (Dense(len(tag_index) + 1, activation='softmax'))(model)

    # model = Model (input, out)
    model = Model(inputs=[input, input3], outputs=out)
    # model.compile (loss='sparse_categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
    # model.compile (loss='binary_crossentropy', optimizer='Adadelta', metrics=['accuracy'])
    model.compile(loss='mse', optimizer=rmsprop, metrics=['accuracy'])
    model.summary()
    return model