def build_classifier( numeric_dim: int, cat_vocab_sizes: dict, # {"country": 50, "device": 10} embedding_dim: int = 16, hidden_units: list = [256, 128], dropout_rate: float = 0.3, num_classes: int = 2, ) -> keras.Model: """Functional API model with numeric + categorical inputs."""

# Numeric input
numeric_input = keras.Input(shape=(numeric_dim,), name="numeric")
x_num = layers.BatchNormalization()(numeric_input)
x_num = layers.Dense(64, activation="relu")(x_num)

# Categorical inputs with embeddings
cat_inputs = []
cat_embeddings = []
for col, vocab_size in cat_vocab_sizes.items():
    inp = keras.Input(shape=(1,), dtype=tf.int32, name=col)
    emb = layers.Embedding(vocab_size + 1, embedding_dim, name=f"emb_{col}")(inp)
    emb = layers.Flatten()(emb)
    cat_inputs.append(inp)
    cat_embeddings.append(emb)

# Concatenate all features
all_inputs = cat_inputs + [numeric_input]
x = layers.Concatenate()([x_num] + cat_embeddings)

# Hidden layers
for units in hidden_units:
    x = layers.Dense(units)(x)
    x = layers.BatchNormalization()(x)
    x = layers.Activation("relu")(x)
    x = layers.Dropout(dropout_rate)(x)

output = layers.Dense(num_classes, activation="softmax", name="output")(x)

model = keras.Model(inputs=all_inputs, outputs=output, name="classifier")
return model

model = build_classifier(numeric_dim=20, cat_vocab_sizes={"country": 50, "device": 10}) model.compile( optimizer=keras.optimizers.AdamW(learning_rate=1e-3, weight_decay=1e-4), loss="sparse_categorical_crossentropy", metrics=["accuracy", keras.metrics.AUC(name="auc")], ) model.summary()


## Pattern 2: Optimized tf.data Pipeline

Correct order: map → cache → shuffle → batch → prefetch.

```python
import tensorflow as tf

AUTO = tf.data.AUTOTUNE

def parse_tfrecord(serialized: tf.Tensor) -> tuple:
    """Parse a TFRecord example."""
    feature_desc = {
        "image": tf.io.FixedLenFeature([], tf.string),
        "label": tf.io.FixedLenFeature([], tf.int64),
    }
    example = tf.io.parse_single_example(serialized, feature_desc)
    image = tf.image.decode_jpeg(example["image"], channels=3)
    image = tf.cast(image, tf.float32) / 255.0
    image = tf.image.resize(image, [224, 224])
    return image, example["label"]

@tf.function
def augment(image, label):
    image = tf.image.random_flip_left_right(image)
    image = tf.image.random_brightness(image, max_delta=0.1)
    image = tf.image.random_contrast(image, 0.8, 1.2)
    return image, label

def build_dataset(tfrecord_pattern: str, batch_size: int,
                  training: bool = True) -> tf.data.Dataset:
    files = tf.data.Dataset.list_files(tfrecord_pattern, shuffle=training)
    dataset = files.interleave(
        tf.data.TFRecordDataset,
        cycle_length=8,                   # read 8 files in parallel
        num_parallel_calls=AUTO,
    )

    dataset = dataset.map(parse_tfrecord, num_parallel_calls=AUTO)

    if training:
        dataset = dataset.map(augment, num_parallel_calls=AUTO)

    # CORRECT ORDER: cache after augmentation (if RAM permits), before shuffle
    # Omit cache() if dataset > available RAM
    # dataset = dataset.cache()

    if training:
        dataset = dataset.shuffle(buffer_size=10_000, reshuffle_each_iteration=True)

    dataset = dataset.batch(batch_size, drop_remainder=training)
    dataset = dataset.prefetch(AUTO)       # always last

    return dataset

train_ds = build_dataset("data/train-*.tfrecord", batch_size=64, training=True)
val_ds = build_dataset("data/val-*.tfrecord", batch_size=128, training=False)

Pattern 3: Custom Keras Layer and Loss

Custom attention layer and focal loss for imbalanced classification.

import tensorflow as tf
from tensorflow import keras

class SelfAttentionPooling(keras.layers.Layer):
    """Attention-weighted pooling over sequence dimension."""

    def __init__(self, units: int = 64, **kwargs):
        super().__init__(**kwargs)
        self.units = units

    def build(self, input_shape):
        self.W = self.add_weight(
            name="attention_W",
            shape=(input_shape[-1], self.units),
            initializer="glorot_uniform",
            trainable=True,
        )
        self.V = self.add_weight(
            name="attention_V",
            shape=(self.units, 1),
            initializer="glorot_uniform",
            trainable=True,
        )
        super().build(input_shape)

    def call(self, inputs, mask=None):
        # inputs: (batch, seq_len, features)
        score = tf.nn.tanh(tf.matmul(inputs, self.W))   # (batch, seq, units)
        score = tf.matmul(score, self.V)                  # (batch, seq, 1)
        if mask is not None:
            score += (1.0 - tf.cast(mask[:, :, tf.newaxis], tf.float32)) * -1e9
        weights = tf.nn.softmax(score, axis=1)            # (batch, seq, 1)
        return tf.reduce_sum(inputs * weights, axis=1)    # (batch, features)

    def get_config(self):
        return {**super().get_config(), "units": self.units}


class FocalLoss(keras.losses.Loss):
    """Focal loss for class imbalance (Lin et al. 2017)."""

    def __init__(self, gamma: float = 2.0, alpha: float = 0.25, **kwargs):
        super().__init__(**kwargs)
        self.gamma = gamma
        self.alpha = alpha

    def call(self, y_true, y_pred):
        y_pred = tf.clip_by_value(y_pred, 1e-7, 1 - 1e-7)
        cross_entropy = -y_true * tf.math.log(y_pred)
        p_t = tf.where(tf.equal(y_true, 1), y_pred, 1 - y_pred)
        focal_factor = (1 - p_t) ** self.gamma
        alpha_t = tf.where(tf.equal(y_true, 1), self.alpha, 1 - self.alpha)
        return tf.reduce_mean(alpha_t * focal_factor * cross_entropy)

Pattern 4: SavedModel Export with Serving Signature

Export model with explicit input/output signatures for TF Serving.

import tensorflow as tf

def export_saved_model(model: tf.keras.Model, export_path: str,
                        input_spec: dict):
    """Export with serving_default signature for TF Serving."""

    @tf.function(input_signature=[
        tf.TensorSpec(shape=[None, input_spec["numeric_dim"]],
                      dtype=tf.float32, name="numeric"),
    ])
    def serving_fn(numeric):
        outputs = model({"numeric": numeric}, training=False)
        probabilities = tf.nn.softmax(outputs, axis=-1)
        return {
            "probabilities": probabilities,
            "predicted_class": tf.argmax(probabilities, axis=-1),
        }

    tf.saved_model.save(
        model,
        export_path,
        signatures={"serving_default": serving_fn}
    )
    print(f"SavedModel exported to {export_path}")

    # Verify signature
    loaded = tf.saved_model.load(export_path)
    infer = loaded.signatures["serving_default"]
    print("Input keys:", list(infer.structured_input_signature[1].keys()))
    print("Output keys:", list(infer.structured_outputs.keys()))

export_saved_model(model, "models/classifier/1", {"numeric_dim": 20})

Pattern 5: TFLite Post-Training Quantization

Convert SavedModel to int8 TFLite with calibration.

import tensorflow as tf
import numpy as np

def quantize_to_tflite(saved_model_path: str, output_path: str,
                        calibration_data: np.ndarray) -> dict:
    """Full integer PTQ quantization with calibration dataset."""
    converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_path)

    # Enable optimizations (weights in int8)
    converter.optimizations = [tf.lite.Optimize.DEFAULT]

    # Full integer quantization: needs representative data for activation calibration
    def representative_dataset():
        for i in range(0, len(calibration_data), 32):
            batch = calibration_data[i:i+32].astype(np.float32)
            yield [batch]

    converter.representative_dataset = representative_dataset
    converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
    converter.inference_input_type = tf.int8
    converter.inference_output_type = tf.int8

    tflite_model = converter.convert()

    with open(output_path, "wb") as f:
        f.write(tflite_model)

    original_mb = sum(
        p.numpy().nbytes for p in tf.keras.models.load_model(saved_model_path).weights
    ) / 1e6
    quantized_mb = len(tflite_model) / 1e6

    return {
        "original_size_mb": round(original_mb, 2),
        "quantized_size_mb": round(quantized_mb, 2),
        "compression_ratio": round(original_mb / quantized_mb, 2),
    }

stats = quantize_to_tflite("models/classifier/1", "model_int8.tflite",
                             calibration_data=X_val[:500])
print(f"Compression: {stats['compression_ratio']}x ({stats['original_size_mb']}MB → {stats['quantized_size_mb']}MB)")

Anti-Patterns

Anti-Pattern 1: Wrong tf.data Order (cache After shuffle or batch)

.cache() after .shuffle() serves the same shuffled order every epoch. .cache() after .batch() caches batches, preventing re-batching with different sizes. Always: map → cache → shuffle → batch → prefetch.

Anti-Pattern 2: Using HDF5 (.h5) for Production Serving

HDF5 saves architecture + weights but not the computation graph. TF Serving cannot load H5 files. SavedModel format includes the computation graph, serving signatures, and custom layer code. Always export in SavedModel format for any serving use case.

Anti-Pattern 3: PTQ When Accuracy Loss is Unacceptable

Post-training quantization can cause 2-5% accuracy drop on sensitive tasks (medical imaging, NLP classification). If the task requires < 1% accuracy degradation, use quantization-aware training — it simulates quantization during training and learns weights that are robust to quantization noise.

Anti-Pattern 4: Setting num_parallel_calls to a Fixed Integer

num_parallel_calls=4 may over-subscribe on a 2-core machine or under-subscribe on a 32-core machine. Use tf.data.AUTOTUNE for all map and interleave calls — it adapts to available hardware at runtime.

tensorflow-patterns

TensorFlow Patterns

Pattern 1: Keras Functional API Model