Fixes #492 Fixes #488

Goals :soccer:

• Document how to use DataParallel and DistributedDataParallel multi-gpu training.
• Demonstrate the potential performance benefit of DataParallel and DistributedDataParallel multi-gpu training through presenting experiment results.

Implementation Details :construction:

• Experiments were done on a node with 2 Tesla V100-SXM2-32GB-LS GPUs using T4Rec after changes included in #496. The scripts used were the ones included in ci/test_integration.sh.

Testing Details :mag:

• Refer to the documentation content to use DataParallel or DistributedDataParallel mode.

Fixes https://github.com/NVIDIA-Merlin/Transformers4Rec/issues/86

Goals :soccer:

Add support for mean reciprocal rank

Implementation Details :construction:

I followed the template of NDCG to implement this.

Testing Details :mag:

Single basic unit test.

Fixes #544

• All prediction tasks return the same output format:

  • During training and evaluation: the output is a dictionary with three elements: {"loss":torch.tensor, "labels": torch.tensor, "predictions": torch.tensor}

  • During inference: The output is the tensor of predictions.

Goals :soccer:

This part of refactoring includes 4 parts:

• Update base PredictionTask class:
• Update Head and Model classes to support the new convention in their forward method call + calculate_metrics
• Update the fit method [in progress]: loss is computed inside the forward call + add flag compute_metrics=True to control whether to compute metrics during training or not. Replace the compute_loss call loss = self.compute_loss(x, y) by :

outputs = self(x, y, training=True)
loss = outputs['loss']
if compute_metrics=True: 
    self.calculate_metrics(outputs['predictions'], outputs['labels'], mode='train', forward=False, call_body=False)

• Update the failing unit tests

Testing Details :mag:

Run the torch unit tests and you will see they pass. You can also try with integration tests.

🚀 Feature request

Wanted to check if it is currently possible to perform model inference locally in place of setting up Triton Server. If yes, where is the documentation available currently for the same?

Motivation

• Currently, whenever I build a new model, I have to deploy it on Triton Server, but just to check the model performance of a batch of 10-20 sessions for testing, wanted to check if there was a way to see results by inferencing locally.
• Secondly, to setup triton server, there's a need to download the docker image and setup the nvcr.io/nvidia/merlin/merlin-inference:21.09 image. But is there a work around to inference locally?

❓ Questions & Help

Details

I tried running creating a custom container on vertex ai to run my T4R notebooks

My dockerfile is as follows

FROM nvcr.io/nvidia/merlin/merlin-inference:21.11 EXPOSE 8080 EXPOSE 8888 ENTRYPOINT jupyter lab --ip 0.0.0.0 --port 8080 --allow-root --no-browser --NotebookApp.token='' --NotebookApp.password=''

I am getting jupyter status unhealthy error and couldn't run the notebooks. Has anyone got any success creating a custom container to run T4R library notebooks? Any hint, help much appreciated :)

Fixes #267 Relates to #471, #475 , #485 , and RMP #211

Goals :soccer:

Introduces the PretrainedEmbeddingsInitializer, which allows initializing an embedding table matrix with pre-trained weights and make it trainable or not. In collaboration with @angmc

Implementation Details :construction:

The signature is PretrainedEmbeddingsInitializer(weights_matrix, trainable=False). The weights_matrix expects a 2D matrix in numpy, list or torch tensor).

Testing Details :mag:

A test demonstrates how to use PretrainedEmbeddingsInitializer with trainable True and False.

pre_trained_item_embeddings = np.random.rand(item_id_cardinality, embedding_dim)

emb_module = tr.EmbeddingFeatures.from_schema(
        schema,
        embedding_dims={"item_id/list": embedding_dim},
        embeddings_initializers={
            "item_id/list": tr.PretrainedEmbeddingsInitializer(
                pre_trained_item_embeddings, trainable=trainable
            ),
        },
    )

Goals :soccer:

The final goal of these changes is to:

1. Be able to use HF Trainer for training all types of tasks (i.e. BinaryClassificationTask and RegressionTask as well as NextItemPredictionTask) to leverage the multi-gpu support already implemented in HF Trainer.
2. Standardize inference to help with integration with Triton.

Implementation Details :construction:

• Standardize the output of forward() functions within T4Rec. All Tasks, Heads and Models will return:

1. A dictionary of {"loss":Tensor, "labels": Union[Tensor,Dict{"task_name":Tensor}], "predictions":Union[Tensor,Dict{"task_name":Tensor}]} during training and evaluation
2. A Tensor during inference To learn more, refer to this diagram.

• Refactor T4Rec flags used within forward() functions of tasks, Heads and Models:

1. Removed hf_format flag as it was not clear and not needed after standardizing the output format.
2. Added testing and training flags to indicate whether we are doing training, evaluation or inference. To know how these flags work refer to top half of this diagram.
3. Removed ignore_masking flag because knowing the mode (train, eval or inference) with the help of training and testing flags means we can know if masking must be applied or ignored.

• targets was added as an input argument to forward() functions that will be called for BinaryClassificationTask and RegressionTask. So from now on, we can call forward() from HF Trainer class to train these tasks and there is no more need to call custom compute_loss() function.

Testing Details :mag:

Go to CI integration tests and run the tests included there using the dataset already downloaded and unzipped by the shell script.

❓ Questions & Help

Details

Hi,

What does input data look like? Currently, I have sessions based data in Pandas DataFrame. I am following RecSys 21 tutorial and currently stuck at 8th cell of this notbook at data loading step. How do I go from having data in Pandas DataFrame to be able to load it in the library for training?

Note: At the moment, I don't have GPU access and I can't get cudf installed on my SageMaker Studio notebook. I want to execute Transformers4Rec on CPU.

Report incorrect documentation

There is only Triton Inference Server option explained in the end-to-end-session-based example notebook. However, we are also aware that PyTorch TIS has an open issue here. There is a closed issue related to local inference here, but it's more of a discussion rather than clean documentation with example.

Suggested fix for documentation

Modify the end-to-end-session-based example here and include valid/tested local inference/prediction approach with PyTorch.

Describe the documentation you'd like

How to use Transformers4Rec locally without the Triton Inference Server (TIS), to be able to surpass bugs and issues with TIS until those issues are fixed.

Steps taken to search for needed documentation**

Searched repo docs, examples, issues

Bug description

Running conda install -c nvidia transformers4rec gets an error; while running alternative command pip install transformers4rec[pytorch,nvtabular] gets another error.

Steps/Code to reproduce bug

1. conda create -n trans4rec python=3.8
2. conda activate trans4rec
3. conda install -c nvidia transformers4rec
4. pip install transformers4rec[pytorch,nvtabular]

Expected behavior

Transformer4rec should be successfully installed.

Environment details

• Transformers4Rec version: N/A
• Platform: Ubuntu 20.04
• Python version: Python 3.8.13

Additional context

❓ Questions & Help

I'm curious on if the schema.pb file is generated manually or automatically? I have seen them in the demos and it's not entirely clear to me how they are created (if they are in the notebooks).

Details

For example, how is the schema here generated?

Bug description

Trying to run the example throws the following exception when training is started

---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
File <timed exec>:18

File /usr/local/lib/python3.8/dist-packages/transformers/trainer.py:1316, in Trainer.train(self, resume_from_checkpoint, trial, ignore_keys_for_eval, **kwargs)
   1314         tr_loss_step = self.training_step(model, inputs)
   1315 else:
-> 1316     tr_loss_step = self.training_step(model, inputs)
   1318 if (
   1319     args.logging_nan_inf_filter
   1320     and not is_torch_tpu_available()
   1321     and (torch.isnan(tr_loss_step) or torch.isinf(tr_loss_step))
   1322 ):
   1323     # if loss is nan or inf simply add the average of previous logged losses
   1324     tr_loss += tr_loss / (1 + self.state.global_step - self._globalstep_last_logged)

File /usr/local/lib/python3.8/dist-packages/transformers/trainer.py:1867, in Trainer.training_step(self, model, inputs)
   1865     loss = self.deepspeed.backward(loss)
   1866 else:
-> 1867     loss.backward()
   1869 return loss.detach()

File /usr/local/lib/python3.8/dist-packages/torch/_tensor.py:402, in Tensor.backward(self, gradient, retain_graph, create_graph, inputs)
    393 if has_torch_function_unary(self):
    394     return handle_torch_function(
    395         Tensor.backward,
    396         (self,),
   (...)
    400         create_graph=create_graph,
    401         inputs=inputs)
--> 402 torch.autograd.backward(self, gradient, retain_graph, create_graph, inputs=inputs)

File /usr/local/lib/python3.8/dist-packages/torch/autograd/__init__.py:184, in backward(tensors, grad_tensors, retain_graph, create_graph, grad_variables, inputs)
    180 inputs = (inputs,) if isinstance(inputs, torch.Tensor) else \
    181     tuple(inputs) if inputs is not None else tuple()
    183 grad_tensors_ = _tensor_or_tensors_to_tuple(grad_tensors, len(tensors))
--> 184 grad_tensors_ = _make_grads(tensors, grad_tensors_, is_grads_batched=False)
    185 if retain_graph is None:
    186     retain_graph = create_graph

File /usr/local/lib/python3.8/dist-packages/torch/autograd/__init__.py:85, in _make_grads(outputs, grads, is_grads_batched)
     83 if out.requires_grad:
     84     if out.numel() != 1:
---> 85         raise RuntimeError("grad can be implicitly created only for scalar outputs")
     86     new_grads.append(torch.ones_like(out, memory_format=torch.preserve_format))
     87 else:

RuntimeError: grad can be implicitly created only for scalar outputs

Steps/Code to reproduce bug

1. docker pull nvcr.io/nvidia/merlin/merlin-pytorch:22.11
2. Start docker container as described here: https://github.com/NVIDIA-Merlin/Transformers4Rec/tree/main/examples
3. Clone the repo into the docker container
4. in the 2nd notebook comment out the data_loader_engine='merlin' because this doesn't work
5. execute the first 2 notebooks in examples/getting-started-session-based

Expected behavior

The example runs through without crashing

Environment details

• Transformers4Rec version: 0.1.15
• Platform: docker / ubuntu
• Python version: 3.8.10
• Huggingface Transformers version: 4.12.0
• PyTorch version: 1.12.1 with GPU
• Tensorflow version (GPU?): -
• CUDA version: 11.7

Additional context

I commented out the data_loader_engine='merlin' param in the config because this throws an error that merlin was never registered with pytorch

This PR fixes user warning and readme documentation about data partitions for multi GPU training. This addresses https://github.com/NVIDIA-Merlin/Transformers4Rec/issues/550.

Fixes #550

@bbozkaya runs different tests (see image below) of repartitioning a parquet file (using pandas or cudf) and it seems that MerlinDataLoader always loads the dataset files with 1 partition even though we partition to multiple groups when saving the parquet file (as recommended here). To take into account these partitions, we should pass the parameter row_groups_per_part=True to the merlin.io.Dataset.

Goals :soccer:

• Add the parameter row_groups_per_part to MerlinDataLoader so as to load the dataset with the correct partitions.
• Add docstrings to the MerlinDataLoader to explain the different parameters.
• Add a user warning to ensure that dataset's partitions are divisible by the number of GPUs for DDP training. This is needed to ensure optimal performance by equally distributing the data among available GPUs.

Bug description

Bug 1 examples/tutorial/03-Session-based-recsys.ipynb, section "3.2.4 Train XLNET with Side Information for Next Item Prediction" , the cell that runs training fails.

***** Running training *****
  Num examples = 112128
  Num Epochs = 3
  Instantaneous batch size per device = 256
  Total train batch size (w. parallel, distributed & accumulation) = 256
  Gradient Accumulation steps = 1
  Total optimization steps = 1314
---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
File <timed exec>:15

File /usr/local/lib/python3.8/dist-packages/transformers/trainer.py:1316, in Trainer.train(self, resume_from_checkpoint, trial, ignore_keys_for_eval, **kwargs)
   1314         tr_loss_step = self.training_step(model, inputs)
   1315 else:
-> 1316     tr_loss_step = self.training_step(model, inputs)
   1318 if (
   1319     args.logging_nan_inf_filter
   1320     and not is_torch_tpu_available()
   1321     and (torch.isnan(tr_loss_step) or torch.isinf(tr_loss_step))
   1322 ):
   1323     # if loss is nan or inf simply add the average of previous logged losses
   1324     tr_loss += tr_loss / (1 + self.state.global_step - self._globalstep_last_logged)

File /usr/local/lib/python3.8/dist-packages/transformers/trainer.py:1849, in Trainer.training_step(self, model, inputs)
   1847         loss = self.compute_loss(model, inputs)
   1848 else:
-> 1849     loss = self.compute_loss(model, inputs)
   1851 if self.args.n_gpu > 1:
   1852     loss = loss.mean()  # mean() to average on multi-gpu parallel training

File /usr/local/lib/python3.8/dist-packages/transformers/trainer.py:1881, in Trainer.compute_loss(self, model, inputs, return_outputs)
   1879 else:
   1880     labels = None
-> 1881 outputs = model(**inputs)
   1882 # Save past state if it exists
   1883 # TODO: this needs to be fixed and made cleaner later.
   1884 if self.args.past_index >= 0:

File /usr/local/lib/python3.8/dist-packages/torch/nn/modules/module.py:1186, in Module._call_impl(self, *input, **kwargs)
   1182 # If we don't have any hooks, we want to skip the rest of the logic in
   1183 # this function, and just call forward.
   1184 if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks
   1185         or _global_forward_hooks or _global_forward_pre_hooks):
-> 1186     return forward_call(*input, **kwargs)
   1187 # Do not call functions when jit is used
   1188 full_backward_hooks, non_full_backward_hooks = [], []

File /usr/local/lib/python3.8/dist-packages/transformers4rec/torch/trainer.py:830, in HFWrapper.forward(self, *args, **kwargs)
    828 def forward(self, *args, **kwargs):
    829     inputs = kwargs
--> 830     return self.wrapper_module(inputs, *args)

File /usr/local/lib/python3.8/dist-packages/torch/nn/modules/module.py:1186, in Module._call_impl(self, *input, **kwargs)
   1182 # If we don't have any hooks, we want to skip the rest of the logic in
   1183 # this function, and just call forward.
   1184 if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks
   1185         or _global_forward_hooks or _global_forward_pre_hooks):
-> 1186     return forward_call(*input, **kwargs)
   1187 # Do not call functions when jit is used
   1188 full_backward_hooks, non_full_backward_hooks = [], []

File /usr/local/lib/python3.8/dist-packages/transformers4rec/torch/model/base.py:553, in Model.forward(self, inputs, training, **kwargs)
    550 outputs = {}
    551 for head in self.heads:
    552     outputs.update(
--> 553         head(inputs, call_body=True, training=training, always_output_dict=True, **kwargs)
    554     )
    556 if len(outputs) == 1:
    557     outputs = outputs[list(outputs.keys())[0]]

File /usr/local/lib/python3.8/dist-packages/torch/nn/modules/module.py:1186, in Module._call_impl(self, *input, **kwargs)
   1182 # If we don't have any hooks, we want to skip the rest of the logic in
   1183 # this function, and just call forward.
   1184 if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks
   1185         or _global_forward_hooks or _global_forward_pre_hooks):
-> 1186     return forward_call(*input, **kwargs)
   1187 # Do not call functions when jit is used
   1188 full_backward_hooks, non_full_backward_hooks = [], []

File /usr/local/lib/python3.8/dist-packages/transformers4rec/torch/model/base.py:398, in Head.forward(self, body_outputs, training, call_body, always_output_dict, ignore_masking, **kwargs)
    395 outputs = {}
    397 if call_body:
--> 398     body_outputs = self.body(body_outputs, training=training, ignore_masking=ignore_masking)
    400 for name, task in self.prediction_task_dict.items():
    401     outputs[name] = task(
    402         body_outputs, ignore_masking=ignore_masking, training=training, **kwargs
    403     )

File /usr/local/lib/python3.8/dist-packages/transformers4rec/config/schema.py:50, in SchemaMixin.__call__(self, *args, **kwargs)
     47 def __call__(self, *args, **kwargs):
     48     self.check_schema()
---> 50     return super().__call__(*args, **kwargs)

File /usr/local/lib/python3.8/dist-packages/torch/nn/modules/module.py:1186, in Module._call_impl(self, *input, **kwargs)
   1182 # If we don't have any hooks, we want to skip the rest of the logic in
   1183 # this function, and just call forward.
   1184 if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks
   1185         or _global_forward_hooks or _global_forward_pre_hooks):
-> 1186     return forward_call(*input, **kwargs)
   1187 # Do not call functions when jit is used
   1188 full_backward_hooks, non_full_backward_hooks = [], []

File /usr/local/lib/python3.8/dist-packages/transformers4rec/torch/block/base.py:152, in SequentialBlock.forward(self, input, training, ignore_masking, **kwargs)
    150 elif "training" in inspect.signature(module.forward).parameters:
    151     if "ignore_masking" in inspect.signature(module.forward).parameters:
--> 152         input = module(input, training=training, ignore_masking=ignore_masking)
    153     else:
    154         input = module(input, training=training)

File /usr/local/lib/python3.8/dist-packages/transformers4rec/config/schema.py:50, in SchemaMixin.__call__(self, *args, **kwargs)
     47 def __call__(self, *args, **kwargs):
     48     self.check_schema()
---> 50     return super().__call__(*args, **kwargs)

File /usr/local/lib/python3.8/dist-packages/transformers4rec/torch/tabular/base.py:390, in TabularModule.__call__(self, inputs, pre, post, merge_with, aggregation, *args, **kwargs)
    387 inputs = self.pre_forward(inputs, transformations=pre)
    389 # This will call the `forward` method implemented by the super class.
--> 390 outputs = super().__call__(inputs, *args, **kwargs)  # noqa
    392 if isinstance(outputs, dict):
    393     outputs = self.post_forward(
    394         outputs, transformations=post, merge_with=merge_with, aggregation=aggregation
    395     )

File /usr/local/lib/python3.8/dist-packages/torch/nn/modules/module.py:1186, in Module._call_impl(self, *input, **kwargs)
   1182 # If we don't have any hooks, we want to skip the rest of the logic in
   1183 # this function, and just call forward.
   1184 if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks
   1185         or _global_forward_hooks or _global_forward_pre_hooks):
-> 1186     return forward_call(*input, **kwargs)
   1187 # Do not call functions when jit is used
   1188 full_backward_hooks, non_full_backward_hooks = [], []

File /usr/local/lib/python3.8/dist-packages/transformers4rec/torch/features/sequence.py:257, in TabularSequenceFeatures.forward(self, inputs, training, ignore_masking, **kwargs)
    254     outputs = self.aggregation(outputs)
    256 if self.projection_module:
--> 257     outputs = self.projection_module(outputs)
    259 if self.masking and (not ignore_masking or training):
    260     outputs = self.masking(
    261         outputs, item_ids=self.to_merge["categorical_module"].item_seq, training=training
    262     )

File /usr/local/lib/python3.8/dist-packages/transformers4rec/config/schema.py:50, in SchemaMixin.__call__(self, *args, **kwargs)
     47 def __call__(self, *args, **kwargs):
     48     self.check_schema()
---> 50     return super().__call__(*args, **kwargs)

File /usr/local/lib/python3.8/dist-packages/torch/nn/modules/module.py:1186, in Module._call_impl(self, *input, **kwargs)
   1182 # If we don't have any hooks, we want to skip the rest of the logic in
   1183 # this function, and just call forward.
   1184 if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks
   1185         or _global_forward_hooks or _global_forward_pre_hooks):
-> 1186     return forward_call(*input, **kwargs)
   1187 # Do not call functions when jit is used
   1188 full_backward_hooks, non_full_backward_hooks = [], []

File /usr/local/lib/python3.8/dist-packages/transformers4rec/torch/block/base.py:148, in SequentialBlock.forward(self, input, training, ignore_masking, **kwargs)
    146 if i == len(self) - 1:
    147     filtered_kwargs = filter_kwargs(kwargs, module, filter_positional_or_keyword=False)
--> 148     input = module(input, **filtered_kwargs)
    150 elif "training" in inspect.signature(module.forward).parameters:
    151     if "ignore_masking" in inspect.signature(module.forward).parameters:

File /usr/local/lib/python3.8/dist-packages/transformers4rec/config/schema.py:50, in SchemaMixin.__call__(self, *args, **kwargs)
     47 def __call__(self, *args, **kwargs):
     48     self.check_schema()
---> 50     return super().__call__(*args, **kwargs)

File /usr/local/lib/python3.8/dist-packages/torch/nn/modules/module.py:1186, in Module._call_impl(self, *input, **kwargs)
   1182 # If we don't have any hooks, we want to skip the rest of the logic in
   1183 # this function, and just call forward.
   1184 if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks
   1185         or _global_forward_hooks or _global_forward_pre_hooks):
-> 1186     return forward_call(*input, **kwargs)
   1187 # Do not call functions when jit is used
   1188 full_backward_hooks, non_full_backward_hooks = [], []

File /usr/local/lib/python3.8/dist-packages/transformers4rec/torch/block/base.py:156, in SequentialBlock.forward(self, input, training, ignore_masking, **kwargs)
    154             input = module(input, training=training)
    155     else:
--> 156         input = module(input)
    158 return input

File /usr/local/lib/python3.8/dist-packages/torch/nn/modules/module.py:1186, in Module._call_impl(self, *input, **kwargs)
   1182 # If we don't have any hooks, we want to skip the rest of the logic in
   1183 # this function, and just call forward.
   1184 if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks
   1185         or _global_forward_hooks or _global_forward_pre_hooks):
-> 1186     return forward_call(*input, **kwargs)
   1187 # Do not call functions when jit is used
   1188 full_backward_hooks, non_full_backward_hooks = [], []

File /usr/local/lib/python3.8/dist-packages/torch/nn/modules/linear.py:114, in Linear.forward(self, input)
    113 def forward(self, input: Tensor) -> Tensor:
--> 114     return F.linear(input, self.weight, self.bias)

RuntimeError: expected scalar type Float but found Double

I believe this is because the product_recency_days_log_norm-list_seq created in the prior notebook (02-ETL-with-NVTabular) is float64 rather than float32. I was able to get things to run by adding >> nvt.ops.ReduceDtypeSize() to the cell where that feature is defined in the prior notebook, section 5.3. I'm not sure if this is the correct fix though.

Bug 2

XLNet-MLM with side information accuracy results that get written to results.txt in 03-Session-based-recsys should have metric name and values separated by : rather than space. Metrics from the other two models trained in the notebook are written correctly. This causes the call to create_bar_chart('results.txt') to fail.

Easy fix,

with open("results.txt", 'a') as f:
    f.write('\n')
    f.write('XLNet-MLM with side information accuracy results:')
    f.write('\n')
    for key, value in  model.compute_metrics().items(): 
        f.write('%s %s\n' % (key, value.item()))

should have f.write('%s:%s\n' % (key, value.item())) in the last line.

Steps/Code to reproduce bug

Run the tutorial notebooks.

Expected behavior

Environment details

Google Cloud Workbench managed notebook with image version nvcr.io/nvidia/merlin/merlin-pytorch:22.11

Machine info: a2-highgpu-1g (Accelerator Optimized: 1 NVIDIA Tesla A100 GPU, 12 vCPUs, 85GB RAM)

I'm using version of the example notebooks that are available in the image.

• Transformers4Rec version: 0.1.15
• Platform: Google Cloud Workbench managed notebook, image nvcr.io/nvidia/merlin/merlin-pytorch:22.11, Machine type a2-highgpu-1g (Accelerator Optimized: 1 NVIDIA Tesla A100 GPU, 12 vCPUs, 85GB RAM),
• Python version: 3.8.10
• Huggingface Transformers version: 4.12.0
• PyTorch version (GPU?): 1.13.0a0+d321be6
• Tensorflow version (GPU?):

Additional context

This PR:

• fixes/sets data paths and env variables for certain args in the notebooks
• fixes the error due to returned tuple from Merlin dataloader in the 03 notebook.
• adding a unit test with for 01 and 02 notebooks using testbook.

Note: if we want a unit test for serving notebook, we would need systems here. currently we dont couple TF4Rec to systems, that's why I removed that part in the unit test code. The decision is to do that in Merlin repo, instead of TF4Rec repo.

❓ Questions & Help

As a part of exploration i'm running the code for transform4rec model built on synthetic data [https://github.com/NVIDIA-Merlin/Transformers4Rec/blob/main/examples/getting-started-session-based/02-session-based-XLNet-with-PyT.ipynb]

throwing exception while running the below code. and the error is Based on my understanding the error occurs on evaluation step where input file is not in required dimension.

Details

this is my path for train,valid,and test files