TensorFlow to Rust package

Special thanks to Marian Radu for his support during the development of the package

Training Workflow

General Information

A Python package that converts a TensorFlow model (.pb or .h5 format) into pure Rust code. This package is dependent on tf-layers (Rust):

Currently, this package supports models that contain the following layers (the layers number is expected to grow in the future with the addition of further architectures):

• InputLayer - input layer. For further information check: https://www.tensorflow.org/api_docs/python/tf/keras/layers/InputLayer
• Multiply - multiply layer. For further information check: https://www.tensorflow.org/api_docs/python/tf/keras/layers/Multiply
• Reshape - reshape layer. For further information check: https://www.tensorflow.org/api_docs/python/tf/keras/layers/Reshape
• Conv1D - 1D convolutional layer. For further information check: https://www.tensorflow.org/api_docs/python/tf/keras/layers/Conv1D
• Embedding - embedding layer. For further information check: https://www.tensorflow.org/api_docs/python/tf/keras/layers/Embedding
• Dense - dense layer. For further information check: https://www.tensorflow.org/api_docs/python/tf/keras/layers/Dense
• Flatten - flatten layer. For further information check: https://www.tensorflow.org/api_docs/python/tf/keras/layers/Flatten
• Concatenate - concatenate layer. For further information check: https://www.tensorflow.org/api_docs/python/tf/keras/layers/Concatenate
• GlobalAveragePooling - global average pooling layer. For further information check: https://www.tensorflow.org/api_docs/python/tf/keras/layers/GlobalAveragePooling1D
• MaxPooling - maxpooling layer. For further information check: https://www.tensorflow.org/api_docs/python/tf/keras/layers/MaxPool1D
• AveragePooling - averagepooling layer. For further information check: https://www.tensorflow.org/api_docs/python/tf/keras/layers/AveragePooling1D
• BatchNormalization - batchnormalization layer. For further information check: https://www.tensorflow.org/api_docs/python/tf/keras/layers/BatchNormalization
• Add - addition layer.
• Mean - mean layer over a specified axis.
• Activation - different types of activation supported (can be used as an independent layer or inside different NN layers such as Dense, Conv1D, etc). Support available for:
  • Linear(Identity)
  • Relu
  • ThresholdedRelu
  • Selu
  • Sigmoid
  • Softmax
  • SoftPlus
  • SoftSign
  • Tanh
• Note1: Some layers might not have all the functionalities from TensorFlow implemented.
• Note2: It is mandatory to use an InputLayer for each input that the model expects. It is also mandatory that InputLayer's dtype be exactly specified (default is float). For instance, if an InputLayer is followed by an EmbeddingLayer, then the type of that particular InputLayer must be set to int - e.g. "int64". Another requirement is to have the output_shape of each layer specified (the only unspecified size should be about the batch size). This is usually done by setting the input_shape parameter when initializing the InputLayer.

Requirements

This project targets the Python 3.8 interpreter. You will need to install graphviz using your system dependency manager of choice. On macOS, this can be done with the command:

bash brew install graphviz

To set up a virtualenv with poetry, execute the following commands in the project root:

bash poetry install poetry shell

Configuration arguments

--pathtotf_model

The path (relative or absolute) to the TensorFlow model to be converted into pure Rust code. It is mandatory.

--pathtosave

The path (relative or absolute) where to save the generated Rust code. It is mandatory.

--model_name

The model name. A struct named Model will be created in Rust. E.g model_name = Mnist => Mnist. It is mandatory.

--binary_classification

Set this flag to true/false whether the model is a binary classifier or not (false for regression or multiclass classifiers). Default is true.

--enable_inplace

Set this flag to true/false whether you want the model written in Rust to use in-place operations whenever possible (in predict_from_array function). Default is true.

--enable_memdrop

Set this flag to true/false whether you want the model written in Rust to free the memory of intermediate layers results as soon as possible (instead of the actual ending of predict_from_array function). Default is true.

--pathtofv

Set the path to a npz array containing the FV for a bunch of samples. The keys for the arrays should match the keys from perform_fx from NeuralBrain (which must be the same as the InputLayers' names when building the model). Also, the expected predictions should be saved as an array in features.npz by the key predictions. This flag is optional.

Output Files

• savedmodelfrom_tensorflow:
  • computation_graph.json: The computational dependencies.
  • modelarchitecture.json: Different parameters for the actual NN layers (stride, poolsize, kernel_size, activation type, etc).
  • model_overview.png: A graph image describing the model.
  • model_weights.npz: model's weights.
• rustgeneratedcode:
  • build.rs: A Rust build file used in serializing the model by reading from model_weights.npz
  • Cargo.toml: the place where all the imports are specified (and many more).
• rustgeneratedcode/model:
  • model_weights.npz: model weights saved in a format that can be used by Rust.
  • thresholds.json: the thresholds for low, bottom, medium, high confidence levels.
• rustgeneratedcode/src:
  • model.rs: A Rust structure encapsulating all the logic behind prediction.
  • lib.rs: the file containing the tests.
• rustgeneratedcode/testdata:
  • features.npz: the features to be passed to the model (1D numpy ndarray).
• rustgeneratedcode/benches:
  • benchmarks.rs: the file in charge of benchmarks.

In order to asses the performance of the model, run cargo bench

In order to test the predictions and see the translation went as expected, run cargo test

Note: all this commands need be executed on rust_generated_code/ directory

Usage

To convert a TensorFlow model use a command-line like the followings:

```bash python3 -m tf2rust \ --pathtotfmodel tests/data/mnist/tfmodel/ \ --pathtosave tests/data/generatedclassifiers/mnist \ --modelname MNist \ --binaryclassification True \ --enableinplace True \ --enablememdrop True \ --pathto_fv tests/data/mnist/features.npz # for testing purposes, optional

```

Converting .h5 models to .pb

```python from tensorflow.keras.models import loadmodel, savemodel

Note that models will have different metrics also saved with the models and expect the implementations for these

metrics.

We have these implemented in utils/scoring_metrics.py but these are not used, and we can also provide None.

model = loadmodel('newmodel.h5', customobjects={'tpr': None, 'tnr': None, 'auc': None}) savemodel(model=model, filepath='tfmodel/', includeoptimizer=False) ```

Running the tests

At the time we'll migrate towards Dockerising this, we'll also switch to tox (this should not pose any difficulties).

We have currently set up integration tests, which do the following:

• Given model artifacts, generate Rust code
• Check that the Rust code is the same code to what we expect to be generated
• Compile the Rust code and see that all tests pass
  • Tests take in FVs and the DVs generated by the Tensorflow model
  • We check that inference with the Rust model yields the same results as the initial Tensorflow model

bash pytest

Next steps

After everything runs smoothly with your model, please add artifacts and a new test for it.