Pre-processing temporal data made easier with TensorFlow Decision Forests and Temporian — The TensorFlow Blog

TensorFlow-Training-model-on-temporal-data-with-TensorFlow-and-Temporian-header-social-v2.png

BONUS: To make the plots interactive, you can add the interactive=True argument to the plot function.

Sales per products

In the previous step, we computed the overall moving sum of sales for the entire shop. However, what if we wanted to calculate the rolling sum of sales for each product or client separately?

For this task, we can use an index.



sales_per_product = sales.add_index("product")
weekly_sales_per_product = sales_per_product["price"].moving_sum(

        tp.duration.days(7)

)
weekly_sales_per_product.plot()

NOTE: Many operators such as moving_sum applied independently on each index.

Aggregate transactions into time series

Our dataset contains individual client transactions. To use this data with a machine learning model, it is often useful to aggregate it into time series, where the data is sampled uniformly over time. For example, we could aggregate the sales weekly, or calculate the total sales in the last week for each day.

However, it is important to note that aggregating transaction data into time series can result in some data loss. For example, the individual transaction timestamps and values would be lost. This is because the aggregated time series would only represent the total sales for each time period.

Let’s compute the total sales in the last week for each day for each product individually.



daily_sampling = sales_per_product.tick(tp.duration.days(1))
weekly_sales_daily = sales_per_product["price"].moving_sum(

    tp.duration.days(7),

    sampling=daily_sampling,

)

weekly_sales_daily.plot()

NOTE: The current plot is a continuous line, while the previous plots have markers. This is because Temporian uses continuous lines by default when the data is uniformly sampled, and markers otherwise.

After the data preparation stage is finished, the data can be exported to a Pandas DataFrame as a final step.

tp.to_pandas(weekly_sales_daily)

Train a forecasting model with TensorFlow model

A key application of Temporian is to clean data and perform feature engineering for machine learning models. It is well suited for forecasting, anomaly detection, fraud detection, and other tasks where data comes continuously.

In this example, we show how to train a TensorFlow model to predict the next day’s sales using past sales for each product individually. We will feed the model various levels of aggregations of sales as well as calendar information.

Let’s first augment our dataset and convert it to a dataset compatible with a tabular ML model.

sales_per_product = sales.add_index("product")
daily_sampling = sales_per_product.tick(tp.duration.days(1))




features = []

for w in [3, 7, 14, 28]:

    features.append(sales_per_product["price"]

        .moving_sum(

            tp.duration.days(w),

            sampling=daily_sampling)

        .rename(f"moving_sum_{w}"))
features.append(daily_sampling.calendar_day_of_week())
label = (sales_per_product["price"]

    .leak(tp.duration.days(1))

    .moving_sum(

        tp.duration.days(1),

        sampling=daily_sampling,

        )

    .rename("label"))


dataset = tp.glue(*features, label)

dataset

We can then convert the dataset from EventSet to TensorFlow Dataset format, and train a Random Forest.

import tensorflow_decision_forests as tfdf
def extract_label(example):

    example.pop("timestamp")

    label = example.pop("label")

    return example, label
tf_dataset = tp.to_tensorflow_dataset(dataset).map(extract_label).batch(100)

model = tfdf.keras.RandomForestModel(task=tfdf.keras.Task.REGRESSION,verbose=2) model.fit(tf_dataset)

And that’s it, we have a model trained to forecast sales. We now can look at the variable importance of the model to understand what features matter the most.

In the summary, we can find the INV_MEAN_MIN_DEPTH variable importance:

Type: "RANDOM_FOREST"

Task: REGRESSION

...

Variable Importance: INV_MEAN_MIN_DEPTH:

    1.        "moving_sum_28"  0.342231

    2.              "product"  0.294546

    3. "calendar_day_of_week"  0.254641

    4.        "moving_sum_14"  0.197038

    5.         "moving_sum_7"  0.124693

    6.         "moving_sum_3"  0.098542

We see that moving_sum_28 is the feature with the highest importance (0.342231). This indicates that the sum of sales in the last 28 days is very important to the model. To further improve our model, we should probably add more temporal aggregation features. The product feature also matters a lot.

And to get an idea of the model itself, we can plot one of the trees of the Random Forest.

tfdf.model_plotter.plot_model_in_colab(model, tree_idx=0, max_depth=2)

More on temporal data preprocessing

We demonstrated some simple data preprocessing. If you want to see other examples of temporal data preprocessing on different data domains, check the Temporian tutorials. Notably:

Heart rate analysis ❤️ detects individual heartbeats and derives heart rate related features on raw ECG signals from Physionet.

M5 Competition 🛒 predicts retail sales in the M5 Makridakis Forecasting competition.

Loan outcomes prediction 🏦 prepares relational SQL data to predict outcomes for finished loans.

Detecting payment card fraud 💳 detects fraudulent payment card transactions in real time.

Supervised and unsupervised anomaly detection 🔎 perform data analysis and feature engineering to detect anomalies in a group of server’s resource usage metrics.

Next Steps

We demonstrated how to handle temporal data such as transactions in TensorFlow using the Temporian library. Now you can try it too!

To learn more about model training with TensorFlow Decision Forests:

Source link