tensorflow_wrapper

Convert a trained TensorFlow/Keras model into a callable compatible with URANIE Relauncher.

uranie_evaluator(model_tf, outputkey=[])

Parameters:

Parameter	Type	Description
model_tf	tensorflow.keras.Model	A trained TensorFlow/Keras model. Must have been compiled with .compile() and optionally fitted using .fit() method (not required if weights are loaded).
outputkey	list	Optional list of keys or indices to select specific outputs from multi-output models. For tuple/list outputs, use integers (e.g., [0, 1]). For dict outputs, use strings (e.g., ["mean", "std"]). Default: [] (returns all outputs).

Returns:

Type	Description
callable or None	A Python callable that accepts *args (floats) and returns a 1-D list of floats. Returns None if the model is not trained or arguments are invalid.

Exceptions/Errors:

• Returns None and prints error message if model_tf is not a valid tensorflow.keras.Model

• Returns None and prints error message if model has not been trained

• Returns None and prints error message if outputkey is invalid

• Prints warning if multi-dimensional outputs are flattened

Examples

One-dimensional example:

import tensorflow as tf
from tensorflow.keras import layers

from uratools.tensorflow_wrapper import uranie_evaluator

# Create and compile model
model = tf.keras.Sequential([
    layers.Dense(64, activation='relu', input_shape=(20,)),
    layers.Dropout(0.2),
    layers.Dense(32, activation='relu'),
    layers.Dense(1)
])
model.compile(optimizer='adam', loss='mse')

# Generate dummy data and train
import numpy as np
X_train = np.random.randn(100, 20)
y_train = np.sum(X_train[:, :5], axis=1)
model.fit(X_train, y_train, epochs=10, verbose=0)

# Wrap for URANIE
wrapped = uranie_evaluator(model)

# Use with URANIE
X_test = np.random.randn(1, 20)
result = wrapped(*X_test[0])
print(result)  # [predicted_value]

Multi-dimensional example:

import numpy as np
import tensorflow as tf
from tensorflow.keras import layers, Model
from tensorflow.keras.layers import Input, Dense

from uratools.tensorflow_wrapper import uranie_evaluator

# Create multi-output model
inputs = Input(shape=(10,))
hidden = Dense(32, activation='relu')(inputs)
output1 = Dense(1, name='output1')(hidden)
output2 = Dense(1, name='output2')(hidden)

model = Model(inputs=inputs, outputs=[output1, output2])
model.compile(optimizer='adam', loss=['mse', 'mse'])

# Train
X_train = np.random.randn(50, 10)
y1_train = np.sum(X_train[:, :5], axis=1)
y2_train = np.prod(X_train[:, :3], axis=1)
model.fit(X_train, [y1_train, y2_train], epochs=5, verbose=0)

# Wrap for first output
wrapped_out1 = uranie_evaluator(model, outputkey=[0])

# Use with URANIE
X_test = np.random.randn(1, 10)
result = wrapped_out1(*X_test[0])
print(f"Output 1 prediction: {result[0]}")

Implementation Details

• Input conversion: Arguments are converted to a 1-row float32 numpy array before passing to the model.

• Output handling: Outputs are converted to Python lists. Multi-dimensional outputs are flattened.

• Training check: Model is considered trained if no optimizer is defined.

• Inference mode: Model runs in inference mode (no training statistics updated).

Supported Model Types

Works with any tf.keras.Model that has been compiled and optionally trained:

• tf.keras.Sequential

• tf.keras.Model (Functional API)

• tf.keras.layers.Dense, tf.keras.layers.Conv1D, tf.keras.layers.Conv2D, tf.keras.layers.Conv3D

• tf.keras.layers.LSTM, tf.keras.layers.GRU, tf.keras.layers.RNN

• tf.keras.layers.Embedding, tf.keras.layers.Attention

• Custom tf.keras.Model subclasses

• Pre-trained models from TensorFlow Hub

• Multi-output models (with outputkey parameter)

Supported Output Types

• Scalar outputs (int, float)

• 1-D arrays, tuples, and dictionaries

• Multi-dimensional tensors

• Using outputkey parameter for multi-output models