Build and Optimize TensorFlow Models

This is a TensorFlow/Keras model-building skill covering architecture design, training configuration, data pipelines, model optimization for inference, and performance monitoring. It builds models with Keras's functional API, including preprocessing layers as part of the model graph itself (Normalization, input Dropout) followed by dense layers with he_normal initialization, L2 regularization, batch normalization, and progressively reduced dropout. Training uses the AdamW optimizer with explicit weight decay, and a comprehensive callback stack ties learning-rate scheduling, early stopping, and checkpointing together:

### Comprehensive callback setup
callbacks = [
    # Learning rate scheduling
    keras.callbacks.ReduceLROnPlateau(
        monitor='val_loss',
        factor=0.5,
        patience=5,
        min_lr=1e-7,
        verbose=1
    ),
    
    # Early stopping
    keras.callbacks.EarlyStopping(
        monitor='val_loss',
        patience=10,
        restore_best_weights=True,
        verbose=1
    ),
    
    # Model checkpointing
    keras.callbacks.ModelCheckpoint(
        filepath='best_model.h5',
        monitor='val_accuracy',
        save_best_only=True,
        save_weights_only=False,
        verbose=1
    ),
    
    # TensorBoard logging
    keras.callbacks.TensorBoard(
        log_dir='./logs',
        histogram_freq=1,
        write_graph=True,
        update_freq='epoch'
    )
]

Use this skill when building, training, or optimizing a TensorFlow/Keras model end-to-end - it covers a custom @tf.function-decorated training step with gradient clipping, an efficient tf.data pipeline (interleaved TFRecord parsing, shuffle/batch/prefetch all tuned with tf.data.AUTOTUNE, plus @tf.function-decorated image augmentation), and post-training INT8 quantization via TFLiteConverter with a representative dataset, alongside SavedModel export with an explicit serving signature. It also defines a custom F1Score metric combining Precision and Recall, recommends GPU memory-growth configuration and the TensorFlow Profiler for diagnosing bottlenecks, and calls for validating on held-out test sets, cross-validation on small datasets, mixed-precision training for larger models, and a gradual learning-rate warm-up for stable convergence. It is not a from-scratch deep-learning-theory skill - it assumes familiarity with neural network concepts and focuses on TensorFlow/Keras-specific implementation and deployment practices, so it isn't the right fit for other frameworks like PyTorch.

Input is training and validation datasets, typically as TFRecord files, plus a target architecture and task such as classification; output is a trained Keras Model, training history and metrics via callbacks and TensorBoard logs, a quantized TFLite model sized and typed for INT8 inference, and a SavedModel export ready to serve via a defined signature. Custom metrics like F1 score, gradient-clipped training steps, and learning-rate reduction on plateau are all wired into the same training loop.

Built entirely on TensorFlow and Keras (tf.data, tf.function, tf.GradientTape, keras.callbacks, keras.metrics), with tf.lite.TFLiteConverter for on-device deployment and tf.saved_model for serving infrastructure; monitoring integrates with TensorBoard and the TensorFlow Profiler.

ML engineers building and deploying TensorFlow/Keras models who want architecture, training-loop, data-pipeline, and deployment (quantization and serving) patterns handled consistently, rather than assembling each stage from scratch per project.