[1]:
# Copyright 2021 NVIDIA Corporation. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
NVTabular demo on Rossmann data - FastAI
Overview
NVTabular is a feature engineering and preprocessing library for tabular data designed to quickly and easily manipulate terabyte scale datasets used to train deep learning based recommender systems. It provides a high level abstraction to simplify code and accelerates computation on the GPU using the RAPIDS cuDF library.
Learning objectives
In the previous notebooks (01-Download-Convert.ipynb and 02-ETL-with-NVTabular.ipynb), we downloaded, preprocessed and created features for the dataset. Now, we are ready to train our deep learning model on the dataset. In this notebook, we use FastAI with the NVTabular data loader for PyTorch to accelereate the training pipeline. FastAI uses PyTorch as a backend and we can combine the NVTabular data loader for PyTorch with the FastAI library.
[2]:
import os
import math
import json
import nvtabular as nvt
import glob
Loading NVTabular workflow
This time, we only need to define our data directories. We can load the data schema from the NVTabular workflow.
[3]:
DATA_DIR = os.environ.get("OUTPUT_DATA_DIR", os.path.expanduser("~/nvt-examples/data/"))
PREPROCESS_DIR = os.path.join(DATA_DIR, "ross_pre/")
PREPROCESS_DIR_TRAIN = os.path.join(PREPROCESS_DIR, "train")
PREPROCESS_DIR_VALID = os.path.join(PREPROCESS_DIR, "valid")
What files are available to train on in our directories?
[4]:
!ls $PREPROCESS_DIR
stats.json train valid
[5]:
!ls $PREPROCESS_DIR_TRAIN
0.1136d38916184bd39bf3d0cc6af8aecc.parquet _metadata
_file_list.txt _metadata.json
[6]:
!ls $PREPROCESS_DIR_VALID
0.bcd2404e802640f29b1427feaacbd24a.parquet _metadata
_file_list.txt _metadata.json
We load the data schema and statistic information from stats.json. We created the file in the previous notebook 02-ETL-with-NVTabular.
[7]:
stats = json.load(open(os.path.join(PREPROCESS_DIR, "stats.json"), "r"))
[8]:
CATEGORICAL_COLUMNS = stats["CATEGORICAL_COLUMNS"]
CONTINUOUS_COLUMNS = stats["CONTINUOUS_COLUMNS"]
LABEL_COLUMNS = stats["LABEL_COLUMNS"]
COLUMNS = CATEGORICAL_COLUMNS + CONTINUOUS_COLUMNS + LABEL_COLUMNS
The embedding table shows the cardinality of each categorical variable along with its associated embedding size. Each entry is of the form (cardinality, embedding_size).
[9]:
EMBEDDING_TABLE_SHAPES = stats["EMBEDDING_TABLE_SHAPES"]
EMBEDDING_TABLE_SHAPES
[9]:
{'Assortment': [4, 16],
'CompetitionMonthsOpen': [26, 16],
'CompetitionOpenSinceYear': [24, 16],
'Day': [32, 16],
'DayOfWeek': [8, 16],
'Events': [22, 16],
'Month': [13, 16],
'Promo2SinceYear': [9, 16],
'Promo2Weeks': [27, 16],
'PromoInterval': [4, 16],
'Promo_bw': [7, 16],
'Promo_fw': [7, 16],
'SchoolHoliday_bw': [9, 16],
'SchoolHoliday_fw': [9, 16],
'State': [13, 16],
'StateHoliday': [3, 16],
'StateHoliday_bw': [4, 16],
'StateHoliday_fw': [4, 16],
'Store': [1116, 81],
'StoreType': [5, 16],
'Week': [53, 16],
'Year': [4, 16]}
Training a Network
Now that our data is preprocessed and saved out, we can leverage datasets to read through the preprocessed parquet files in an online fashion to train neural networks.
We’ll start by setting some universal hyperparameters for our model and optimizer. These settings will be shared across all of the frameworks that we explore below.
[10]:
EMBEDDING_DROPOUT_RATE = 0.04
DROPOUT_RATES = [0.001, 0.01]
HIDDEN_DIMS = [1000, 500]
BATCH_SIZE = 65536
LEARNING_RATE = 0.001
EPOCHS = 25
# TODO: Calculate on the fly rather than recalling from previous analysis.
MAX_SALES_IN_TRAINING_SET = 38722.0
MAX_LOG_SALES_PREDICTION = 1.2 * math.log(MAX_SALES_IN_TRAINING_SET + 1.0)
TRAIN_PATHS = sorted(glob.glob(os.path.join(PREPROCESS_DIR_TRAIN, "*.parquet")))
VALID_PATHS = sorted(glob.glob(os.path.join(PREPROCESS_DIR_VALID, "*.parquet")))
fast.ai
fast.ai: Preparing Datasets
AsyncTensorBatchDatasetItr maps a symbolic dataset object to cat_features, cont_features, labels PyTorch tenosrs by iterating through the dataset and concatenating the results.
[11]:
import fastai
fastai.__version__
[11]:
'2.2.5'
[12]:
import torch
from nvtabular.loader.torch import TorchAsyncItr, DLDataLoader
from nvtabular.framework_utils.torch.utils import FastaiTransform
from fastai.tabular.data import TabularDataLoaders
from fastai.tabular.model import TabularModel
from fastai.basics import Learner
from fastai.basics import MSELossFlat
from fastai.callback.progress import ProgressCallback
def make_batched_dataloader(paths, columns, batch_size):
dataset = nvt.Dataset(paths)
ds_batch_sets = TorchAsyncItr(
dataset,
batch_size=batch_size,
cats=CATEGORICAL_COLUMNS,
conts=CONTINUOUS_COLUMNS,
labels=LABEL_COLUMNS,
)
return DLDataLoader(ds_batch_sets,
batch_size=None,
pin_memory=False,
collate_fn=FastaiTransform(ds_batch_sets).transform,
num_workers=0)
train_dataset = make_batched_dataloader(TRAIN_PATHS, COLUMNS, BATCH_SIZE)
valid_dataset = make_batched_dataloader(VALID_PATHS, COLUMNS, BATCH_SIZE * 4)
[13]:
databunch = TabularDataLoaders(train_dataset, valid_dataset)
fast.ai: Defining a Model
Next we’ll need to define the inputs that will feed our model and build an architecture on top of them. For now, we’ll just stick to a simple MLP model.
Using FastAI’s TabularModel, we can build an MLP under the hood by defining its high-level characteristics.
[14]:
pt_model = TabularModel(
emb_szs=list(EMBEDDING_TABLE_SHAPES.values()),
n_cont=len(CONTINUOUS_COLUMNS),
out_sz=1,
layers=HIDDEN_DIMS,
ps=DROPOUT_RATES,
use_bn=True,
embed_p=EMBEDDING_DROPOUT_RATE,
y_range=torch.tensor([0.0, MAX_LOG_SALES_PREDICTION]),
).cuda()
fast.ai: Training
[15]:
from fastai.torch_core import flatten_check
from time import time
def exp_rmspe(pred, targ):
"Exp RMSE between `pred` and `targ`."
pred, targ = flatten_check(pred, targ)
pred, targ = torch.exp(pred) - 1, torch.exp(targ) - 1
pct_var = (targ - pred) / targ
return torch.sqrt((pct_var ** 2).mean())
loss_func = MSELossFlat()
learner = Learner(
databunch, pt_model, loss_func=loss_func, metrics=[exp_rmspe], cbs=ProgressCallback()
)
start = time()
learner.fit(EPOCHS, LEARNING_RATE)
t_final = time() - start
total_rows = train_dataset.dataset.num_rows_processed + valid_dataset.dataset.num_rows_processed
print(
f"run_time: {t_final} - rows: {total_rows} - epochs: {EPOCHS} - dl_thru: { (EPOCHS * total_rows) / t_final}"
)
| epoch | train_loss | valid_loss | exp_rmspe | time |
|---|
| epoch | train_loss | valid_loss | exp_rmspe | time |
|---|---|---|---|---|
| 0 | 0.870130 | 1.443352 | 0.668771 | 00:02 |
| 1 | 0.451688 | 0.238232 | 0.396827 | 00:01 |
| 2 | 0.290309 | 0.147549 | 0.484601 | 00:01 |
| 3 | 0.204925 | 0.151387 | 0.537334 | 00:01 |
| 4 | 0.153039 | 0.105131 | 0.404711 | 00:01 |
| 5 | 0.118746 | 0.060419 | 0.265174 | 00:01 |
| 6 | 0.094846 | 0.037690 | 0.197737 | 00:01 |
| 7 | 0.077555 | 0.034608 | 0.192175 | 00:01 |
| 8 | 0.064673 | 0.032721 | 0.187379 | 00:01 |
| 9 | 0.054867 | 0.032081 | 0.185658 | 00:01 |
| 10 | 0.047228 | 0.031881 | 0.189285 | 00:01 |
| 11 | 0.041429 | 0.030871 | 0.177481 | 00:01 |
| 12 | 0.037166 | 0.031383 | 0.185052 | 00:01 |
| 13 | 0.033308 | 0.029781 | 0.180436 | 00:01 |
| 14 | 0.030054 | 0.028644 | 0.175005 | 00:01 |
| 15 | 0.028240 | 0.029979 | 0.181500 | 00:01 |
| 16 | 0.026032 | 0.026933 | 0.168009 | 00:01 |
| 17 | 0.024473 | 0.028919 | 0.177013 | 00:01 |
| 18 | 0.022900 | 0.028642 | 0.163702 | 00:01 |
| 19 | 0.021604 | 0.027488 | 0.162483 | 00:01 |
| 20 | 0.020489 | 0.026400 | 0.161136 | 00:01 |
| 21 | 0.019540 | 0.026042 | 0.166578 | 00:01 |
| 22 | 0.018842 | 0.028341 | 0.162945 | 00:01 |
| 23 | 0.018130 | 0.025699 | 0.159816 | 00:01 |
| 24 | 0.017510 | 0.024265 | 0.162697 | 00:01 |
run_time: 49.69642353057861 - rows: 844338 - epochs: 25 - dl_thru: 424747.8691703398