Hey there,

First of all, congratulations for your effort, this is a great initiative!

I am raising this issue because I have faced a problem with installation. I have created a Python 3.8.6 virtual environment on my Mac and installed tensorflow 2.5.0 successfully. When I ran the installation command for the "Tensorflow Decision Forests" package, pip3 install tensorflow_decision_forests --upgrade

I got:

ERROR: Could not find a version that satisfies the requirement tensorflow_decision_forests (from versions: none) ERROR: No matching distribution found for tensorflow_decision_forests

It's a bit confusing because the installation command on PyPi (I guess this is the right one) contains dashes ,instead of underscores, in the package name.

Any ideas?

Thanks a lot

I am getting the following error when I try a simple model.

csv_feature_columns =  ['weekday_weekend'] + weather_columns + building_columns + schedules_columns + encoded_time_columns + ["total_site_electricity_kwh"] 

train_df = pd.read_csv(timeseries_file_path,usecols=csv_feature_columns,nrows=10000)

train_ds = tfdf.keras.pd_dataframe_to_tf_dataset(train_df, label="total_site_electricity_kwh")

model = tfdf.keras.RandomForestModel()
model.fit(train_ds)

157/157 [==============================] - 6s 18ms/step
---------------------------------------------------------------------------
NotFoundError                             Traceback (most recent call last)
<ipython-input-6-ce1e05e4d2c8> in <module>
      1 # Train a Random Forest model.
      2 model = tfdf.keras.RandomForestModel()
----> 3 model.fit(train_ds)
      4 

~/.conda/envs/tensorflow25/lib/python3.7/site-packages/tensorflow_decision_forests/keras/core.py in fit(self, x, y, callbacks, **kwargs)
    743 
    744     history = super(CoreModel, self).fit(
--> 745         x=x, y=y, epochs=1, callbacks=callbacks, **kwargs)
    746 
    747     self._build(x)

~/.conda/envs/tensorflow25/lib/python3.7/site-packages/tensorflow/python/keras/engine/training.py in fit(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_batch_size, validation_freq, max_queue_size, workers, use_multiprocessing)
   1227           epoch_logs.update(val_logs)
   1228 
-> 1229         callbacks.on_epoch_end(epoch, epoch_logs)
   1230         training_logs = epoch_logs
   1231         if self.stop_training:

~/.conda/envs/tensorflow25/lib/python3.7/site-packages/tensorflow/python/keras/callbacks.py in on_epoch_end(self, epoch, logs)
    433     logs = self._process_logs(logs)
    434     for callback in self.callbacks:
--> 435       callback.on_epoch_end(epoch, logs)
    436 
    437   def on_train_batch_begin(self, batch, logs=None):

~/.conda/envs/tensorflow25/lib/python3.7/site-packages/tensorflow_decision_forests/keras/core.py in on_epoch_end(***failed resolving arguments***)
    930     del logs
    931     if epoch == 0:
--> 932       self._model._train_model()  # pylint:disable=protected-access
    933 
    934 

~/.conda/envs/tensorflow25/lib/python3.7/site-packages/tensorflow_decision_forests/keras/core.py in _train_model(self)
    864         guide=guide,
    865         training_config=self._advanced_arguments.yggdrasil_training_config,
--> 866         deployment_config=self._advanced_arguments.yggdrasil_deployment_config,
    867     )
    868 

~/.conda/envs/tensorflow25/lib/python3.7/site-packages/tensorflow_decision_forests/tensorflow/core.py in train(input_ids, label_id, model_id, learner, task, generic_hparms, ranking_group, training_config, deployment_config, guide, model_dir, keep_model_in_resource)
    503       training_config=training_config.SerializeToString(),
    504       deployment_config=deployment_config.SerializeToString(),
--> 505       guide=guide.SerializeToString())
    506 
    507 

~/.conda/envs/tensorflow25/lib/python3.7/site-packages/tensorflow/python/util/tf_export.py in wrapper(*args, **kwargs)
    402           'Please pass these args as kwargs instead.'
    403           .format(f=f.__name__, kwargs=f_argspec.args))
--> 404     return f(**kwargs)
    405 
    406   return tf_decorator.make_decorator(f, wrapper, decorator_argspec=f_argspec)

~/.conda/envs/tensorflow25/lib/python3.7/site-packages/tensorflow_decision_forests/tensorflow/ops/training/op.py in simple_ml_model_trainer(feature_ids, label_id, weight_id, model_id, model_dir, learner, hparams, task, training_config, deployment_config, guide, name)
    510       return _result
    511     except _core._NotOkStatusException as e:
--> 512       _ops.raise_from_not_ok_status(e, name)
    513     except _core._FallbackException:
    514       pass

~/.conda/envs/tensorflow25/lib/python3.7/site-packages/tensorflow/python/framework/ops.py in raise_from_not_ok_status(e, name)
   6895   message = e.message + (" name: " + name if name is not None else "")
   6896   # pylint: disable=protected-access
-> 6897   six.raise_from(core._status_to_exception(e.code, message), None)
   6898   # pylint: enable=protected-access
   6899 

~/.conda/envs/tensorflow25/lib/python3.7/site-packages/six.py in raise_from(value, from_value)

NotFoundError: Resource decision_forests/ 12-in/N27tensorflow_decision_forests3ops23AbstractFeatureResourceE does not exist. [Op:SimpleMLModelTrainer]

When trying to get a prediction I am getting the error in the title, it also gives the following:

in user code:

    File "/home/laner107/.local/lib/python3.8/site-packages/tensorflow_decision_forests/keras/core.py", line 791, in call  *
        normalized_inputs = self._build_normalized_inputs(inputs)
    File "/home/laner107/.local/lib/python3.8/site-packages/tensorflow_decision_forests/keras/core.py", line 747, in _build_normalized_inputs  *
        assert len(self._semantics) == 1

    AssertionError: 


Call arguments received:
  • inputs=tf.Tensor(shape=(14,), dtype=float32)
  • training=False

The following is where I call the prediction:

  def predict_to_data(self):
        testing_data = test_preprocess()
        testing_data = np.array(testing_data)
        predicitions = self.model(testing_data[0])

here is what the data im passing in looks like:

[0.484375   0.83007665 0.56508876 0.46099291 0.52793453 0.75438596
 0.52066116 0.7826087  0.         0.65852121 0.40425532 0.58974359
 0.69047619 0.37058824]

and here is the architecture for the model:

def create_single_model(self):
        input_features = tf.keras.Input(shape=(self.num_features,))

        # bootstrap_size_ratio: Number of examples used to train each trees; expressed as a ratio of the training dataset size. Default: 1.0.
        rf_model_1 = tfdf.keras.GradientBoostedTreesModel(
            verbose=0,
            task=tfdf.keras.Task.CLASSIFICATION,
            hyperparameter_template="benchmark_rank1@v1",
            num_trees=self.num_of_trees,
        )

        model = tf.keras.models.Model(input_features, rf_model_1(input_features))

        return model

For now I was just going to generate one prediction to see what the output was, eventually though I plan on doing it in batches just have to figure that out, any idea why this error is occurring?

All of this is done after the GradientBoostedTreesModel is trained(fit) and evaluated using validation data.

Hi!

I am trying to serve the test tf-df example decision-forests/examples/minimal.py (aptly named tf-df-example below) using the precompiled tf-serving. Unfortunately, I am running into numerous GLIBC_X.XX not found errors like this:

/usr/bin/tensorflow_model_server: /lib/x86_64-linux-gnu/libc.so.6: version `GLIBC_2.33' not found (required by /usr/bin/tensorflow_model_server)

Best guess is that the issue has to do with the difference between the system that precompiled tensorflow_model_server_linux.zip and what I am in pulling as the base: tensorflow/serving:2.9.1. I have tried others, but ultimately this same GLIBC_X.XX not found error pops up and I'm not sure where to go from here (aside from trying to compile myself).

Any thoughts or suggestions would be greatly appreciated. Thanks!

Here is the set up.

1. Dockerfile:

FROM tensorflow/serving:2.9.1 as base

# Install curl
RUN apt-get update && apt-get install -y --no-install-recommends \
    curl unzip \
    && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*

RUN curl -LJO "https://github.com/tensorflow/decision-forests/releases/download/serving-0.2.6/tensorflow_model_server_linux.zip"
RUN unzip -o tensorflow_model_server_linux.zip -d /usr/bin/

COPY tf-df_serving_entrypoint.sh /usr/bin/tf-df_serving_entrypoint.sh
COPY /models/tf-df-example/ /tensorflow/models/tf-df-example/

WORKDIR /tensorflow/
ENTRYPOINT ["/usr/bin/tf-df_serving_entrypoint.sh"]

2. tf-df_serving_entrypoint.sh:

# Using prebuild binary set in dockerfile
TFSERVING="/usr/bin/tensorflow_model_server"

# Configure the model path and name.
MODEL_PATH=/tensorflow/models/tf-df-example/
MODEL_NAME=tf-df-example

# Start a TF Serving server
${TFSERVING} \
    --rest_api_port=8501 \
    --model_name=${MODEL_NAME} \
    --model_base_path=${MODEL_PATH}

3. To build and run:

docker build . -t tfdf/serving
docker run -t --rm -p 8501:8501 tfdf/serving 

I'm trying to use GradientBoostedTreesModel in a TFX pipeline, the code is roughly as follows:

model = tfdf.keras.GradientBoostedTreesModel(
        task=tfdf.keras.Task.CLASSIFICATION,
        num_trees=200,
        max_depth=6,
        verbose=True,
        hyperparameter_template="better_default",
        name="classifier",
    )
model.compile(metrics=[tf.keras.metrics.AUC(), "accuracy"])
model.fit(_input_fn(fn_args.train_files, fn_args.schema_path))

This unfortunately gives me an INVALID_ARGUMENT: No defined default loss for this combination of label type and task exception and fails the model training.

Definition of _input_fn is as follows:

def _input_fn(...):
        tf.data.TFRecordDataset(
            tf.data.Dataset.list_files(files), compression_type="GZIP"
        )
        .batch(1024)
        .map(
            lambda batch: tf.io.parse_example(batch, specs),
            num_parallel_calls=tf.data.AUTOTUNE,
        )
        .map(lambda batch: (batch, batch.pop(FeatureManager.LABEL_KEY)))
        .cache()
        .prefetch(tf.data.AUTOTUNE)

Which basically parses the schema into feature specs, parses the batch of TF-examples and finally maps them to a tuple of (Dict[feature_name, Tensor], Tensor), results is like this:

<PrefetchDataset 
 element_spec=(
   {'feature1': TensorSpec(shape=(None, 1), dtype=tf.float32, name=None), 'feature2': ...}, 
   TensorSpec(shape=(None, 1), dtype=tf.int64, name=None)
  )
>

Labels can be 0 or 1 and the task is a binary classification task.

Any idea what I might be doing wrong here?

Mac OS Monterey, tfdv 0.2.4, python 3.8, tfx 1.7

Hi, thanks for releasing version TF-DF v1.0.1. are there plans to re-add support for osx as well? I only see it for linux here: https://pypi.org/project/tensorflow-decision-forests/#files

Hi I trained my tfdf model in python and want to use it in java for production. For conventional NN model, we can load the model from SavedModelBundle and get prediction.

try (SavedModelBundle b = SavedModelBundle.load("/tmp/model", "serve")) {

        // create the session from the Bundle
        Session sess = b.session();
        // create an input Tensor, value = 2.0f
        Tensor x = Tensor.create(
            new long[] {NUM_PREDICTIONS}, 
            FloatBuffer.wrap( new float[] {2.0f} ) 
        );
        
        // run the model
        float[] y = sess.runner()
            .feed("x", x)
            .fetch("y")
            .run()
            .get(0)
            .copyTo(new float[NUM_PREDICTIONS]);

        // print out the result.
        System.out.println(y[0]);
    }                

I'm currently trying to use my tfdf model and wondering if current tfdf support loading and inference in Java? Will the model's graph and useful info be loaded? I'm still trying to load it and wondering if anyone has clue? Thank you so much!

Traceback (most recent call last): File "mydf.py", line 29, in model.fit(x=train_ds) File "/home/wanghaikuan/anaconda3/envs/python37/lib/python3.7/site-packages/tensorflow_decision_forests/keras/core.py", line 1535, in fit class_weight=class_weight) File "/home/wanghaikuan/anaconda3/envs/python37/lib/python3.7/site-packages/tensorflow_decision_forests/keras/core.py", line 1668, in _fit_implementation iterator) File "/home/wanghaikuan/anaconda3/envs/python37/lib/python3.7/site-packages/tensorflow/python/training/tracking/base.py", line 587, in _method_wrapper result = method(self, *args, **kwargs) File "/home/wanghaikuan/anaconda3/envs/python37/lib/python3.7/site-packages/tensorflow/python/util/traceback_utils.py", line 153, in error_handler raise e.with_traceback(filtered_tb) from None File "/home/wanghaikuan/anaconda3/envs/python37/lib/python3.7/site-packages/tensorflow_decision_forests/keras/core.py", line 1554, in _consumes_training_examples_until_eof num_examples += self.train_step(data) File "/home/wanghaikuan/anaconda3/envs/python37/lib/python3.7/site-packages/tensorflow_decision_forests/keras/core.py", line 1027, in train_step return self.collect_data_step(data, is_training_example=True) File "/home/wanghaikuan/anaconda3/envs/python37/lib/python3.7/site-packages/tensorflow_decision_forests/keras/core.py", line 1236, in collect_data_step if not self._is_trained: tensorflow.python.framework.errors_impl.OperatorNotAllowedInGraphError: Using a symbolic tf.Tensor as a Python bool is not allowed: AutoGraph did convert this function. This might indicate you are trying to use an unsupported feature.

-------------------------------------------------------- my code is : import numpy as np import pandas as pd import tensorflow as tf import tensorflow_decision_forests as tfdf

print("Found TF-DF v" + tfdf.version)

dataset_path = tf.keras.utils.get_file( "adult.csv", "https://raw.githubusercontent.com/google/yggdrasil-decision-forests/" "main/yggdrasil_decision_forests/test_data/dataset/adult.csv")

dataset_df = pd.read_csv(dataset_path) # "df" for Pandas's DataFrame.

print("First 3 examples:") print(dataset_df.head(3))

test_indices = np.random.rand(len(dataset_df)) < 0.30 test_ds_pd = dataset_df[test_indices] train_ds_pd = dataset_df[~test_indices] print(f"{len(train_ds_pd)} examples in training" f", {len(test_ds_pd)} examples for testing.")

train_ds = tfdf.keras.pd_dataframe_to_tf_dataset(train_ds_pd, label="income") test_ds = tfdf.keras.pd_dataframe_to_tf_dataset(test_ds_pd, label="income")

model = tfdf.keras.RandomForestModel(verbose=2) model.fit(x=train_ds)

i need you help, thanks

It seems the Keras ModelCheckpoint call back doesn't work with TFDF. Is there an alternate way to create checkpoints during training? I am training on a data set with tens of millions of samples and it takes several hours to train. I want to save the progress so that it doesn't need to retrain from scratch in case training crashes.

There is a problem with Tensorflow_decision_forests after updating to version 2.6.0

here is the gist https://colab.research.google.com/gist/lukebor/70f7abd84d547bf39c4a8b47394e7017/beginner_colab.ipynb

I have used tensorflow beginner tutorial and upgraded the tf. If there is other way to import tfdf please let me know

Dear authors,

I used tfdf.pd_dataframe_to_tf_dataset for train and test set respectively after making sure that both train and test had all 4 classes (single label for each data point).

I found that labels in two sets were integer encoded ([0 1 2 3]). I defined:

train = tfdf.keras.pd_dataframe_to_tf_dataset(df_train, label=label_column_name)
test = tfdf.keras.pd_dataframe_to_tf_dataset(df_test, label=label_column_name)
model = RandomForestModel(num_trees=5)
model.fit(train, validation_data=test)

It raised error: ValueError: Shapes (None, 4) and (None, 1) are incompatible Then I move to this code:

model.fit(train)
model.evaluate(test)

It raised error: ValueError: Shapes (None, 4) and (None, 1) are incompatible Then, I checked:

pred = model.predict(test)
print(pred[0])
print(np.unique(pred))

Output:

[0. 1. 0. 0.]
[0.  0.2 0.4 0.6 0.8 1. ]

Please help me to fix this error. Thank you so much.

Initial folder structure for operator definitions. Defined:

• base Operator and WindowOperator classes
• example AssignOperator and SimpleMovingAverage shell classes

For simplicity at this point, and given we are going to be using pandas for the MVP, we decided to create these aliases:

• Interval as an alias of pd.Timedelta
• Sampling as an alias of pd.MultiIndex (with the restriction of the last level of it being a DatetimeIndex)
• EventSequence as an alias of pd.DataFrame

This PR updates the core.proto definition with latest changes discussed in today's sync.

Main changes:

• List of Features in main Processor object.
• Renamed some messages (EventSequence => Event, FeatureSequence => Feature, Timestamps => Sampling).
• Unified Input and Output into a single EventArgument used for both inputs and outputs.
• FeatureSequence and Feature unified into a single Feature, and can now be part of several events.

Final updated proto diagram:

Hi, I'm a Kaggler, and I find tf-decision-forests very useful. Thus I want to contribute tutorials to the library ! Are tutorials contributions being accepted ? If yes then tutorials on which topics are currently in wishlist?

Hi,

I have a decision tree with 20k nodes. How can I plot it?

I checked the d3.js code but with svg its pretty slow to render 20k nodes and use some zoom with it.

is there a way to generate a graphviz too and convert it to a huge png so I can view it with https://leafletjs.com/? or is there a way to draw the decision tree with d3 and canvas instead of svg?

Prediction with TFDF is extremely under documented.

According to https://www.tensorflow.org/decision_forests/api_docs/python/tfdf/keras/RandomForestModel#predict you should be able to predict on numpy arrays, tensors, or datasets. Yet any attempt to do so has failed. It seems PrefetchDatasets are the only option.

On top of this, prediction is dreadfully slow. My current use case is to do ensemble predictions of images. The images are 144k pixels which requires ~20 seconds for one model to make a prediction. Pixelwise predicts with normal TF can be near instantaneous with predict_on_batch which TFDF models are supposed to support. But PrefetchDatasets aren't compatible with it. So the answer is to use Numpy arrays. But that again is incompatible. All of this is said to be supported in the documentation but they appear unimplementable.

I would like to stick with the TFDF method for my work but it is unreasonable slow.

How can I implement faster prediction when it seems it's an under-documented area?