def vdcnn_model(X_train, y_train, X_test, y_test, sequence_max_length):

    model = VDCNN(num_classes=y_train.shape[1],
                  sequence_length=sequence_max_length)

    if y_train.shape[1] == 1:
        model.compile(loss='binary_crossentropy',
                      optimizer=SGD(lr=0.0001, momentum=0.9),
                      metrics=['accuracy'])
    else:
        model.compile(loss='categorical_crossentropy',
                      optimizer=SGD(lr=0.0001, momentum=0.9),
                      metrics=['accuracy'])

    model.fit(X_train,
              y_train,
              validation_data=(X_test, y_test),
              epochs=50,
              batch_size=128)

    scores = model.evaluate(X_test, y_test)
    accuracy = scores[1] * 100
    y_pred = model.predict(X_test)

    return accuracy, y_pred
Esempio n. 2
0
File: train.py Progetto: evu/VDCNN
def train(x_train, y_train, x_test, y_test):

    session_ts = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
    log_dir = str(pathlib.Path(FLAGS.train_log_dir) / session_ts)

    if FLAGS.dataset_type == "embeddings":
        embedding_input = True
        embedding_dim = x_train.shape[-1]
    else:
        embedding_input = False
        embedding_dim = 16

    # Build model
    model = VDCNN(
        num_classes=y_train.shape[1],
        depth=FLAGS.depth,
        sequence_length=FLAGS.sequence_length,
        shortcut=FLAGS.shortcut,
        pool_type=FLAGS.pool_type,
        sort=FLAGS.sort,
        use_bias=FLAGS.use_bias,
        embedding_input=embedding_input,
        embedding_dim=embedding_dim,
    )

    model.compile(
        optimizer=tf.keras.optimizers.SGD(lr=FLAGS.lr, momentum=0.9),
        loss="categorical_crossentropy",
        metrics=["acc"],
    )

    # Save model architecture
    model_json = model.to_json()
    with open("vdcnn_model.json", "w") as json_file:
        json_file.write(model_json)
    time_str = datetime.datetime.now().isoformat()
    print("{}: Model saved as json.".format(time_str))
    print("")

    # Trainer
    # Tensorboard and extra callback to support steps history
    tensorboard = tf.keras.callbacks.TensorBoard(log_dir=log_dir,
                                                 histogram_freq=50,
                                                 write_graph=True,
                                                 write_images=True)
    checkpointer = tf.keras.callbacks.ModelCheckpoint(
        filepath="./checkpoints/vdcnn_weights_val_acc_{val_acc:.4f}.h5",
        save_freq="epoch",
        verbose=1,
        save_best_only=True,
        mode="max",
        monitor="val_acc",
    )
    loss_history = custom_callbacks.LossHistory(model,
                                                tensorboard,
                                                logdir=log_dir)
    evaluate_step = custom_callbacks.EvaluateStep(
        model,
        checkpointer,
        tensorboard,
        FLAGS.evaluate_every,
        FLAGS.batch_size,
        x_test,
        y_test,
        log_dir,
    )

    # Fit model
    model.fit(
        x_train,
        y_train,
        batch_size=FLAGS.batch_size,
        epochs=FLAGS.num_epochs,
        validation_data=(x_test, y_test),
        verbose=1,
        callbacks=[
            checkpointer,
            tensorboard,
            # loss_history,
            evaluate_step,
        ],
    )
    print("-" * 30)
    time_str = datetime.datetime.now().isoformat()
    print("{}: Done training.".format(time_str))

    tf.keras.backend.clear_session()
    print("-" * 30)
    print()