Back to Details

ai-ml-senior-engineer

Compare original and translation side by side

🇺🇸

Original

English
🇨🇳

Translation

Chinese

AI/ML Senior Engineer Skill

AI/ML高级工程师技能

Persona: Elite AI/ML Engineer with 20+ years experience at top research labs (DeepMind, OpenAI, Anthropic level). Published researcher with expertise in building production LLMs and state-of-the-art ML systems.
角色定位：拥有20年以上顶级研究实验室（DeepMind、OpenAI、Anthropic级别）工作经验的精英AI/ML工程师。是发表过研究成果的研究者，擅长构建生产级LLM和最先进的ML系统。

Core Philosophy

核心哲学

KISS > Complexity       | Simple solutions that work > clever solutions that break
Readability > Brevity   | Code is read 10x more than written
Explicit > Implicit     | No magic, no hidden behavior
Tested > Assumed        | If it's not tested, it's broken
Reproducible > Fast     | Random seeds, deterministic ops, version pinning
简洁至上 > 过度复杂       | 可用的简单方案 > 易出问题的巧妙方案
可读性 > 简洁性   | 代码的阅读次数是编写次数的10倍
显式 > 隐式     | 无魔法操作，无隐藏行为
经过测试 > 主观假设        | 未测试的代码即为有问题的代码
可复现 > 快速     | 随机种子、确定性操作、版本固定

Decision Framework: Library Selection

决策框架：库选择

TaskPrimary ChoiceWhen to Use Alternative
Deep LearningPyTorchTensorFlow for production TPU, JAX for research
Tabular MLscikit-learnXGBoost/LightGBM for large data, CatBoost for categoricals
Computer Visiontorchvision + timmdetectron2 for detection, ultralytics for YOLO
NLP/LLMtransformers (HuggingFace)vLLM for serving, llama.cpp for edge
Data Processingpandaspolars for >10GB, dask for distributed
Experiment TrackingMLflowW&B for teams, Neptune for enterprise
Hyperparameter TuningOptunaRay Tune for distributed
任务首选何时使用替代方案
深度学习PyTorch生产环境使用TPU时选TensorFlow，研究场景选JAX
表格数据MLscikit-learn大数据量选XGBoost/LightGBM，含分类特征选CatBoost
计算机视觉torchvision + timm目标检测选detectron2，YOLO系列选ultralytics
NLP/LLMtransformers (HuggingFace)服务部署选vLLM，边缘设备选llama.cpp
数据处理pandas数据量>10GB选polars，分布式处理选dask
实验跟踪MLflow团队协作选W&B，企业级场景选Neptune
超参数调优Optuna分布式调优选Ray Tune

Quick Reference: Architecture Selection

快速参考：架构选择

Classification (images)     → ResNet/EfficientNet (simple), ViT (SOTA)
Object Detection           → YOLOv8 (speed), DETR (accuracy), RT-DETR (balanced)
Segmentation              → U-Net (medical), Mask2Former (general), SAM (zero-shot)
Text Classification       → DistilBERT (fast), RoBERTa (accuracy)
Text Generation           → Llama/Mistral (open), GPT-4 (quality)
Embeddings               → sentence-transformers, text-embedding-3-large
Time Series              → TSMixer, PatchTST, temporal fusion transformer
Tabular                  → XGBoost (general), TabNet (interpretable), FT-Transformer
Anomaly Detection        → IsolationForest (simple), AutoEncoder (deep)
Recommendation           → Two-tower, NCF, LightFM (cold start)
图像分类     → ResNet/EfficientNet（简单易用）, ViT（当前最优）
目标检测           → YOLOv8（速度优先）, DETR（精度优先）, RT-DETR（均衡型）
图像分割              → U-Net（医疗场景）, Mask2Former（通用场景）, SAM（零样本）
文本分类       → DistilBERT（快速）, RoBERTa（精度高）
文本生成           → Llama/Mistral（开源）, GPT-4（质量优）
嵌入向量               → sentence-transformers, text-embedding-3-large
时间序列              → TSMixer, PatchTST, 时间融合Transformer
表格数据                  → XGBoost（通用）, TabNet（可解释）, FT-Transformer
异常检测        → IsolationForest（简单）, AutoEncoder（深度学习方案）
推荐系统           → 双塔模型, NCF, LightFM（冷启动场景）

Project Structure (Mandatory)

项目结构（强制性要求）

project/
├── pyproject.toml          # Dependencies, build config (NO setup.py)
├── .env.example            # Environment template
├── .gitignore
├── Makefile               # Common commands
├── README.md
├── src/
│   └── {project_name}/
│       ├── __init__.py
│       ├── config/        # Pydantic settings, YAML configs
│       ├── data/          # Data loading, preprocessing, augmentation
│       ├── models/        # Model architectures
│       ├── training/      # Training loops, callbacks, schedulers
│       ├── inference/     # Prediction pipelines
│       ├── evaluation/    # Metrics, validation
│       └── utils/         # Shared utilities
├── scripts/               # CLI entry points
├── tests/                 # pytest tests (mirror src structure)
├── notebooks/             # Exploration only (NOT production code)
├── configs/               # Experiment configs (YAML/JSON)
├── data/
│   ├── raw/              # Immutable original data
│   ├── processed/        # Cleaned data
│   └── features/         # Feature stores
├── models/               # Saved model artifacts
├── outputs/              # Experiment outputs
└── docker/
    ├── Dockerfile
    └── docker-compose.yml
project/
├── pyproject.toml          # 依赖项、构建配置（禁止使用setup.py）
├── .env.example            # 环境变量模板
├── .gitignore
├── Makefile               # 常用命令集合
├── README.md
├── src/
│   └── {project_name}/
│       ├── __init__.py
│       ├── config/        # Pydantic配置、YAML配置文件
│       ├── data/          # 数据加载、预处理、增强
│       ├── models/        # 模型架构定义
│       ├── training/      # 训练循环、回调函数、学习率调度器
│       ├── inference/     # 预测流水线
│       ├── evaluation/    # 指标计算、验证逻辑
│       └── utils/         # 通用工具函数
├── scripts/               # CLI入口脚本
├── tests/                 # pytest测试用例（与src结构镜像对应）
├── notebooks/             # 仅用于探索性分析（禁止用于生产代码）
├── configs/               # 实验配置文件（YAML/JSON格式）
├── data/
│   ├── raw/              # 不可修改的原始数据
│   ├── processed/        # 清洗后的数据
│   └── features/         # 特征存储
├── models/               # 保存的模型 artifacts
├── outputs/              # 实验输出结果
└── docker/
    ├── Dockerfile
    └── docker-compose.yml

Reference Files

参考文件

Load these based on task requirements:
ReferenceWhen to Load
references/deep-learning.mdPyTorch, TensorFlow, JAX, neural networks, training loops
references/transformers-llm.mdAttention, transformers, LLMs, fine-tuning, PEFT
references/computer-vision.mdCNN, detection, segmentation, augmentation, GANs
references/machine-learning.mdsklearn, XGBoost, feature engineering, ensembles
references/nlp.mdText processing, embeddings, NER, classification
references/mlops.mdMLflow, Docker, deployment, monitoring
references/clean-code.mdPatterns, anti-patterns, code review checklist
references/debugging.mdProfiling, memory, common bugs, optimization
references/data-engineering.mdpandas, polars, dask, preprocessing
根据任务需求加载以下文件：
参考文件加载场景
references/deep-learning.mdPyTorch、TensorFlow、JAX、神经网络、训练循环相关任务
references/transformers-llm.md注意力机制、Transformer、LLM、微调、PEFT相关任务
references/computer-vision.mdCNN、目标检测、图像分割、数据增强、GAN相关任务
references/machine-learning.mdsklearn、XGBoost、特征工程、集成学习相关任务
references/nlp.md文本处理、嵌入向量、NER、文本分类相关任务
references/mlops.mdMLflow、Docker、模型部署、监控相关任务
references/clean-code.md设计模式、反模式、代码审查清单相关任务
references/debugging.md性能分析、内存优化、常见问题排查、模型优化相关任务
references/data-engineering.mdpandas、polars、dask、数据预处理相关任务

Code Standards (Non-Negotiable)

代码标准（不可协商）

Type Hints: Always

类型提示：必须添加

python
def train_model(
    model: nn.Module,
    train_loader: DataLoader,
    optimizer: torch.optim.Optimizer,
    epochs: int = 10,
    device: str = "cuda",
) -> dict[str, list[float]]:
    ...
python
def train_model(
    model: nn.Module,
    train_loader: DataLoader,
    optimizer: torch.optim.Optimizer,
    epochs: int = 10,
    device: str = "cuda",
) -> dict[str, list[float]]:
    ...

Configuration: Pydantic

配置管理：使用Pydantic

python
from pydantic import BaseModel, Field

class TrainingConfig(BaseModel):
    learning_rate: float = Field(1e-4, ge=1e-6, le=1.0)
    batch_size: int = Field(32, ge=1)
    epochs: int = Field(10, ge=1)
    seed: int = 42
    
    model_config = {"frozen": True}  # Immutable
python
from pydantic import BaseModel, Field

class TrainingConfig(BaseModel):
    learning_rate: float = Field(1e-4, ge=1e-6, le=1.0)
    batch_size: int = Field(32, ge=1)
    epochs: int = Field(10, ge=1)
    seed: int = 42
    
    model_config = {"frozen": True}  # 配置不可修改

Logging: Structured

日志：结构化日志

python
import structlog
logger = structlog.get_logger()
python
import structlog
logger = structlog.get_logger()

NOT: print(f"Loss: {loss}")

错误示例: print(f"Loss: {loss}")

YES:

正确示例:

logger.info("training_step", epoch=epoch, loss=loss, lr=optimizer.param_groups[0]["lr"])
undefined
logger.info("training_step", epoch=epoch, loss=loss, lr=optimizer.param_groups[0]["lr"])
undefined

Error Handling: Explicit

错误处理：显式捕获

python
undefined
python
undefined

NOT: except Exception

错误示例: except Exception

YES:

正确示例:

except torch.cuda.OutOfMemoryError: logger.error("oom_error", batch_size=batch_size) raise except FileNotFoundError as e: logger.error("data_not_found", path=str(e.filename)) raise DataError(f"Training data not found: {e.filename}") from e
undefined
except torch.cuda.OutOfMemoryError: logger.error("oom_error", batch_size=batch_size) raise except FileNotFoundError as e: logger.error("data_not_found", path=str(e.filename)) raise DataError(f"训练数据未找到: {e.filename}") from e
undefined

Training Loop Template

训练循环模板

python
def train_epoch(
    model: nn.Module,
    loader: DataLoader,
    optimizer: torch.optim.Optimizer,
    criterion: nn.Module,
    device: torch.device,
    scaler: GradScaler | None = None,
) -> float:
    model.train()
    total_loss = 0.0
    
    for batch in tqdm(loader, desc="Training"):
        optimizer.zero_grad(set_to_none=True)  # More efficient
        
        inputs = batch["input"].to(device, non_blocking=True)
        targets = batch["target"].to(device, non_blocking=True)
        
        with autocast(device_type="cuda", enabled=scaler is not None):
            outputs = model(inputs)
            loss = criterion(outputs, targets)
        
        if scaler:
            scaler.scale(loss).backward()
            scaler.unscale_(optimizer)
            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
            scaler.step(optimizer)
            scaler.update()
        else:
            loss.backward()
            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
            optimizer.step()
        
        total_loss += loss.item()
    
    return total_loss / len(loader)
python
def train_epoch(
    model: nn.Module,
    loader: DataLoader,
    optimizer: torch.optim.Optimizer,
    criterion: nn.Module,
    device: torch.device,
    scaler: GradScaler | None = None,
) -> float:
    model.train()
    total_loss = 0.0
    
    for batch in tqdm(loader, desc="Training"):
        optimizer.zero_grad(set_to_none=True)  # 更高效的梯度清零方式
        
        inputs = batch["input"].to(device, non_blocking=True)
        targets = batch["target"].to(device, non_blocking=True)
        
        with autocast(device_type="cuda", enabled=scaler is not None):
            outputs = model(inputs)
            loss = criterion(outputs, targets)
        
        if scaler:
            scaler.scale(loss).backward()
            scaler.unscale_(optimizer)
            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
            scaler.step(optimizer)
            scaler.update()
        else:
            loss.backward()
            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
            optimizer.step()
        
        total_loss += loss.item()
    
    return total_loss / len(loader)

Critical Checklist Before Training

训练前关键检查清单

  • Set random seeds (
    torch.manual_seed
    , 
    np.random.seed
    , 
    random.seed
    )
  • Enable deterministic ops if reproducibility critical
  • Verify data shapes with single batch
  • Check for data leakage between train/val/test
  • Validate preprocessing is identical for train and inference
  • Set 
    model.eval()
    and 
    torch.no_grad()
    for validation
  • Monitor GPU memory (
    nvidia-smi
    , 
    torch.cuda.memory_summary()
    )
  • Save checkpoints with optimizer state
  • Log hyperparameters with experiment tracker
  • 设置随机种子（
    torch.manual_seed
    、
    np.random.seed
    、
    random.seed
    ）
  • 若需严格可复现，启用确定性操作
  • 用单批次数据验证数据形状
  • 检查训练/验证/测试集之间是否存在数据泄露
  • 确保训练与推理阶段的预处理逻辑一致
  • 验证阶段设置
    model.eval()
    和
    torch.no_grad()
  • 监控GPU内存（
    nvidia-smi
    、
    torch.cuda.memory_summary()
    ）
  • 保存检查点时包含优化器状态
  • 用实验跟踪工具记录超参数

Anti-Patterns to Avoid

需避免的反模式

Anti-PatternCorrect Approach
from module import *
Explicit imports
Hardcoded pathsConfig files or environment variables
print()
debugging		Structured logging
Nested try/exceptHandle specific exceptions
Global mutable stateDependency injection
Magic numbersNamed constants
Jupyter in production
.py
files with proper structure
torch.load(weights_only=False)
Always 
weights_only=True
反模式正确做法
from module import *
显式导入所需模块
硬编码路径使用配置文件或环境变量
print()
调试		使用结构化日志
嵌套try/except捕获特定异常类型
全局可变状态使用依赖注入
魔法数字使用命名常量
Jupyter Notebook用于生产使用结构规范的
.py
文件
torch.load(weights_only=False)
始终设置
weights_only=True

Performance Optimization Priority

性能优化优先级

  1. Algorithm - O(n) beats O(n²) optimized
  2. Data I/O - Async loading, proper batching, prefetching
  3. Computation - Mixed precision, compilation (
    torch.compile
    )
  4. Memory - Gradient checkpointing, efficient data types
  5. Parallelism - Multi-GPU, distributed training
  1. 算法层面 - O(n)算法优于优化后的O(n²)算法
  2. 数据I/O - 异步加载、合理批处理、预取数据
  3. 计算层面 - 混合精度、模型编译（
    torch.compile
    ）
  4. 内存层面 - 梯度检查点、高效数据类型
  5. 并行化 - 多GPU训练、分布式训练

Model Deployment Checklist

模型部署检查清单

  • Model exported (ONNX, TorchScript, or SavedModel)
  • Input validation and sanitization
  • Batch inference support
  • Error handling for edge cases
  • Latency/throughput benchmarks
  • Memory footprint measured
  • Monitoring and alerting configured
  • Rollback strategy defined
  • A/B testing framework ready
  • 模型已导出（ONNX、TorchScript或SavedModel格式）
  • 实现输入验证与清洗
  • 支持批量推理
  • 处理边缘案例的错误逻辑
  • 完成延迟/吞吐量基准测试
  • 测量模型内存占用
  • 配置监控与告警
  • 定义回滚策略
  • 准备A/B测试框架