def test_rossler_dataset_creator():
    x_0 = [2, 2, 2]
    data = rossler_dataset_maker(x_0=x_0,
                                 start_time=0.0,
                                 end_time=30.0,
                                 time_step=0.1)
    first_five_x = np.array([2., 1.607831, 1.23093264, 0.8672437, 0.51370104])
    first_five_y = np.array(
        [2., 2.26131837, 2.49356973, 2.69709381, 2.8719731])
    first_five_z = np.array(
        [2., 1.58200549, 1.20471963, 0.88366574, 0.62337719])
    np.testing.assert_allclose(first_five_x, data[0][0:5, [0]].reshape(5))
    np.testing.assert_allclose(first_five_y, data[0][0:5, [1]].reshape(5))
    np.testing.assert_allclose(first_five_z, data[0][0:5, [2]].reshape(5))
Ejemplo n.º 2
0
def load_model_and_viz():
    loaded_model = keras.models.load_model(
        f'/home/hossein/Desktop/Repos/extreme_events/saved_models/{MODEL_NAME}'
    )
    with open(MODEL_PATH / "meta_data", "rb") as meta_data_file:
        metadata = pickle.load(meta_data_file)

    test_time = 10.0
    data = rossler_dataset_maker(
        x_0=metadata.init_val,
        start_time=metadata.start_time,
        end_time=metadata.end_time +
        test_time,  # extra 10 time unites for test
        time_step=metadata.time_step)

    train_time_steps = int(
        (metadata.end_time - metadata.start_time) / metadata.time_step)
    test_time_steps = int(test_time / metadata.time_step)
    tot_time_steps = train_time_steps + test_time_steps

    all_x = data[:, :, :-1].reshape(1, tot_time_steps, 2)
    all_y = data[:, :, -1].reshape(1, tot_time_steps)
    all_y_if_flipped = if_flips_in_next_n_steps(all_y,
                                                threshold=5.0,
                                                n_time_steps=20)

    plt.plot(data[0][0:tot_time_steps, 2:3].T.tolist()[0])

    plt.plot([None] * train_time_steps +
             all_y_if_flipped[0][train_time_steps:tot_time_steps].tolist())

    results2 = []
    for i in range(test_time_steps):
        val = loaded_model.predict(all_x[:, i:train_time_steps + i, :])
        if val[0][0] > 0:
            results2.append(1)
        else:
            results2.append(0)

        if i % 10 == 0:
            print(f"done {i} iteration")

    plt.plot([None] * train_time_steps + results2, "r")
    plt.show()
Ejemplo n.º 3
0
from extreme_events.data_source.data_providers import rossler_dataset_maker, if_flips_in_next_n_steps
from extreme_events.utils.model_utils import set_seeds_and_clear_session, MetaData
from extreme_events.models.simple_rnn import SimpleTwoLayerRNN

if __name__ == "__main__":
    set_seeds_and_clear_session()
    x_0 = [2, 2, 2]
    start_time = 0.0
    end_time = 30.0
    time_step = 0.01
    loss_type = 'binary_crossentropy'
    model_meta_data = MetaData(init_val=x_0, start_time=start_time, end_time=end_time, time_step=time_step, loss_type=loss_type)

    data = rossler_dataset_maker(x_0=model_meta_data.init_val,
                                 start_time=model_meta_data.start_time,
                                 end_time=model_meta_data.end_time,
                                 time_step=model_meta_data.time_step)
    x_train = data[0][:, :-1].reshape(1, data.shape[1], 2)  # both x and y
    y_train = data[0][:, -1:].reshape(1, data.shape[1])  # assuming the last column is target
    y_train = if_flips_in_next_n_steps(y_train, threshold=5.0, n_time_steps=20)
    optimizer = keras.optimizers.Adam(lr=0.005)
    # loss = keras.losses.Huber()
    loss = keras.losses.BinaryCrossentropy(
        from_logits=False, label_smoothing=0, reduction=keras.losses.Reduction.SUM,
    )

    # loss = SigmoidFocalCrossEntropy()
    metrics = ["mse"]
    model = SimpleTwoLayerRNN(loss_function=loss, optimizer=optimizer, metrics=metrics,
                              input_shape=(x_train.shape[1], x_train.shape[2]))
    history = model.fit(X=x_train, y=y_train)
Ejemplo n.º 4
0
from tensorflow import keras
import numpy as np

from extreme_events.data_source.data_providers import rossler_dataset_maker
from extreme_events.utils.model_utils import set_seeds_and_clear_session
from extreme_events.models.lstm import LSTM2Layer

if __name__ == "__main__":
    set_seeds_and_clear_session()
    x_0 = [2, 2, 2]
    start_time = 0.0
    end_time = 30.0
    time_step = 0.01
    data = rossler_dataset_maker(x_0=x_0,
                                 start_time=start_time,
                                 end_time=end_time,
                                 time_step=time_step)

    optimizer = keras.optimizers.Adam(lr=0.005)

    # def last_time_step_mse(Y_true, Y_pred):
    #     return keras.metrics.mean_squared_error(Y_true[:, -1], Y_pred[:, -1])

    x_train = data[0][:, :-1].reshape(1, data.shape[1], 2)  # both x and y
    y_train = data[0][:, -1:].reshape(
        1, data.shape[1])  # assuming the last column is target
    loss = keras.losses.Huber()
    metrics = ["mse"]
    model = LSTM2Layer(loss_function=loss,
                       optimizer=optimizer,
                       metrics=metrics,
Ejemplo n.º 5
0
from tensorflow import keras

from extreme_events.data_source.data_providers import rossler_dataset_maker
from extreme_events.utils.model_utils import set_seeds_and_clear_session
from extreme_events.models.gru import GRU

if __name__ == "__main__":
    set_seeds_and_clear_session()
    x_0 = [2, 2, 2]
    start_time = 0.0
    end_time = 30.0
    time_step = 0.01
    data = rossler_dataset_maker(x_0=x_0,
                                 start_time=start_time,
                                 end_time=end_time,
                                 time_step=time_step,
                                 target_advance_time=10.0,
                                 target_threshold_val=10.0)
    x_train = data[0][:, :-1].reshape(1, data.shape[1], 2)  # both x and y
    y_train = data[0][:, -1:].reshape(
        1, data.shape[1])  # assuming the last column is target
    optimizer = keras.optimizers.Adam(lr=0.005)
    loss = "mse"
    metrics = ["mse"]
    model = GRU(loss_function=loss,
                optimizer=optimizer,
                metrics=metrics,
                input_shape=(x_train.shape[1], x_train.shape[2]))
    model.fit(X=x_train, y=y_train)