Dummy dataset

• Find this notebook at EpyNN/epynnlive/dummy_time/prepare_dataset.ipynb.

• Regular python code at EpyNN/epynnlive/dummy_time/prepare_dataset.py.

Run the notebook online with Google Colab.

This notebook is part of the series on preparing data for Neural Network regression with EpyNN.

In addition to the topic-specific content, it contains several explanations about basics or general concepts in programming that are important in the context.

Note that elements developed in the following notebooks may not be reviewed herein:

• Boolean dataset

• String dataset

What is a time series?

A time series is not a data type. It represents sequential data with respect to the dimension of time. Herein, we will work with sequential data containing numerical elements of the float data type.

Why preparing a dummy dataset with time features?

The general interest of dummy dataset is explained in dummy dataset with Boolean sample features.

Prepare a set of time sample features and related label

Imports

# EpyNN/epynnlive/dummy_time/prepare_dataset.ipynb
# Standard library imports
import random

# Related third party imports
import matplotlib.pyplot as plt
import numpy as np

Seeding

random.seed(1)

Generate features

We need to define a function which will generate pseudo-random time features.

def features_time(TIME=1, SAMPLING_RATE=128):
    """Generate dummy time features.

    Time features may be white noise or a sum with a pure sine-wave.

    The pure sin-wave has random frequency lower than SAMPLING_RATE // 4.

    :param SAMPLING_RATE: Sampling rate (Hz), defaults to 128.
    :type SAMPLING_RATE: int

    :param TIME: Sampling time (s), defaults to 1.
    :type TIME: int

    :return: Time features of shape (N_FEATURES,).
    :rtype: :class:`numpy.ndarray`

    :return: White noise of shape (N_FEATURES,).
    :rtype: :class:`numpy.ndarray`
    """
    # Number of features describing a sample
    N_FEATURES = TIME * SAMPLING_RATE

    # Initialize features array
    features = np.linspace(0, TIME, N_FEATURES, endpoint=False)

    # Random choice of true signal frequency
    signal_frequency = random.uniform(0, SAMPLING_RATE // 4)

    # Generate pure sine wave of N_FEATURES points
    features = np.sin(2 * np.pi * signal_frequency * features)

    # Generate white noise
    white_noise = np.random.normal(0, scale=0.5, size=N_FEATURES)

    # Random choice between noisy signal or white noise
    features = random.choice([features + white_noise, white_noise])

    return features, white_noise

The code is commented and quite self-explaining, let’s proceed with a call.

features, white_noise = features_time()

plt.plot(features, label="features")
plt.plot(white_noise, label="white_noise")
plt.plot(features - white_noise, label="features - white_noise")
plt.legend()
plt.show()

Here we have noisy features from the random choice because when subtracting white_noise from features we recover a pure sine-wave of random frequency, as stated in the comment of the features_time() function.

features, white_noise = features_time()

plt.plot(features, label="features")
plt.plot(white_noise, label="white_noise")
plt.plot(features - white_noise, label="features - white_noise")
plt.legend()
plt.show()

By contrast, here we retrieved features which only contain white_noise, since the subtract operation returns a flat line.

Therefore, sample features may consist of noise containing a true signal, or just pure noise.

Generate label

As already mentioned, in this dummy example we have the a priori knowledge of the law we want to model.

def label_features(features, white_noise):
    """Prepare label associated with features.

    The dummy law is:

    True signal in features = positive.
    No true signal in features = negative.

    :return: Time features of shape (N_FEATURES,).
    :rtype: :class:`numpy.ndarray`

    :return: White noise of shape (N_FEATURES,).
    :rtype: :class:`numpy.ndarray`

    :return: Single-digit label with respect to features.
    :rtype: int
    """
    # Single-digit positive and negative labels
    p_label = 0
    n_label = 1

    # Test if features contains signal (0)
    if any(features != white_noise):
        label = p_label

    # Test if features is equal to white noise (1)
    elif all(features == white_noise):
        label = n_label

    return label

The code above is commented and self explaining.

Let’s check the function we made for a few iterations.

for i in range(5):
    features, white_noise = features_time()
    label = label_features(features, white_noise)

    print(label, np.sum(features), np.sum(white_noise))

1 -6.533357433395695 -6.533357433395695
0 5.060565673758379 4.295314530677464
0 -7.430319493962538 -7.420946917171596
1 8.245856832163877 8.245856832163877
0 -0.048133388166399005 -1.0486463249958615

Prepare dataset

Let’s go on and write the function which will iterate to generate a set of sample time features and label.

def prepare_dataset(N_SAMPLES=100):
    """Prepare a set of dummy time sample features and label.

    :param N_SAMPLES: Number of samples to generate, defaults to 100.
    :type N_SAMPLES: int

    :return: Set of sample features.
    :rtype: tuple[:class:`numpy.ndarray`]

    :return: Set of single-digit sample label.
    :rtype: tuple[int]
    """
    # Initialize X and Y datasets
    X_features = []
    Y_label = []

   # Iterate over N_SAMPLES
    for i in range(N_SAMPLES):

        # Compute random time features
        features, white_noise = features_time()

        # Retrieve label associated with features
        label = label_features(features, white_noise)

        # From n measurements to n steps with 1 measurements
        features = np.expand_dims(features, 1)

        # Append sample features to X_features
        X_features.append(features)

        # Append sample label to Y_label
        Y_label.append(label)

    # Prepare X-Y pairwise dataset
    dataset = list(zip(X_features, Y_label))

    # Shuffle dataset
    random.shuffle(dataset)

    # Separate X-Y pairs
    X_features, Y_label = zip(*dataset)

    return X_features, Y_label

This simply wraps the example-specific elements which are the functions features_time() and label_features().

Live examples

The function prepare_dataset() presented herein is used in the following live examples:

• Notebook atEpyNN/epynnlive/dummy_time/train.ipynb or following this link.

• Regular python code at EpyNN/epynnlive/dummy_time/train.py.