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.
- Author
- G1Joshi ↗
- Repository
- Agent-Skills ↗
- Licence
- MIT
- Last repository change
- 01.10.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 1
No signals detected. Repository changed on 01.10.2026, without references to retired models or APIs.
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
- When to Use
- Quick Start
- Core Concepts
- Common Patterns
- Best Practices
- Troubleshooting
- References
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
| Repository | Score | Licence |
|---|---|---|
| This page · G1Joshi/Agent-Skills | 100 | MIT |
| TerminalSkills/skills | 100 | Apache-2.0 |
| dkbnull/hello-skill | 100 | MIT |
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.