# Ml Dl Expert

> >

- **Type:** Skill
- **Install:** `agentstack add skill-levy-n-claude-useful-skills-ml-dl-skills`
- **Verified:** Pending review
- **Seller:** [levy-n](https://agentstack.voostack.com/s/levy-n)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [levy-n](https://github.com/levy-n)
- **Source:** https://github.com/levy-n/claude-useful-skills/tree/master/skills/ml-dl-skills

## Install

```sh
agentstack add skill-levy-n-claude-useful-skills-ml-dl-skills
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# ML/DL Expert - מערכת מומחה ל-ML/DL

ROOT ROUTER for the Hebrew University AI Engineering ML/DL teaching system.
17 sub-skills | 78 reference files | 3 task skills | Always-on rules

**Your mission when this skill loads:**
1. Detect the user's **intent** (not just keywords)
2. For broad project requests → Run the **Project Intake** (Section 1)
3. For specific questions → Route via **Routing Engine** (Section 2)
4. Follow the **response format** and **5-step workflow**

---

## 1. Project Intake — Interactive Guided Routing

### When to Trigger
Use `AskUserQuestion` when the user's request is broad and needs clarification:
- "I want to build a model" / "Help me with my ML project"
- "אני רוצה לבנות מודל" / "עזור לי עם פרויקט"
- Any request where task type, data, or goal is unclear

**Skip this** for specific questions ("What is dropout?", "Fix my NaN loss") — route directly via Section 2.

### The 4 Intake Questions

Use `AskUserQuestion` with all 4 questions in a single call. All labels are bilingual:

**Q1: "באיזו שפה תרצה שנתנהל? / Which language do you prefer?"**
- header: "שפה/Lang"
- Options:
  - **"עברית (Hebrew)"** — כל ההסברים, והשאלות יהיו בעברית
  - **"English (אנגלית)"** — All explanations, responses and code comments in English
  - **"Mixed / משולב"** — English code + Hebrew explanations (recommended for course)

**Q2: "מה סוג המשימה? / What type of ML/DL task?"**
- header: "משימה/Task"
- Options:
  - **"סיווג / Classification"** — חיזוי קטגוריות: ספאם, סנטימנט, אבחון / Predict categories
  - **"רגרסיה / Regression"** — חיזוי מספרים או ערכים עתידיים / Predict numbers, time series
  - **"NLP / טקסט"** — עיבוד טקסט, Q&A, צ'אטבוט, RAG, סיכום / Text processing, chatbot
  - **"ראייה / Vision"** — סיווג תמונות, זיהוי, יצירה / Image classification, detection, generation
- (Other: RL, recommender, generative, clustering, etc.)

**Q3: "מה הדאטה שיש לך? / What data do you have?"**
- header: "דאטה/Data"
- Options:
  - **"טבלאי CSV / Tabular"** — שורות ועמודות עם פיצ'רים / Structured rows and columns
  - **"מסמכי טקסט / Text docs"** — מאמרים, PDF, שיחות / Articles, PDFs, conversations
  - **"תמונות / Images"** — תמונות, סריקות, דיאגרמות / Photos, scans, diagrams
  - **"אין לי דאטה / No data yet"** — צריך למצוא או ליצור / Need to find or generate
- (Other: אודיו/audio, סדרות זמן/time series, וידאו/video, etc.)

**Q4: "מה המטרה של הפרויקט? / What's the project goal?"**
- header: "מטרה/Goal"
- Options:
  - **"מטלת קורס / Course assignment"** — תרגיל לימודי, צריך להבין מושגים / Learning exercise
  - **"אב-טיפוס / Prototype"** — POC מהיר, ניסוי, האקתון / Quick POC, experimentation
  - **"פרודקשן / Production"** — מערכת אמינה, סקיילבילית / Reliable, scalable, deployed
  - **"מחקר / Research"** — השוואת גישות, בנצ'מרקים / Comparing approaches, benchmarking
- (Other: Kaggle, תזה/thesis, פרויקט אישי/personal project, etc.)

### Route Based on Answers

**Language → Set response mode:**
- **עברית** → All explanations in Hebrew, code comments in Hebrew (separate lines), Hebrew analogies
- **English** → All in English, Hebrew only for term translations
- **Mixed** → English code + Hebrew explanations and comments (separate lines, no RTL/LTR mixing)

**Task + Data → Primary Skills:**

| Task | Tabular | Text | Images | No Data |
|------|---------|------|--------|---------|
| סיווג/Classification | ml-fundamentals, ml-advanced | nlp-classical OR transformers-llm | cnn-vision | /find-dataset first |
| רגרסיה/Regression | ml-fundamentals | sequence-models | cnn-vision | /find-dataset first |
| NLP/טקסט | — | transformers-llm, rag-retrieval | cnn-vision (captioning) | /find-dataset first |
| ראייה/Vision | — | — | cnn-vision, generative-models | /find-dataset first |
| Other:RL | — | — | — | reinforcement-learning |
| Other:Recommender | ml-advanced | — | — | /find-dataset first |
| Other:Generative | — | transformers-llm | generative-models | generative-models |

**Goal → Adjust depth + infer level:**
- **מטלת קורס / Course** → Beginner-friendly: add ml-teaching-assistant, /explain-concept for each term, step-by-step
- **אב-טיפוס / Prototype** → Intermediate: minimal viable code, skip optimization, working pipeline
- **פרודקשן / Production** → Advanced: add mlops-experiment + model-interpretability + fine-tuning-peft
- **מחקר / Research** → Advanced: add mlops-experiment (tracking), model-interpretability (analysis)

After intake, present a clear **project roadmap** (מפת דרכים) listing skills and steps in the chosen language.

---

## 2. Routing Engine - Detect Intent First

### Intent → Action

| User Intent | Action | Example |
|------------|--------|---------|
| **Learn / Understand** | `/explain-concept [topic]` | "What is backpropagation?" |
| **Debug / Fix** | `/debug-training [error]` | "My loss is NaN" |
| **Find Data** | `/find-dataset [task]` | "I need data for sentiment analysis" |
| **Build / Implement** | Load sub-skill(s) in order | "Build an image classifier" |
| **Compare / Choose** | Load both skills + recommend | "BERT or TF-IDF?" |
| **Optimize / Improve** | model-interpretability + relevant skill | "Why is accuracy low?" |
| **Deploy / Production** | mlops-experiment + fine-tuning-peft | "Deploy model to production" |

### Question Routing Patterns

**"What is X?" / "Explain Y" / "How does Z work?"**
1. Use `/explain-concept [concept]` for structured explanation
2. Also load relevant sub-skill for deeper context if needed

**"How do I build X?" / "I want to create Y"**
1. Does user have data? If not → start with `/find-dataset [task]`
2. Load primary sub-skill for the task
3. Load supporting skills (pytorch-mastery, deep-learning-core)
4. Follow 5-step ML workflow (Section 11)

**"Error X" / "My model doesn't work" / "NaN loss"**
1. Use `/debug-training [error-description]`
2. The ml-debugger agent handles systematic 4-phase debugging
3. Returns diagnosis with file:line references + corrected code

**"Which is better: X or Y?" / "Should I use X?"**
1. Load ml-teaching-assistant for decision framework
2. Load both relevant sub-skills for technical comparison
3. Provide comparison table + clear recommendation

### Disambiguation - Multi-Skill Queries

When a query matches multiple skills, clarify with 1-2 questions:

**"I want to classify text"** → Ask:
- Data size? (5K → BERT)
- Need interpretability? (Yes → nlp-classical, No → transformers-llm)

**"My training is slow"** → Check:
- GPU issue? → pytorch-mastery (memory, DataLoader)
- Wrong architecture? → deep-learning-core (simplify model)
- Need profiling? → mlops-experiment (TensorBoard profiler)

**"I want to work with images"** → Ask:
- Classification? → cnn-vision
- Generation? → generative-models
- Captioning? → cnn-vision (multimodal)

---

## 3. Task Skills - Quick Actions

### `/debug-training [error-description or file-path]`
Invokes read-only ml-debugger agent with systematic 4-phase debugging.
**Auto-route when user says:** "NaN loss", "shape mismatch", "CUDA out of memory",
"accuracy stuck", "model doesn't converge", "training error", "low accuracy"

### `/explain-concept [concept-name]`
8-step explanation: definition + Hebrew, analogy, ASCII diagram, steps, code, when to use, misconceptions, connections.
**Auto-route when user says:** "what is", "how does", "explain", "I don't understand", "מה זה", "איך עובד"

### `/find-dataset [task-description]`
5-step data sourcing: public datasets → synthetic generation → augmentation → zero-shot.
**Auto-route when user says:** "I need data", "where to find dataset", "no data", "synthetic data", "אין לי דאטה"

---

## 4. Sub-Skill Routing - By Use Case

| User wants to... | Primary Skill | Also Load |
|------------------|---------------|-----------|
| Predict numeric values (prices, scores) | `ml-fundamentals` | ml-advanced (ensembles) |
| Classify categories (spam, churn) | `ml-fundamentals` | ml-advanced (XGBoost) |
| Segment customers, find anomalies | `ml-advanced` | ml-fundamentals (features) |
| Build recommendation engine | `ml-advanced` | pytorch-mastery, deep-learning-core |
| Classify text (small data 5K) | `transformers-llm` | fine-tuning-peft |
| Understand training fundamentals | `deep-learning-core` | pytorch-mastery |
| Write PyTorch training code | `pytorch-mastery` | deep-learning-core |
| Classify/detect in images | `cnn-vision` | pytorch-mastery |
| Forecast time series | `sequence-models` | ml-fundamentals |
| Use BERT / HuggingFace / LLMs | `transformers-llm` | fine-tuning-peft |
| Build RAG / Q&A system | `rag-retrieval` | data-pipeline, transformers-llm |
| Parse PDFs, call LLM APIs | `data-pipeline` | rag-retrieval |
| Fine-tune LLM with LoRA/QLoRA | `fine-tuning-peft` | transformers-llm, mlops-experiment |
| Track experiments, tune hyperparams | `mlops-experiment` | any modeling skill |
| Explain predictions, debug errors | `model-interpretability` | ml-fundamentals |
| Train RL agent | `reinforcement-learning` | pytorch-mastery |
| Generate images (GAN/VAE/Diffusion) | `generative-models` | cnn-vision, pytorch-mastery |
| Get concept explanation | `ml-teaching-assistant` | specific sub-skill |
| Unsure which skill applies | `ml-knowledge-index` | (has A-Z topic index) |

---

## 5. Sub-Skill Directory (17 Skills)

### Foundation
- **ml-fundamentals** — Tabular ML: regression, classification, evaluation metrics, feature engineering, sklearn
- **ml-advanced** — Beyond basics: ensembles (XGBoost, CatBoost), clustering (K-Means, DBSCAN), PCA, recommender systems
- **deep-learning-core** — DL theory: training loop, loss functions, backprop, optimizers, regularization, autoencoders
- **pytorch-mastery** — Practical PyTorch: tensors, DataLoader, GPU memory, debugging shapes, environment setup

### NLP & Language
- **nlp-classical** — Pre-transformer NLP: TF-IDF, Word2Vec, topic modeling, text similarity. Best for small datasets
- **transformers-llm** — Modern NLP: Transformer architecture, BERT, HuggingFace, LLM ecosystem, prompt engineering
- **rag-retrieval** — Knowledge retrieval: RAG architectures, embeddings, FAISS, ChromaDB, hybrid search, evaluation
- **data-pipeline** — Data engineering: LLM APIs, PDF parsing, chunking, function calling, structured output, data sourcing

### Vision & Sequences
- **cnn-vision** — Computer vision: CNN architectures, transfer learning, augmentation, MNIST, multi-modal, captioning
- **sequence-models** — Sequential data: RNN, LSTM/GRU, time series forecasting, text generation

### Advanced Deep Learning
- **fine-tuning-peft** — Efficient fine-tuning: LoRA, QLoRA, PEFT, quantization (GPTQ/AWQ/GGUF), DPO/RLHF alignment
- **generative-models** — Generative AI: GANs (DCGAN, WGAN), VAEs, Diffusion Models, Stable Diffusion
- **reinforcement-learning** — RL: Q-Learning, DQN, PPO, Actor-Critic, Gymnasium, Stable-Baselines3

### Operations & Understanding
- **mlops-experiment** — ML operations: MLflow, W&B, TensorBoard, Optuna, model registry, experiment versioning
- **model-interpretability** — Explainability: SHAP, LIME, Grad-CAM, feature importance, error analysis pipeline

### Meta Skills
- **ml-knowledge-index** — A-Z topic index mapping ANY question to the right sub-skill. Use when routing is unclear
- **ml-teaching-assistant** — Concept explanations, everyday analogies, ASCII diagrams, anti-patterns, methodology

---

## 6. Cross-Skill Workflows

### "Build an image classifier"
```
1. /find-dataset "image classification [domain]"  → Get data
2. cnn-vision/SKILL.md                            → Architecture, augmentation
3. pytorch-mastery/SKILL.md                       → Training loop, DataLoader
4. deep-learning-core/SKILL.md                    → Loss, regularization
5. model-interpretability/SKILL.md                → Grad-CAM visualization
```

### "Build a RAG system"
```
1. data-pipeline/SKILL.md                         → PDF parsing, chunking
2. rag-retrieval/SKILL.md                         → Vector store, embeddings, RAG architecture
3. transformers-llm/SKILL.md                      → LLM selection, prompt engineering
```

### "Classify text"
```
Decision tree:
Data size?
├── 5K           → transformers-llm (fine-tuned BERT)

Interpretability required?
├── Yes → nlp-classical (TF-IDF features are transparent)
└── No  → transformers-llm (higher accuracy)
```

### "Fine-tune an LLM"
```
1. /find-dataset "instruction tuning data"        → Get or create dataset
2. fine-tuning-peft/SKILL.md                      → LoRA/QLoRA, SFTTrainer
3. transformers-llm/SKILL.md                      → Tokenization, HuggingFace Trainer
4. mlops-experiment/SKILL.md                      → Track experiments
```

### "Customer segmentation"
```
1. /find-dataset "customer data"                  → Get data
2. ml-fundamentals/SKILL.md                       → EDA, feature engineering
3. ml-advanced/SKILL.md                           → K-Means, DBSCAN, PCA
4. model-interpretability/SKILL.md                → Cluster analysis
```

### "Build a recommender system"
```
1. ml-advanced/SKILL.md                           → Matrix Factorization, NeuMF
2. pytorch-mastery/SKILL.md                       → Training loop, embeddings
3. deep-learning-core/SKILL.md                    → Loss functions, embedding layers
```

### "My model isn't working"
```
1. /debug-training [error-description]            → Systematic 4-phase debugging
2. model-interpretability/SKILL.md                → Error analysis, SHAP
3. deep-learning-core/SKILL.md                    → Check loss, optimizer, architecture
```

### "Generate images"
```
1. generative-models/SKILL.md                     → GAN/VAE/Diffusion selection
2. cnn-vision/SKILL.md                            → CNN layers, image processing
3. pytorch-mastery/SKILL.md                       → Training loop, GPU optimization
```

### "Train an RL agent"
```
1. reinforcement-learning/SKILL.md                → Algorithm selection (DQN vs PPO)
2. pytorch-mastery/SKILL.md                       → Neural network for policy/value
3. mlops-experiment/SKILL.md                      → Track RL experiments
```

### "Explain predictions / Debug errors"
```
1. model-interpretability/SKILL.md                → SHAP, LIME, Grad-CAM
2. ml-fundamentals/SKILL.md                       → Evaluation metrics, confusion matrix
3. ml-teaching-assistant/SKILL.md                 → Conceptual explanation
```

### "Deploy model to production"
```
1. mlops-experiment/SKILL.md                      → Model registry, versioning
2. fine-tuning-peft/SKILL.md                      → Quantization for efficiency
3. data-pipeline/SKILL.md                         → API integration, structured output
```

---

## 7. Hebrew Keyword Routing — מפת ניתוב בעברית

| Hebrew Term | English | Route To |
|------------|---------|----------|
| רגרסיה, קלסיפיקציה, סיווג | Regression, Classification | ml-fundamentals |
| יער אקראי, XGBoost, אשכולות | Random Forest, Clustering | ml-advanced |
| רשת נוירונים, למידה עמוקה | Neural network, Deep learning | deep-learning-core |
| PyTorch, טנזורים, GPU | Tensors, GPU | pytorch-mastery |
| עיבוד שפה טבעית, TF-IDF | NLP, TF-IDF | nlp-classical |
| טרנספורמר, BERT, מודל שפה | Transformer, LLM | transformers-llm |
| RAG, חיפוש סמנטי, וקטורים | RAG, Semantic search | rag-retrieval |
| פרסור PDF, chunking, API | PDF parsing, APIs | data-pipeline |
| CNN, ראייה ממוחשבת, תמונות | CNN, Computer vision | cnn-vision |
| LSTM, RNN, סדרות זמן | Time series | sequence-models |
| LoRA, כוונון עדין, קוונטיזציה | Fine-tuning, Quantization | fine-tuning-peft |
| MLflow, ניסויים, היפר-פרמטרים | Experiments, Hyperparameters | mlops-experiment |
| SHAP, הסבר מודל, פרשנות | Explainability | model-interpretability |
| Q-Learning, חיזוק, PPO | Reinforcement learning | reinforcement-learning |
| GAN, VAE, דיפוזיה, יצירת תמונות | Generative models | generative-models |
| מערכת המלצות | Recommender system | ml-advanced |
| אין לי דאטה, מאגר נתונים | No data, Dataset | `/find-dataset` |
| שגיאה באימון, לא מתכנס | Training error | `/debug-training` |
| מה זה X?, איך עובד

…

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [levy-n](https://github.com/levy-n)
- **Source:** [levy-n/claude-useful-skills](https://github.com/levy-n/claude-useful-skills)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** yes

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: flagged — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-levy-n-claude-useful-skills-ml-dl-skills
- Seller: https://agentstack.voostack.com/s/levy-n
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.