@wentorai/research-plugins 1.0.0 → 1.2.0

package/skills/domains/ai-ml/generative-ai-guide/SKILL.md

@@ -0,0 +1,146 @@
+---
+name: generative-ai-guide
+description: "Curated guide to generative AI covering LLMs and diffusion models"
+version: 1.0.0
+author: wentor-community
+source: https://github.com/aishwaryanr/awesome-generative-ai-guide
+metadata:
+  openclaw:
+    category: "domains"
+    subcategory: "ai-ml"
+    keywords:
+      - generative-ai
+      - large-language-models
+      - diffusion-models
+      - transformers
+      - prompt-engineering
+      - ai-research
+---
+
+# Generative AI Guide
+
+A skill providing a comprehensive, curated guide to generative AI research and practice, covering large language models (LLMs), diffusion models, transformer architectures, prompt engineering, and evaluation methodologies. Based on the awesome-generative-ai-guide repository (25K stars), this skill equips researchers with structured knowledge of the rapidly evolving generative AI landscape.
+
+## Overview
+
+Generative AI has become one of the most active areas of research across computer science, with implications spanning natural language processing, computer vision, audio synthesis, code generation, scientific discovery, and creative applications. The pace of development makes it challenging for researchers to maintain a current understanding of the field. This skill provides a structured map of the generative AI landscape, organized by topic and application area, with guidance on key papers, methods, and practical considerations.
+
+Whether you are an AI researcher staying current with the field, a domain scientist exploring how generative AI can accelerate your work, or a student entering the field, this skill provides the orientation and resources needed to navigate the space effectively.
+
+## Large Language Models
+
+**Architecture Foundations**
+- Transformer architecture: self-attention mechanism, positional encoding, layer normalization
+- Scaling laws: the relationship between model size, data, compute, and performance
+- Training objectives: causal language modeling, masked language modeling, instruction tuning
+- Context windows: evolution from 512 tokens to 100K+ tokens and associated techniques
+- Mixture of Experts (MoE): sparse activation for efficient scaling
+
+**Key Model Families**
+- GPT series (OpenAI): decoder-only architecture, scaling-driven approach
+- Claude series (Anthropic): emphasis on safety, instruction following, and long context
+- Llama series (Meta): open-weight models enabling community research
+- Gemini series (Google): multimodal from the ground up
+- Open-source ecosystem: Mistral, Qwen, DeepSeek, and community fine-tunes
+
+**Training Pipeline**
+- Pre-training: large-scale unsupervised learning on web-scale text corpora
+- Supervised fine-tuning (SFT): training on high-quality instruction-response pairs
+- Reinforcement learning from human feedback (RLHF): aligning outputs with human preferences
+- Direct preference optimization (DPO): simplified alignment without reward models
+- Constitutional AI: self-improvement using principle-based critique
+
+**Inference Optimization**
+- Quantization: reducing model precision (FP16, INT8, INT4) for faster inference
+- KV-cache optimization: efficient memory management for long sequences
+- Speculative decoding: using small models to draft and large models to verify
+- Batching strategies: continuous batching for throughput optimization
+- Serving frameworks: vLLM, TGI, and other high-performance inference engines
+
+## Diffusion Models
+
+**Core Concepts**
+- Forward process: gradually adding noise to data until reaching pure noise
+- Reverse process: learning to denoise step by step to generate new data
+- Score matching: estimating the gradient of the data distribution
+- Classifier-free guidance: controlling generation fidelity and diversity
+- Latent diffusion: operating in compressed latent space for efficiency
+
+**Key Architectures**
+- DDPM (Denoising Diffusion Probabilistic Models): foundational formulation
+- Stable Diffusion: latent space diffusion with text conditioning
+- DALL-E series: text-to-image generation with CLIP-based conditioning
+- Imagen: text-to-image with cascaded diffusion models
+- Video diffusion models: extending to temporal generation
+
+**Applications in Research**
+- Molecular generation: designing new drug candidates and materials
+- Protein structure prediction: generating plausible protein conformations
+- Scientific data augmentation: creating synthetic training data
+- Image restoration: denoising, super-resolution, inpainting for microscopy
+- Simulation acceleration: approximating expensive physical simulations
+
+## Prompt Engineering
+
+**Fundamental Techniques**
+- Zero-shot prompting: direct instruction without examples
+- Few-shot prompting: providing examples to establish the desired pattern
+- Chain-of-thought (CoT): requesting step-by-step reasoning
+- Self-consistency: sampling multiple reasoning chains and selecting the majority
+- Tree of thought: exploring multiple reasoning branches systematically
+
+**Advanced Strategies**
+- ReAct (Reasoning + Acting): interleaving reasoning with tool use
+- Retrieval-augmented generation (RAG): grounding responses in retrieved documents
+- Program-aided language models: generating and executing code for precise computation
+- Structured output: constraining generation to valid JSON, XML, or other formats
+- Multi-agent prompting: orchestrating multiple LLM instances for complex tasks
+
+**Research-Specific Prompting**
+- Literature synthesis: prompting for balanced integration of multiple sources
+- Hypothesis generation: structured prompts for creative scientific reasoning
+- Code debugging: providing error context and asking for systematic diagnosis
+- Data analysis: chaining prompts through exploratory analysis to interpretation
+- Writing assistance: iterative refinement prompts that preserve the author's voice
+
+## Evaluation and Benchmarks
+
+**Language Model Evaluation**
+- Perplexity: intrinsic measure of model quality on held-out text
+- MMLU: massive multi-task language understanding across 57 subjects
+- HumanEval: code generation benchmark with function completion tasks
+- MT-Bench: multi-turn conversation quality assessment
+- Arena Elo: head-to-head comparison ratings from human preferences
+
+**Generation Quality Metrics**
+- FID (Frechet Inception Distance): image generation quality and diversity
+- CLIP score: text-image alignment for conditional generation
+- BLEU, ROUGE: text generation overlap metrics (limited but widely used)
+- Human evaluation: gold standard requiring careful protocol design
+- Calibration: measuring whether model confidence matches actual accuracy
+
+**Safety and Alignment Evaluation**
+- Red-teaming: adversarial testing for harmful outputs
+- Bias benchmarks: measuring demographic and cultural biases
+- Hallucination detection: identifying fabricated facts in generated text
+- Instruction following: measuring compliance with complex multi-step instructions
+- Robustness testing: evaluating consistency under paraphrased inputs
+
+## Integration with Research-Claw
+
+This skill provides the Research-Claw agent with generative AI domain expertise:
+
+- Help researchers understand and apply generative AI techniques to their domain
+- Guide model selection based on task requirements and resource constraints
+- Assist with prompt engineering for research-specific applications
+- Connect with analysis skills for evaluating generative model outputs
+- Support writing skills with knowledge of the latest developments for literature reviews
+
+## Best Practices
+
+- Stay current by monitoring key conferences (NeurIPS, ICML, ICLR, ACL, CVPR) and arXiv
+- Distinguish between benchmark performance and real-world applicability
+- Consider computational costs and environmental impact when selecting models
+- Evaluate models on your specific task rather than relying solely on leaderboard rankings
+- Document prompt strategies and model versions for reproducibility
+- Be aware of the limitations: hallucination, bias, and sensitivity to prompt phrasing

package/skills/domains/ai-ml/graph-learning-papers-guide/SKILL.md

@@ -0,0 +1,125 @@
+---
+name: graph-learning-papers-guide
+description: "Conference papers on graph neural networks and graph learning"
+metadata:
+  openclaw:
+    emoji: "📊"
+    category: "domains"
+    subcategory: "ai-ml"
+    keywords: ["graph neural network", "GNN", "graph learning", "graph transformer", "message passing", "node classification"]
+    source: "https://github.com/doujiang-zheng/Awesome-Graph-Learning-Papers-List"
+---
+
+# Graph Learning Papers Guide
+
+## Overview
+
+A curated list of graph learning papers from top AI/ML conferences (NeurIPS, ICML, ICLR, KDD, WWW, AAAI). Covers graph neural networks, graph transformers, spectral methods, message passing, and applications in molecular science, social networks, and recommendation systems. Organized by venue, year, and topic for systematic tracking.
+
+## Topic Taxonomy
+
+```
+Graph Learning
+├── Graph Neural Networks
+│   ├── Message Passing (GCN, GAT, GraphSAGE, GIN)
+│   ├── Spectral (ChebNet, CayleyNet)
+│   ├── Graph Transformers (Graphormer, GPS)
+│   └── Equivariant GNNs (EGNN, SE(3)-Transformers)
+├── Graph Generation
+│   ├── VAE-based (GraphVAE)
+│   ├── Autoregressive (GraphRNN)
+│   ├── Diffusion (GDSS, DiGress)
+│   └── Flow-based (GraphFlow)
+├── Self-supervised Learning
+│   ├── Contrastive (GraphCL, GCA)
+│   ├── Generative (GraphMAE)
+│   └── Predictive (GPT-GNN)
+├── Scalability
+│   ├── Sampling (GraphSAINT, ClusterGCN)
+│   ├── Knowledge distillation
+│   └── Graph condensation
+├── Temporal Graphs
+│   ├── Dynamic GNNs
+│   ├── Temporal interaction
+│   └── Evolving graphs
+└── Applications
+    ├── Molecular property prediction
+    ├── Drug discovery
+    ├── Social network analysis
+    ├── Recommendation systems
+    └── Traffic forecasting
+```
+
+## Key Models
+
+| Model | Year | Innovation |
+|-------|------|-----------|
+| **GCN** | 2017 | Spectral convolution simplified |
+| **GraphSAGE** | 2017 | Inductive with sampling |
+| **GAT** | 2018 | Attention over neighbors |
+| **GIN** | 2019 | WL-test as powerful as possible |
+| **Graphormer** | 2021 | Transformer on graphs |
+| **GPS** | 2022 | General, powerful, scalable recipe |
+| **GraphMAE** | 2022 | Masked autoencoding on graphs |
+
+## Paper Search
+
+```python
+import arxiv
+
+def find_gnn_papers(topic="graph neural network", max_results=20):
+    """Find recent GNN papers."""
+    search = arxiv.Search(
+        query=f"abs:{topic}",
+        max_results=max_results,
+        sort_by=arxiv.SortCriterion.SubmittedDate,
+    )
+
+    for r in search.results():
+        print(f"[{r.published.strftime('%Y-%m-%d')}] {r.title}")
+
+find_gnn_papers("graph transformer")
+find_gnn_papers("molecular graph generation")
+```
+
+## Benchmark Datasets
+
+```python
+datasets = {
+    "Node Classification": {
+        "Cora": "Citation network, 7 classes",
+        "PubMed": "Medical citation, 3 classes",
+        "ogbn-arxiv": "arXiv papers, 40 classes",
+        "ogbn-papers100M": "100M papers (large-scale)",
+    },
+    "Graph Classification": {
+        "ZINC": "Molecular graphs, regression",
+        "ogbg-molpcba": "128 molecular tasks",
+        "PROTEINS": "Protein function prediction",
+    },
+    "Link Prediction": {
+        "ogbl-collab": "Author collaborations",
+        "ogbl-citation2": "Citation prediction",
+    },
+}
+
+for task, ds in datasets.items():
+    print(f"\n{task}:")
+    for name, desc in ds.items():
+        print(f"  {name}: {desc}")
+```
+
+## Use Cases
+
+1. **Literature survey**: Track GNN research across top venues
+2. **Method comparison**: Compare GNN architectures and results
+3. **Research planning**: Identify trends and open problems
+4. **Course preparation**: Curate reading lists for GNN courses
+5. **Benchmark tracking**: Monitor SOTA on OGB leaderboards
+
+## References
+
+- [Awesome-Graph-Learning-Papers-List](https://github.com/doujiang-zheng/Awesome-Graph-Learning-Papers-List)
+- [Open Graph Benchmark](https://ogb.stanford.edu/)
+- [PyG (PyTorch Geometric)](https://pyg.org/)
+- [DGL (Deep Graph Library)](https://www.dgl.ai/)

package/skills/domains/ai-ml/huggingface-inference-guide/SKILL.md

@@ -0,0 +1,196 @@
+---
+name: huggingface-inference-guide
+description: "Run NLP and CV model inference via Hugging Face free-tier API"
+metadata:
+  openclaw:
+    emoji: "🤗"
+    category: "domains"
+    subcategory: "ai-ml"
+    keywords: ["huggingface", "inference", "nlp", "machine-learning", "transformers", "models"]
+    source: "https://huggingface.co/docs/api-inference/index"
+---
+
+# Hugging Face Inference API Guide
+
+## Overview
+
+The Hugging Face Inference API provides instant access to thousands of pre-trained machine learning models for natural language processing, computer vision, audio processing, and multimodal tasks. Researchers can run inference on state-of-the-art models without managing infrastructure, GPU resources, or complex deployment pipelines.
+
+The API hosts models from the Hugging Face Hub, which contains over 500,000 models contributed by the research community. This includes transformer models for text classification, named entity recognition, summarization, translation, question answering, text generation, and image classification. For academic researchers, the Inference API is invaluable for rapid prototyping, benchmark evaluation, and integrating ML capabilities into research workflows without dedicated compute resources.
+
+The free tier provides access to a broad selection of models with rate limits suitable for development and small-scale research. An API token is required for authentication, available for free at huggingface.co.
+
+## Authentication
+
+A free Hugging Face API token is required. Create an account and generate a token at https://huggingface.co/settings/tokens.
+
+Store your token securely in an environment variable:
+
+```bash
+export HF_API_TOKEN=$HF_API_TOKEN
+```
+
+```bash
+curl -X POST "https://api-inference.huggingface.co/models/bert-base-uncased" \
+  -H "Authorization: Bearer $HF_API_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"inputs": "The goal of life is [MASK]."}'
+```
+
+## Core Endpoints
+
+### Text Classification (Sentiment Analysis)
+
+```
+POST https://api-inference.huggingface.co/models/{model_id}
+```
+
+```bash
+curl -s -X POST \
+  "https://api-inference.huggingface.co/models/distilbert-base-uncased-finetuned-sst-2-english" \
+  -H "Authorization: Bearer $HF_API_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"inputs": "This research methodology provides robust and reproducible results."}' \
+  | python3 -m json.tool
+```
+
+### Named Entity Recognition
+
+```bash
+curl -s -X POST \
+  "https://api-inference.huggingface.co/models/dslim/bert-base-NER" \
+  -H "Authorization: Bearer $HF_API_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"inputs": "Dr. Marie Curie conducted research at the University of Paris on radioactivity."}' \
+  | python3 -m json.tool
+```
+
+### Text Summarization
+
+```bash
+curl -s -X POST \
+  "https://api-inference.huggingface.co/models/facebook/bart-large-cnn" \
+  -H "Authorization: Bearer $HF_API_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "inputs": "The study of quantum computing has seen tremendous advances in the past decade. Researchers have demonstrated quantum supremacy with processors containing over 100 qubits. Error correction remains a significant challenge, but recent breakthroughs in topological qubits and surface codes suggest viable paths forward. Applications in drug discovery, materials science, and cryptography are expected to be among the first practical use cases.",
+    "parameters": {"max_length": 80, "min_length": 30}
+  }' | python3 -m json.tool
+```
+
+### Zero-Shot Classification
+
+Classify text into arbitrary categories without fine-tuning.
+
+```bash
+curl -s -X POST \
+  "https://api-inference.huggingface.co/models/facebook/bart-large-mnli" \
+  -H "Authorization: Bearer $HF_API_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "inputs": "New CRISPR technique enables precise gene editing in human stem cells",
+    "parameters": {"candidate_labels": ["biology", "computer science", "physics", "economics"]}
+  }' | python3 -m json.tool
+```
+
+### Python Example: Batch Sentiment Analysis of Paper Abstracts
+
+```python
+import requests
+import os
+import time
+
+API_URL = "https://api-inference.huggingface.co/models/distilbert-base-uncased-finetuned-sst-2-english"
+HEADERS = {"Authorization": f"Bearer {os.environ['HF_API_TOKEN']}"}
+
+def classify_sentiment(texts):
+    """Classify sentiment for a batch of texts."""
+    response = requests.post(API_URL, headers=HEADERS, json={"inputs": texts})
+    if response.status_code == 503:
+        # Model is loading, wait and retry
+        wait_time = response.json().get("estimated_time", 20)
+        print(f"Model loading, waiting {wait_time:.0f}s...")
+        time.sleep(wait_time)
+        response = requests.post(API_URL, headers=HEADERS, json={"inputs": texts})
+    response.raise_for_status()
+    return response.json()
+
+abstracts = [
+    "Our results demonstrate a significant improvement over baseline methods.",
+    "The proposed approach failed to achieve meaningful gains on the benchmark.",
+    "We present preliminary findings that warrant further investigation.",
+]
+
+results = classify_sentiment(abstracts)
+for abstract, result in zip(abstracts, results):
+    top = max(result, key=lambda x: x["score"])
+    print(f"Sentiment: {top['label']} ({top['score']:.3f})")
+    print(f"  Text: {abstract[:80]}...")
+    print()
+```
+
+### Python Example: Research Paper Topic Classification
+
+```python
+import requests
+import os
+
+ZSC_URL = "https://api-inference.huggingface.co/models/facebook/bart-large-mnli"
+HEADERS = {"Authorization": f"Bearer {os.environ['HF_API_TOKEN']}"}
+
+def classify_paper(abstract, categories):
+    """Classify a paper abstract into research categories."""
+    payload = {
+        "inputs": abstract,
+        "parameters": {"candidate_labels": categories}
+    }
+    resp = requests.post(ZSC_URL, headers=HEADERS, json=payload)
+    resp.raise_for_status()
+    return resp.json()
+
+categories = [
+    "machine learning",
+    "computational biology",
+    "natural language processing",
+    "computer vision",
+    "reinforcement learning",
+    "quantum computing"
+]
+
+abstract = "We propose a novel transformer architecture for protein structure prediction that achieves state-of-the-art results on CASP benchmarks."
+result = classify_paper(abstract, categories)
+
+print("Topic classification:")
+for label, score in zip(result["labels"], result["scores"]):
+    bar = "#" * int(score * 40)
+    print(f"  {label:<30} {score:.3f} {bar}")
+```
+
+## Common Research Patterns
+
+**Literature Screening:** Use zero-shot classification to automatically categorize and filter large collections of paper abstracts by research topic, methodology, or relevance to a specific research question.
+
+**Sentiment and Stance Detection:** Analyze the tone and conclusions of research papers, review comments, or social media discussions about scientific topics using sentiment analysis models.
+
+**Named Entity Extraction:** Extract researcher names, institutions, chemical compounds, gene names, and other domain-specific entities from unstructured text in papers and reports.
+
+**Automated Summarization:** Generate concise summaries of lengthy research papers or grant proposals to accelerate literature review workflows.
+
+**Multilingual Research:** Use translation and multilingual models to access and analyze research published in languages other than English.
+
+## Rate Limits and Best Practices
+
+- **Free tier:** Rate-limited; approximately 1,000 requests per day depending on model and load
+- **Model loading:** Cold models may take 20-60 seconds to load; handle 503 responses with retry logic
+- **Batch inputs:** Send multiple texts as an array in a single request to improve throughput
+- **Model selection:** Use distilled or smaller variants (e.g., `distilbert` instead of `bert-large`) for faster inference
+- **Timeouts:** Set request timeouts to 60+ seconds for large models or first requests after cold start
+- **Caching:** Cache inference results for identical inputs to avoid redundant API calls
+- **Pro tier:** For production workloads, consider the Inference Endpoints or Pro subscription for dedicated resources
+
+## References
+
+- Hugging Face Inference API Documentation: https://huggingface.co/docs/api-inference/index
+- Hugging Face Model Hub: https://huggingface.co/models
+- Hugging Face API Token Settings: https://huggingface.co/settings/tokens
+- Hugging Face Tasks Overview: https://huggingface.co/tasks

package/skills/domains/ai-ml/keras-deep-learning/SKILL.md

@@ -0,0 +1,210 @@
+---
+name: keras-deep-learning
+description: "Build and debug deep learning models with Keras and TensorFlow backend"
+metadata:
+  openclaw:
+    emoji: "🔬"
+    category: "domains"
+    subcategory: "ai-ml"
+    keywords: ["Keras", "deep learning", "neural network", "model training", "TensorFlow", "classification"]
+    source: "https://github.com/fchollet/deep-learning-with-python-notebooks"
+---
+
+# Keras Deep Learning Guide
+
+## Overview
+
+Keras is the high-level deep learning API that ships as part of TensorFlow 2.x and is the recommended interface for building, training, and deploying neural networks. Its Sequential and Functional APIs provide a progressive disclosure of complexity: beginners can stack layers in minutes, while researchers can build arbitrary DAG architectures, custom training loops, and multi-output models with the same framework.
+
+This guide covers practical patterns for academic research with Keras, from image classification and sequence modeling to custom loss functions and experiment reproducibility. The focus is on patterns that appear repeatedly in published work -- data loading pipelines, callback orchestration, hyperparameter search, and model introspection -- rather than toy examples.
+
+Keras is particularly strong in rapid prototyping for research papers. Its integration with TensorBoard, Weights & Biases, and tf.data pipelines makes it straightforward to go from idea to reproducible experiment to publication-quality results.
+
+## Model Architecture Patterns
+
+### Sequential API for Standard Architectures
+
+```python
+import tensorflow as tf
+from tensorflow import keras
+from tensorflow.keras import layers
+
+# Image classification baseline
+model = keras.Sequential([
+    layers.Input(shape=(224, 224, 3)),
+    layers.Rescaling(1.0 / 255),
+    layers.Conv2D(32, 3, activation="relu", padding="same"),
+    layers.BatchNormalization(),
+    layers.MaxPooling2D(2),
+    layers.Conv2D(64, 3, activation="relu", padding="same"),
+    layers.BatchNormalization(),
+    layers.MaxPooling2D(2),
+    layers.Conv2D(128, 3, activation="relu", padding="same"),
+    layers.GlobalAveragePooling2D(),
+    layers.Dropout(0.3),
+    layers.Dense(256, activation="relu"),
+    layers.Dense(10, activation="softmax"),
+])
+
+model.compile(
+    optimizer=keras.optimizers.AdamW(learning_rate=1e-3, weight_decay=1e-4),
+    loss="sparse_categorical_crossentropy",
+    metrics=["accuracy"],
+)
+```
+
+### Functional API for Multi-Input/Multi-Output Models
+
+```python
+# Multi-input model for multimodal research
+image_input = keras.Input(shape=(224, 224, 3), name="image")
+text_input = keras.Input(shape=(128,), dtype="int32", name="text")
+
+# Image branch
+x_img = keras.applications.EfficientNetV2B0(
+    include_top=False, weights="imagenet", input_tensor=image_input
+).output
+x_img = layers.GlobalAveragePooling2D()(x_img)
+
+# Text branch
+x_txt = layers.Embedding(10000, 128)(text_input)
+x_txt = layers.Bidirectional(layers.LSTM(64))(x_txt)
+
+# Merge
+merged = layers.Concatenate()([x_img, x_txt])
+merged = layers.Dense(256, activation="relu")(merged)
+merged = layers.Dropout(0.4)(merged)
+output = layers.Dense(5, activation="softmax", name="classification")(merged)
+
+model = keras.Model(inputs=[image_input, text_input], outputs=output)
+```
+
+## Data Pipeline with tf.data
+
+Efficient data loading is critical for GPU utilization in research experiments:
+
+```python
+def build_dataset(file_pattern, batch_size=32, training=True):
+    """Build a tf.data pipeline with augmentation for research experiments."""
+    dataset = tf.data.Dataset.list_files(file_pattern, shuffle=training)
+
+    def parse_image(path):
+        img = tf.io.read_file(path)
+        img = tf.image.decode_jpeg(img, channels=3)
+        img = tf.image.resize(img, [256, 256])
+        label = tf.strings.split(path, os.sep)[-2]
+        return img, label
+
+    dataset = dataset.map(parse_image, num_parallel_calls=tf.data.AUTOTUNE)
+
+    if training:
+        dataset = dataset.shuffle(1000)
+        dataset = dataset.map(
+            lambda x, y: (tf.image.random_flip_left_right(x), y),
+            num_parallel_calls=tf.data.AUTOTUNE,
+        )
+
+    dataset = dataset.batch(batch_size)
+    dataset = dataset.prefetch(tf.data.AUTOTUNE)
+    return dataset
+```
+
+## Training and Callback Orchestration
+
+### Reproducible Training Setup
+
+```python
+import os
+import random
+import numpy as np
+
+def set_seed(seed=42):
+    """Ensure reproducibility across runs for paper results."""
+    os.environ["PYTHONHASHSEED"] = str(seed)
+    random.seed(seed)
+    np.random.seed(seed)
+    tf.random.set_seed(seed)
+
+set_seed(42)
+
+callbacks = [
+    keras.callbacks.ModelCheckpoint(
+        "best_model.keras", monitor="val_loss", save_best_only=True
+    ),
+    keras.callbacks.EarlyStopping(
+        monitor="val_loss", patience=10, restore_best_weights=True
+    ),
+    keras.callbacks.ReduceLROnPlateau(
+        monitor="val_loss", factor=0.5, patience=5, min_lr=1e-6
+    ),
+    keras.callbacks.TensorBoard(log_dir="./logs", histogram_freq=1),
+    keras.callbacks.CSVLogger("training_log.csv"),
+]
+
+history = model.fit(
+    train_dataset,
+    validation_data=val_dataset,
+    epochs=100,
+    callbacks=callbacks,
+)
+```
+
+### Custom Training Loop for Research
+
+```python
+@tf.function
+def train_step(model, optimizer, x, y, loss_fn):
+    with tf.GradientTape() as tape:
+        predictions = model(x, training=True)
+        loss = loss_fn(y, predictions)
+    gradients = tape.gradient(loss, model.trainable_variables)
+    optimizer.apply_gradients(zip(gradients, model.trainable_variables))
+    return loss
+
+# Custom metric tracking
+train_loss = keras.metrics.Mean(name="train_loss")
+for epoch in range(num_epochs):
+    train_loss.reset_state()
+    for x_batch, y_batch in train_dataset:
+        loss = train_step(model, optimizer, x_batch, y_batch, loss_fn)
+        train_loss.update_state(loss)
+    print(f"Epoch {epoch+1}, Loss: {train_loss.result():.4f}")
+```
+
+## Debugging and Common Pitfalls
+
+| Issue | Symptom | Solution |
+|-------|---------|----------|
+| Exploding gradients | Loss becomes NaN | Add gradient clipping, reduce learning rate |
+| Overfitting | Val loss diverges from train loss | Add Dropout, data augmentation, weight decay |
+| Underfitting | Both losses plateau high | Increase model capacity, reduce regularization |
+| Slow training | Low GPU utilization | Use tf.data with prefetch, increase batch size |
+| Memory errors | OOM on GPU | Reduce batch size, use mixed precision |
+| Non-deterministic results | Different results per run | Call `set_seed()`, set `TF_DETERMINISTIC_OPS=1` |
+
+### Mixed Precision Training
+
+```python
+# Enable mixed precision for 2x speedup on modern GPUs
+keras.mixed_precision.set_global_policy("mixed_float16")
+
+# Ensure the output layer uses float32 for numerical stability
+output = layers.Dense(10, activation="softmax", dtype="float32")(x)
+```
+
+## Best Practices for Research
+
+- **Version pin everything.** Record `tensorflow`, `keras`, `numpy`, and `cuda` versions in your paper appendix.
+- **Use `keras.utils.set_random_seed(42)`** for full determinism (TF 2.12+).
+- **Save models in `.keras` format** (not HDF5) for forward compatibility.
+- **Profile with TensorBoard** to identify data pipeline bottlenecks before scaling up.
+- **Use `tf.debugging.enable_check_numerics()`** during development to catch NaN/Inf early.
+- **Export with `tf.saved_model`** for deployment; export ONNX for cross-framework comparison.
+
+## References
+
+- [Deep Learning with Python, 2nd Edition](https://www.manning.com/books/deep-learning-with-python-second-edition) -- Francois Chollet (Keras creator)
+- [Keras documentation](https://keras.io/) -- Official API reference and guides
+- [TensorFlow tutorials](https://www.tensorflow.org/tutorials) -- End-to-end examples
+- [fchollet/deep-learning-with-python-notebooks](https://github.com/fchollet/deep-learning-with-python-notebooks) -- Code companion to the book
+- [Keras examples gallery](https://keras.io/examples/) -- 100+ community-contributed examples