# `tensorflow_wrapper`

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

```python
uranie_evaluator(model_tf, outputkey=[])
```

**Parameters:**

```{list-table}
:header-rows: 1
:widths: 18 20 62

* - 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:**

```python
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:**

```python
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