Skip to content
Skills Library
Data & analytics · Building & coding

tensorflow

/tensorflow

Expert TensorFlow 2.x assistance covering tf.data pipelines, SavedModel serialization, TensorBoard, and multi-GPU distribution strategies. Use when building, training, and deploying production machine learning models.

Licence
MIT
Last repository change
01.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
1
Deprecation

No signals detected. Repository changed on 01.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Expert TensorFlow 2.x assistance covering tf.data pipelines, SavedModel serialization, TensorBoard, and multi-GPU distribution strategies. Use when building, training, and deploying production machine learning models.

Original author description

Expert TensorFlow 2.x assistance covering tf.data pipelines, SavedModel serialization, TensorBoard, and multi-GPU distribution strategies. Use when building, training, and deploying production machine learning models.

How it works

  1. When to Use
  2. Quick Start
  3. Core Concepts
  4. Common Patterns
  5. Best Practices
  6. Troubleshooting
  7. References
Original SKILL.md headings · 143 lines, 539 words
SKILL.md preview
---
name: tensorflow
description: Expert TensorFlow 2.x assistance covering tf.data pipelines, SavedModel serialization, TensorBoard, and multi-GPU distribution strategies. Use when building, training, and deploying production machine learning models.
---

# TensorFlow

TensorFlow is an end-to-end open-source machine learning platform with extensive production deployment tooling, Keras integrations, and mobile/embedded optimization via TensorFlow Lite.

## When to Use

- **Enterprise Production Machine Learning**: End-to-end model deployment with TensorFlow Serving and TFX.
- **Mobile & Embedded Edge Inference**: Compiling models to microcontrollers and mobile apps using TensorFlow Lite (TFLite).
- **High-Performance Data Pipelines with tf.data**: Prefetching, interleaving, and streaming terabyte-scale datasets.
- **Distributed Training Across GPU/TPU Pods**: Scaling multi-worker distributed training with `tf.distribute.MirroredStrategy`.

## Quick Start

```python
import tensorflow as tf

# Define sequential classification model
model = tf.keras.Sequential([
    tf.keras.layers.Dense(128, activation='relu', input_shape=(30,)),
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(2, activation='softmax')
])

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
```

## Core Concepts

### High-Throughput Input Pipelines with tf.data

Asynchronous data loading with prefetching and parallel mapping:

```python
import tensorflow as tf

def parse_image_sample(filename, label):
    image_raw = tf.io.read_file(filename)
    image = tf.io.decode_jpeg(image_raw, channels=3)
    image = tf.image.resize(image, [224, 224])
    image = tf.cast(image, tf.float32) / 255.0 # Normalize
    return image, label

def create_dataset(filenames, labels, batch_size=64):
    dataset = tf.data.Dataset.from_tensor_slices((filenames, labels))
    dataset = dataset.shuffle(buffer_size=1000)
    # Interleave and map in parallel across all CPU cores
    dataset = dataset.map(parse_image_sample, num_parallel_calls=tf.data.AUTOTUNE)
    dataset = dataset.batch(batch_size)
    # Prefetch batches to GPU memory while current batch trains
    dataset = dataset.prefetch(buffer_size=tf.data.AUTOTUNE)
    return dataset
```

### Functional Model & Multi-GPU Distribution

Training models across multiple GPUs with `MirroredStrategy`:

```python
strategy = tf.distribute.MirroredStrategy()
print(f"Number of distributed devices: {strategy.num_replicas_in_sync}")

with strategy.scope():
    inputs = tf.keras.Input(shape=(224, 224, 3))
    x = tf.keras.layers.Conv2D(32, 3, activation='relu', padding='same')(inputs)
    x = tf.keras.layers.MaxPooling2D()(x)
    x = tf.keras.layers.Conv2D(64, 3, activation='relu', padding='same')(x)
    x = tf.keras.layers.GlobalAveragePooling2D()(x)
    outputs = tf.keras.layers.Dense(10, activation='softmax')(x)

    model = tf.keras.Model(inputs=inputs, outputs=outputs)
    model.compile(
        optimizer=tf.keras.optimizers.Adam(learning_rate=1e-3),
        loss='sparse_categorical_crossentropy',
        metrics=['accuracy']
    )

# model.fit(train_dataset, epochs=10)
```

### Exporting to TensorFlow Lite (TFLite) with INT8 Quantization

Compressing models for mobile deployment:

```python
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]

# Convert model to quantized TFLite binary
tflite_model = converter.convert()

with open("model_quantized.tflite", "wb") as f:
    f.write(tflite_model)
print("Saved optimized TFLite model.")
```

## Common Patterns

### High-Throughput Input Pipelines with tf.data Prefetching

**Problem**: GPU stays idle waiting for CPU to read, decode, and batch training data.

**Solution**:
Use `tf.data.AUTOTUNE` prefetching:

```python
dataset = tf.data.Dataset.from_tensor_slices((X_train, y_train))
dataset = (
    dataset.shuffle(buffer_size=10000)
    .batch(64)
    .prefetch(buffer_size=tf.data.AUTOTUNE) # Overlaps preprocessing with GPU compute
)

model.fit(dataset, epochs=10)
```

## Best Practices

**Do**:

- Always use `num_parallel_calls=tf.data.AUTOTUNE` and `.prefetch(tf.data.AUTOTUNE)` in input pipelines.
- Use `tf.distribute.MirroredStrategy` for seamless single-node multi-GPU data parallelism.
- Wrap heavy computation inside `@tf.function` to compile graphs via AutoGraph for C++ execution speeds.
- Save models in the modern `SavedModel` or `.keras` format rather than legacy checkpoint files.

**Don't**:

- Use Python operations inside `@tf.function`; use `tf.*` operations to ensure clean graph tracing.
- Execute feed-dict or session APIs; legacy TensorFlow 1.x patterns are completely deprecated.
- Train on CPU when GPU/TPU acceleration is available; verify devices with `tf.config.list_physical_devices('GPU')`.

## Troubleshooting

| Error                                                | Cause                                                       | Solution                                                                                             |
| :--------------------------------------------------- | :---------------------------------------------------------- | :--------------------------------------------------------------------------------------------------- |
| `ResourceExhaustedError: OOM when allocating tensor` | Batch size or model weights exceed GPU VRAM.                | Reduce batch size or configure memory growth: `tf.config.experimental.set_memory_growth(gpu, True)`. |
| `TensorFlow not detecting GPU`                       | Missing CUDA/cuDNN driver libraries in system library path. | Check detected devices via `tf.config.list_physical_devices('GPU')`.                                 |
| `Graph execution error: Incompatible shapes`         | Input tensor shape mismatch in first model layer.           | Verify input batch dimension matches `input_shape`.                                                  |

## References

- [TensorFlow Documentation](https://www.tensorflow.org/)

Versions

RepositoryScoreLicence
This page · G1Joshi/Agent-Skills100MIT
TerminalSkills/skills100Apache-2.0
dkbnull/hello-skill100MIT

Database snapshot: 13.11.2026 · package version 721cd30a42ac (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100tensorflow-savedmodel-creator
    Create tensorflow savedmodel creator operations. Auto-activating skill for ML Deployment. Triggers on: tensorflow savedmodel creator, tensorflow savedmodel creator Part of the ML Deployment skill category. Use when working with tensorflow savedmodel creator functionality.…
  • 100tensorflow-model-trainer
    Build tensorflow model trainer operations. Auto-activating skill for ML Training. Triggers on: tensorflow model trainer, tensorflow model trainer Part of the ML Training skill category. Use when working with tensorflow model trainer functionality. Trigger with phrases like…
  • 100tensorflow-deep-learning
    Best practices for building, training, evaluating, and deploying neural networks with TensorFlow and Keras. Use when writing tf.data input pipelines, defining or training a Keras model, configuring callbacks for checkpointing and early stopping, evaluating a trained model, or…
  • 100keras
    Expert Keras 3 assistance covering multi-backend execution (JAX, PyTorch, TensorFlow), Sequential/Functional APIs, and custom training loops. Use when building deep learning models with clean, modular Python abstractions.
  • 95ray-data
    Scalable data processing for ML workloads. Streaming execution across CPU/GPU, supports Parquet/CSV/JSON/images. Integrates with Ray Train, PyTorch, TensorFlow. Scales from single machine to 100s of nodes. Use for batch inference, data preprocessing, multi-modal data loading, or…
  • 100ml-engineer
    Build production ML systems with PyTorch 2.x, TensorFlow, and modern ML frameworks. Implements model serving, feature engineering, A/B testing, and monitoring. Use for ML model deployment, inference optimization, or production ML infrastructure.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.