AI推理工程师学习路线

AI 推理工程师 · 零基础完整学习路线

目标：从零基础到能胜任大厂/AI公司推理工程师岗位 预计周期：8-12个月（全职学习） 核心能力：CUDA编程 + 推理框架 + 大模型优化部署

目录

• 阶段总览
• 阶段一：编程基础（第1-2月）
• 阶段二：深度学习基础（第3-4月）
• 阶段三：CUDA编程（第3-5月）
• 阶段四：推理框架（第5-7月）
• 阶段五：大模型推理优化（第7-9月）
• 阶段六：项目实战（第9-10月）
• 阶段七：求职准备（第10-12月）
• 每日时间分配建议
• 硬件和环境要求
• 学习原则
• 推荐资源汇总

阶段总览

月份 1 2 3 4 5 6 7 8 9 10 11 12
├─ 编程基础 ─┤
├─ 深度学习 ──┤
├── CUDA编程 ──────┤
├─ 推理框架 ──────┤
├─ 大模型优化 ─────┤
├─ 项目实战 ┤
├─ 求职 ─┤
├──────────────── Codeforces 持续刷题 ──────────────────────┤

阶段一：编程基础（第1-2月）

1.1 Python（第1-2周）

Python 是 AI 领域的通用语言，必须熟练。

学习内容：

• 基础语法：变量、条件、循环、函数
• 数据结构：list、dict、set、tuple
• 面向对象：类、继承、魔术方法
• 常用库：numpy 基础操作、文件读写
• 虚拟环境：venv / conda 管理依赖

学习资源：

检验标准：

• 能用 Python 读写文件、处理数据
• 能用 numpy 做矩阵运算
• 能用 class 写一个简单的神经网络层

1.2 C/C++（第2-6周）

推理框架底层全是 C++，这是核心语言能力。

学习内容：

C语言基础（第2-3周）：
– 指针、内存管理（malloc/free）
– 结构体、函数指针
– 预处理器、头文件

C++ 现代特性（第4-6周）：
– 引用、const、constexpr
– 类与对象、构造/析构、RAII
– 智能指针：unique_ptr, shared_ptr
– 模板基础：函数模板、类模板
– STL：vector, map, unordered_map, string
– 移动语义：std::move, 右值引用
– Lambda 表达式
– 多线程基础：std::thread, mutex

学习资源：

检验标准：

• 能手写链表、栈、队列
• 理解指针和内存管理，不会内存泄漏
• 能用智能指针管理资源
• 能用模板写通用函数
• 能用 STL 容器解决问题

1.3 Linux 基础（第4-5周，穿插学习）

推理部署都在 Linux 环境，必须会用。

学习内容：

• 基本命令：ls, cd, grep, find, cat, vim/nano
• 文件权限、用户管理
• Shell 脚本基础
• 包管理：apt / conda / pip
• SSH 远程连接
• tmux / screen 后台运行

学习资源：

检验标准：

• 能在终端完成日常操作
• 能写简单的 Shell 脚本
• 能用 SSH 连接远程服务器操作

1.4 Codeforces 刷题（贯穿全程）

目标： 从零开始，8-12个月打到 1800-2000 分

第1-2月目标： 稳定在 1000-1200 分

每日任务：1-2题（800-1200难度）

重点掌握：
– 暴力枚举
– 贪心
– 排序和比较
– 字符串处理
– 简单数学

平台：
– Codeforces: https://codeforces.com
– 洛谷: https://www.luogu.com.cn（中文题解多）

刷题方法：

阶段二：深度学习基础（第3-4月）

2.1 数学基础（第3月，穿插学习）

不需要精通，但需要理解核心概念。

线性代数：

必须掌握：
– 向量、矩阵运算
– 矩阵乘法的几何意义
– 转置、逆矩阵
– 特征值和特征向量（了解）
– SVD 分解（了解）

资源：
– 3Blue1Brown《线性代数的本质》(B站有搬运)
– MIT 18.06 线性代数（Gilbert Strang）

概率论：

必须掌握：
– 概率、条件概率、贝叶斯公式
– 常见分布：正态、均匀、伯努利
– 期望、方差
– 极大似然估计（MLE）

资源：
– 3Blue1Brown 概率相关视频
– StatQuest (YouTube/B站) — 用最简单的语言讲统计

微积分：

必须掌握：
– 导数、偏导数
– 链式求导法则（反向传播的基础）
– 梯度的概念

资源：
– 3Blue1Brown《微积分的本质》

检验标准：

• 能手算矩阵乘法
• 理解梯度下降的数学原理
• 能推导反向传播的链式求导

2.2 深度学习理论（第3-4月）

学习顺序：

第3月：
1. 神经网络基础
– 感知机、多层感知机
– 激活函数：ReLU、Sigmoid、Tanh
– 损失函数：交叉熵、MSE
– 反向传播原理
– 梯度下降及其变体：SGD、Adam

2. CNN（卷积神经网络）
– 卷积操作原理
– 池化层
– 经典网络：LeNet → AlexNet → VGG → ResNet
– 重点理解 ResNet 的残差连接

第4月：
3. RNN / LSTM（了解即可）
– 序列建模基本概念
– LSTM 解决了什么问题

4. Transformer（重中之重）
– Self-Attention 机制
– Multi-Head Attention
– 位置编码（Positional Encoding）
– Layer Normalization
– Encoder-Decoder 架构
– 必须能手写一个简化版 Transformer

5. 大语言模型（LLM）基础
– GPT 系列架构（Decoder-Only）
– LLaMA / Qwen 架构特点
– 预训练、SFT、RLHF 流程（了解）

学习资源：

检验标准：

• 能用 PyTorch 手写一个 MLP 做 MNIST 分类
• 能解释 CNN 卷积操作的计算过程
• 能手写 Self-Attention 的代码
• 能解释 Transformer 的完整数据流
• 理解 GPT 和 LLaMA 的架构区别

2.3 PyTorch 实战（第4月）

学习内容：

基础操作：
– Tensor 操作：创建、索引、变形、广播
– 自动求导：autograd 机制
– Dataset / DataLoader 数据加载
– nn.Module 写模型
– 训练循环：forward → loss → backward → step

进阶：
– 自定义 Dataset
– 模型保存和加载（state_dict）
– GPU 训练：.to(device)
– 混合精度训练：torch.cuda.amp
– 自定义 autograd Function

实战项目：

项目1：MNIST 手写数字分类（MLP）
项目2：CIFAR-10 图像分类（ResNet）
项目3：手写一个简化版 Transformer 做文本分类

学习资源：

检验标准：

• 能独立写训练代码，不看教程
• 理解 DataLoader、Dataset 的工作原理
• 能自定义 loss function 和 layer
• 能用 GPU 跑通训练

阶段三：CUDA编程（第3-5月）

CUDA 是推理工程师的核心竞争力，也是你与大多数 AI 从业者的差异化所在。 这个阶段和深度学习阶段可以并行。

3.1 GPU 架构理解（第3月前两周）

必须理解的概念：

硬件层面：
– SM (Streaming Multiprocessor) — 流式多处理器
– CUDA Core — 基本计算单元
– Warp — 32个线程一组，GPU调度的最小单位
– 显存 (Global Memory) vs 共享内存 (Shared Memory)
– 寄存器 (Register)
– L1/L2 Cache

编程模型：
– Grid → Block → Thread 的层次关系
– Host (CPU) 和 Device (GPU) 的区别
– 内核函数 (Kernel) 的启动方式
– <<<grid, block>>> 的含义

学习资源：

3.2 CUDA 基础编程（第3-4月）

循序渐进的练习清单：

入门级（第3月）：
1. 向量加法 — 理解 grid/block/thread
2. 向量点积 — 学习 atomicAdd
3. 矩阵加法 — 二维 grid/block
4. 矩阵转置 — 理解显存访问模式
5. 一维卷积 — 学习边界处理

进阶级（第4月）：
6. 矩阵乘法（朴素版） — 理解计算和访存
7. 矩阵乘法（Shared Memory 优化） — 分块矩阵乘法
8. Softmax — 归约操作
9. Layer Normalization — 数值稳定技巧
10. ReLU / GELU 激活函数

高级（第5月）：
11. 简化版 Self-Attention — Q*K^T 和 Softmax*V
12. Flash Attention 思路 — 理解 tiling 和重计算
13. INT8 量化矩阵乘法 — 理解量化推理

每个练习的要求：

// 示例：向量加法
// 文件名：01_vector_add.cu

#include <cuda_runtime.h>
#include <stdio.h>

// Kernel: 每个线程处理一个元素
__global__ void vector_add(float *a, float *b, float *c, int n) {
int idx = blockIdx.x * blockDim.x + threadIdx.x;
if (idx < n) {
c[idx] = a[idx] + b[idx];
}
}

int main() {
int n = 1 << 20; // 100万元素
size_t bytes = n * sizeof(float);

// Host 分配内存
float *h_a = (float*)malloc(bytes);
float *h_b = (float*)malloc(bytes);
float *h_c = (float*)malloc(bytes);

// 初始化
for (int i = 0; i < n; i++) {
h_a[i] = 1.0f;
h_b[i] = 2.0f;
}

// Device 分配内存
float *d_a, *d_b, *d_c;
cudaMalloc(&d_a, bytes);
cudaMalloc(&d_b, bytes);
cudaMalloc(&d_c, bytes);

// Host → Device
cudaMemcpy(d_a, h_a, bytes, cudaMemcpyHostToDevice);
cudaMemcpy(d_b, h_b, bytes, cudaMemcpyHostToDevice);

// 启动 Kernel
int blockSize = 256;
int gridSize = (n + blockSize – 1) / blockSize;
vector_add<<<gridSize, blockSize>>>(d_a, d_b, d_c, n);

// Device → Host
cudaMemcpy(h_c, d_c, bytes, cudaMemcpyDeviceToHost);

// 验证
for (int i = 0; i < n; i++) {
if (h_c[i] != 3.0f) {
printf("Error at %d: %f\\n", i, h_c[i]);
break;
}
}
printf("Vector add passed!\\n");

// 释放
cudaFree(d_a); cudaFree(d_b); cudaFree(d_c);
free(h_a); free(h_b); free(h_c);
return 0;
}

// 编译：nvcc -o vector_add 01_vector_add.cu
// 运行：./vector_add

学习资源：

3.3 CUDA 性能优化（第5月）

优化技巧清单：

内存优化：
– Coalesced Memory Access（合并访存）
– Shared Memory 使用和 bank conflict
– 常量内存 (Constant Memory)
– 内存拷贝优化：pinned memory

计算优化：
– Occupancy（占用率）优化
– Warp 级原语：__shfl_sync, warp reduce
– 循环展开 (Loop Unrolling)
– 指令级并行

分析工具：
– nvprof / Nsight Systems — 性能分析
– Nsight Compute — kernel 级分析
– Roofline 模型 — 判断计算瓶颈还是访存瓶颈

Roofline 模型理解：

╱ 峰值计算性能
╱
╱ ← 计算密集区（Compute-bound）
╱
╱
─────╱────── 访存带宽上限
╱
╱ ← 访存密集区（Memory-bound）
╱

算术强度 = FLOPs / Bytes
– 算术强度 > 峰值比 → Compute-bound → 优化计算
– 算术强度 < 峰值比 → Memory-bound → 优化访存

检验标准：

• 能分析一个 kernel 的瓶颈是计算还是访存
• 能用 Shared Memory 优化矩阵乘法（比朴素版快 5x+）
• 能用 nvprof/Nsight 做性能分析
• 理解 bank conflict 和 coalesced access

3.4 Codeforces 进阶（第3-5月目标）

目标： 1400-1600 分

新增重点：
– 动态规划（背包、区间DP、状态压缩DP）
– 图论（BFS、DFS、最短路、拓扑排序）
– 二分查找 / 二分答案
– 数据结构：优先队列、并查集

每日任务：1-2题（1200-1600难度）
每周参加：至少1次比赛

阶段四：推理框架（第5-7月）

4.1 TensorRT（第5-6月，重点）

TensorRT 是 NVIDIA 的推理优化引擎，推理工程师必须掌握。

学习路线：

第5月：基础
1. ONNX 基础
– 什么是 ONNX，为什么需要模型转换
– PyTorch → ONNX 导出（torch.onnx.export）
– Netron 可视化模型结构

2. TensorRT 入门
– 安装和环境配置
– trtexec 命令行工具使用
– ONNX → TensorRT Engine 转换
– FP32 / FP16 / INT8 精度对比

3. TensorRT API
– Builder / Network / Engine / Context
– 用 C++ API 构建推理 pipeline
– Dynamic Shape 处理
– 批处理推理

第6月：进阶
4. TensorRT 图优化
– 算子融合（Conv+BN+ReLU → 一个kernel）
– 常量折叠
– 层间融合策略
– 查看优化后的网络结构（Polygraphy）

5. TensorRT 量化
– PTQ（训练后量化）流程
– QAT（量化感知训练）概念
– Calibration 校准过程
– INT8 量化精度评估

6. TensorRT Plugin
– 为什么需要自定义 Plugin
– Plugin 接口实现
– 编写一个自定义算子的 Plugin

实战项目：

项目1：ResNet-50 TensorRT 部署
– PyTorch → ONNX → TRT Engine
– 对比 FP32 / FP16 / INT8 精度和速度
– 写 benchmark 报告

项目2：BERT TensorRT 部署
– 文本分类任务
– Dynamic Shape 处理变长输入
– 量化并评估精度变化

学习资源：

4.2 ONNX Runtime（第6月，了解）

学习内容：
– ONNX Runtime 架构
– EP (Execution Provider) 机制
– 用 ORT 部署 PyTorch 模型
– 对比 ORT 和 TensorRT 的差异

适用场景：
– 需要跨平台部署（非 NVIDIA 硬件）
– 快速部署，不需要极致性能

4.3 模型服务化部署（第7月）

学习内容：

1. Triton Inference Server
– 模型仓库配置
– 模型版本管理
– Dynamic Batching
– 多模型并发服务
– 性能监控

2. 自建推理服务
– gRPC / HTTP API 设计
– 请求队列和批处理
– 负载均衡
– 错误处理和重试

3. 容器化部署
– Dockerfile 编写（CUDA 基础镜像）
– Docker Compose 编排
– K8s 基础概念（了解）

实战：
– 用 Triton 部署 TRT Engine
– 用 FastAPI 自建一个简单的推理服务
– 写 Dockerfile 打包
– 用 wrk / locust 做压力测试

4.4 Codeforces 进阶（第5-7月目标）

目标： 1600-1800 分

新增重点：
– 线段树 / 树状数组
– 高级 DP：数位DP、树形DP
– 字符串：KMP、哈希
– 数论：质数筛、快速幂、组合数学
– 构造题

每日任务：1-2题（1500-1800难度）
每周参加：Div2 比赛，稳定做出 A-D

阶段五：大模型推理优化（第7-9月）

5.1 大模型推理的核心问题

大模型推理 vs 小模型推理的区别：

小模型（ResNet/BERT）：
– 模型小，显存不是瓶颈
– 可以用大 batch 提升吞吐
– TensorRT 直接搞定

大模型（LLaMA-7B/13B/70B）：
– 模型太大，一张卡装不下 → 需要多卡并行
– 自回归生成，每生成一个token都要跑一次前向 → 延迟敏感
– KV Cache 占大量显存 → 需要显存管理优化
– 请求长度不一 → 需要动态批处理

5.2 大模型量化（第7月）

量化方法：

基础量化：
– FP32 → FP16 / BF16（几乎无损，必做）
– FP16 → INT8（PTQ，有一定精度损失）

大模型专用量化：
– GPTQ（逐层量化，基于二阶信息）
– 原理：逐层最小化量化误差
– 工具：AutoGPTQ
– 效果：4bit 量化，精度损失小

– AWQ（激活感知量化）
– 原理：保护重要权重通道
– 效果：比 GPTQ 在某些场景更好

– SmoothQuant（平滑量化）
– 原理：将激活的量化难度转移到权重
– 适合 W8A8 场景

– GGUF（llama.cpp 格式）
– CPU 推理友好
– 多种量化级别（Q4_0, Q4_K_M, Q5_K_M…）

实战：

1. 用 AutoGPTQ 量化 LLaMA-7B 为 4bit
2. 用 AWQ 量化同一个模型
3. 对比量化前后的：
– 模型大小
– 推理速度（tokens/s）
– 显存占用
– 精度评估（用 perplexity 或下游任务）
4. 写一篇量化对比报告

5.3 推理引擎（第7-8月）

vLLM（重点学习）

vLLM 核心技术：
1. PagedAttention
– 传统 KV Cache：连续内存分配 → 内存碎片化、浪费
– PagedAttention：将 KV Cache 分页管理
– 类似操作系统的虚拟内存分页
– 效果：显存利用率提升 2-4x

2. Continuous Batching
– 传统 Static Batching：等所有请求完成才返回
– Continuous Batching：请求完成即返回新请求加入
– 效果：吞吐量提升 2-3x

3. 调度策略
– 先来先服务 (FCFS)
– 最短作业优先 (SJF)

学习方法：
– 读 vLLM 源码，重点看：
– vllm/model_executor/ — 模型执行
– vllm/core/scheduler.py — 调度器
– vllm/attention/ — Attention 实现
– 动手部署一个 7B 模型
– 用 benchmark 脚本测试不同配置的性能

TensorRT-LLM

学习内容：
– TRT-LLM 架构
– 模型构建流程
– In-flight Batching
– Tensor Parallel 多卡推理
– KV Cache 管理
– 对比 vLLM 的差异

实战：
– 用 TRT-LLM 部署 LLaMA-7B
– 对比 vLLM 和 TRT-LLM 的性能

5.4 多卡推理（第8月）

并行策略：

1. Tensor Parallel（张量并行）
– 将一层的权重矩阵切分到多张卡
– 每层计算需要通信（AllReduce）
– 适合同一台机器的多卡

2. Pipeline Parallel（流水线并行）
– 将模型不同层放在不同卡上
– 像流水线一样处理不同 micro-batch
– 适合跨机器

3. Expert Parallel（专家并行）
– MoE 模型专用
– 不同专家放在不同卡上

实战：
– 用 vLLM 跑 Tensor Parallel 2/4卡推理
– 理解通信开销和扩展效率

5.5 自定义 CUDA Kernel（第8-9月）

这是拉开差距的关键：

项目：手写一个优化的 Attention Kernel

步骤：
1. 朴素版 Self-Attention（PyTorch 实现）
2. 朴素版 CUDA Kernel
3. Shared Memory 优化
4. Flash Attention 思路：tiling + online softmax
5. 对比 PyTorch 原生实现的性能

进阶：
– 写一个融合的 LayerNorm + Linear kernel
– 写一个 RoPE 位置编码的 CUDA kernel
– 写一个 INT8 GEMM kernel

学习资源：

5.6 Codeforces 进阶（第7-9月目标）

目标： 1800-2000 分

新增重点：
– 网络流（最大流、最小割）
– 高级数据结构：平衡树、字典树
– 计算几何基础
– 高级数论：扩展欧几里得、中国剩余定理
– Div1 A-B 稳定 AC

每日任务：1题（1700-2000难度）+ 比赛

阶段六：项目实战（第9-10月）

核心项目（选2-3个做到可以写在简历上）

项目一：大模型量化部署全流程

目标：将一个 7B 参数的大模型量化部署，实现高吞吐推理

技术栈：PyTorch + AutoGPTQ/AWQ + TensorRT-LLM/vLLM + FastAPI

步骤：
1. 用 GPTQ/AWQ 将模型量化为 4bit
2. 用 vLLM 或 TRT-LLM 部署量化模型
3. 实现 Continuous Batching 推理服务
4. 用 FastAPI 包装 HTTP API
5. 压力测试：不同并发下的吞吐和延迟
6. 对比不同量化方案的性能

产出：
– GitHub 代码仓库（README 要写好）
– 性能报告：吞吐、延迟、显存、精度对比
– 技术博客：记录完整过程和踩坑经验

GitHub README 应包含：
– 项目介绍和动机
– 架构图
– 快速开始指南
– Benchmark 数据
– 技术细节说明

项目二：自定义 CUDA Kernel 优化

目标：手写优化的 Attention / LayerNorm kernel，超过 PyTorch 原生实现

技术栈：CUDA C++ + PyTorch C++ Extension

步骤：
1. 实现朴素版 CUDA kernel
2. 用 Nsight Compute 分析瓶颈
3. 逐步优化：Shared Memory → 合并访存 → Warp 级操作
4. 封装为 PyTorch 自定义算子
5. 在实际模型中替换原生算子，测试端到端加速

产出：
– GitHub 代码仓库
– 优化过程文档：每一步的性能对比
– 技术博客：CUDA kernel 优化实战

项目三：端到端推理服务系统

目标：搭建一个完整的模型推理服务，包含监控和自动扩缩

技术栈：Docker + Triton/FastAPI + Prometheus + Grafana

步骤：
1. 模型转换和优化（TRT Engine）
2. 推理服务开发（gRPC + HTTP）
3. 请求队列和批处理
4. Docker 容器化
5. 监控指标：QPS、延迟P99、GPU利用率
6. 压力测试和性能调优

产出：
– 完整的项目代码
– Docker Compose 一键部署
– Grafana 监控面板截图
– 性能测试报告

项目展示

每个项目的 GitHub 仓库要求：
✓ 清晰的 README（英文优先）
✓ 代码注释到位
✓ 有 benchmark 数据
✓ 有架构图或流程图
✓ License 文件
✓ .gitignore 配置好

技术博客要求：
✓ 发布在掘金 / 知乎 / 个人博客
✓ 图文并茂，有代码片段
✓ 写清楚问题 → 方案 → 结果
✓ 有数据对比（表格或图表）

阶段七：求职准备（第10-12月）

7.1 简历优化

简历结构（推荐顺序）：

1. 技术技能
– 语言：C/C++（熟练）、Python（熟练）、CUDA（熟练）
– 框架：TensorRT、vLLM、PyTorch、ONNX Runtime
– 工具：Docker、Linux、Git、Nsight Compute
– 领域：模型量化、推理优化、大模型部署

2. 项目经历（最重要的部分）
– 每个项目：背景 → 技术方案 → 个人贡献 → 量化成果
– 示例：
"使用 GPTQ 将 LLaMA-7B 量化为 4bit，通过 vLLM 部署，
实现吞吐量 3.2x 提升，显存占用降低 60%，延迟 < 100ms"

3. 竞赛 / 开源贡献（如有）
– Codeforces Rating: XXXX
– GitHub 开源项目

4. 教育背景（放在最后）
– 学校、专业、时间
– 不需要写 GPA（如果不高的话）

关键原则：
– 学历放在简历最后
– 项目和技术放在最前面
– 用数据说话（提升 X%、降低 Y%、支持 Z QPS）

7.2 面试准备

算法面试

你的 CF 功底在这里发挥巨大作用

重点准备类型：
– 数组/字符串：滑动窗口、双指针
– 链表：反转、合并、环检测
– 树：遍历、LCA、路径和
– 图：BFS/DFS、最短路、拓扑排序
– 动态规划：背包、区间、状态压缩
– 设计题：LRU Cache、线程池

平台：
– LeetCode Hot 100
– Codeforces 分类刷题

推理优化面试题

高频问题：

基础概念：
Q: TensorRT 做了哪些图优化？
A: 算子融合（Conv+BN+ReLU）、常量折叠、冗余层消除、
层间融合、Kernel Auto-tuning

Q: FP16 和 INT8 量化有什么区别？
A: FP16 几乎无损，INT8 有精度损失但速度更快、
显存更省。INT8 需要 calibration。

Q: 什么是算子融合？为什么能加速？
A: 将多个连续操作合并为一个 kernel，减少显存读写
次数和 kernel launch 开销。

Q: PTQ 和 QAT 的区别？
A: PTQ 训练后量化，快速但精度损失更大；
QAT 量化感知训练，需要重训但精度更好。

大模型推理：
Q: KV Cache 是什么？为什么需要？
A: 自回归生成时，之前 token 的 K/V 不需要重复计算，
缓存起来避免重复计算。减少计算量但增加显存。

Q: PagedAttention 解决了什么问题？
A: 传统 KV Cache 连续分配导致内存碎片和浪费，
PagedAttention 分页管理，类似 OS 虚拟内存。

Q: Continuous Batching 和 Static Batching 的区别？
A: Static 等一个 batch 全部完成；Continuous 请求完成
即返回，新请求可随时加入，吞吐更高。

Q: 如何分析模型推理的瓶颈？
A: 用 Nsight Systems/Compute 分析，看计算利用率
和显存带宽利用率，用 Roofline 模型判断。

CUDA：
Q: 什么是 Warp？什么是 Bank Conflict？
A: Warp 是 GPU 调度最小单位（32线程）；Bank Conflict
是 Shared Memory 访问冲突，会导致序列化。

Q: 如何优化一个 CUDA Kernel？
A: 先用 Nsight 找瓶颈 → 计算瓶颈就优化算法减少 FLOPs，
访存瓶颈就优化内存访问模式（coalesced access、
Shared Memory）→ 提升 Occupancy。

7.3 求职策略

路径一：AI 创业公司（首选起步）
– 目标：智谱、月之暗面、MiniMax、DeepSeek、百川、零一万物
– 优势：对学历相对宽容，技术氛围好，成长快
– 投递方式：官网 + Boss直聘 + 内推
– 期望：1-2年经验后跳大厂

路径二：大厂实习转正
– 目标：字节、阿里、百度、腾讯的 AI 部门
– 优势：实习学历要求比正式岗宽松
– 方式：投实习 → 表现好 → 转正
– 注意：实习期间要主动承担有挑战的任务

路径三：技术影响力 → 内推
– 持续写技术博客
– GitHub 项目有 star
– 在技术社区活跃
– 自然会有猎头和内推找上门

投递顺序建议：
1. 先投 AI 创业公司练手（积累面试经验）
2. 再投大厂实习
3. 拿到 offer 后再考虑选择

面试时间线：
– 秋招：8-10月（提前批7月就开始）
– 春招：2-4月
– 日常实习：全年
– 建议：边学边投，不要等"完全准备好"

每日时间分配建议

全职学习（8-10小时/天）：

08:00 – 09:30 Codeforces 刷题（1-2题）
09:30 – 09:45 休息
09:45 – 12:00 主线学习（按阶段推进）
12:00 – 14:00 午饭 + 午休
14:00 – 17:00 主线学习 / 项目实战
17:00 – 17:30 休息
17:30 – 19:00 项目实战 / 代码练习
19:00 – 20:00 晚饭
20:00 – 21:30 复习总结 + 整理笔记
21:30 – 22:00 刷 CF 题解 / 看技术文章

在职学习（3-4小时/天）：

早上 06:30 – 08:00 CF 刷题
晚上 19:00 – 21:00 主线学习
晚上 21:00 – 22:00 项目练习
周末 全天 集中学习和项目

硬件和环境要求

最低要求：
– NVIDIA GPU：RTX 3060 (12GB) 或以上
– 内存：16GB+
– 硬盘：500GB+ SSD
– 系统：Ubuntu 22.04（推荐双系统或WSL2）

推荐配置：
– NVIDIA GPU：RTX 4090 (24GB)
– 内存：32GB+
– 硬盘：1TB NVMe SSD

如果硬件不够：
– 使用 Google Colab（免费 T4 GPU）
– 使用 AutoDL / 恒源云 等 GPU 云平台（便宜）
– 大模型推理用量化模型（4bit 7B 在 12GB 显存可跑）

软件环境：
– CUDA Toolkit 12.x
– cuDNN
– Python 3.10+
– PyTorch 2.x
– TensorRT 8.x / 10.x
– Docker

学习原则

1. 先跑通再理解
不要试图一开始就理解所有原理。先用代码跑通，
看到结果，再回头理解为什么。

2. 项目驱动学习
不要只看不写。每学一个知识点，都要用代码验证。
最好的学习方式是做项目时遇到问题再查资料。

3. 不要追求完美
先完成再完美。一个能跑的项目 > 一个完美的设想。

4. 记录和输出
写技术博客、做笔记。输出是最好的学习方式。
同时为未来的简历积累素材。

5. 不要闭门造车
加入技术社区（GitHub、知乎、Discord）。
看别人怎么做的，参与讨论，接受反馈。

6. 刷题不要停
CF 每天至少1题。算法能力是面试的硬门槛。
不要等到面试前才刷。

7. 边学边投
不要等"完全准备好"。面试本身就是学习。
早面试，早知道差距在哪。

推荐资源汇总

书籍

编程基础：
《C Primer Plus》 — C语言入门
《C++ Primer》 — C++权威
《Effective Modern C++》 — C++ 最佳实践

CUDA：
《CUDA by Example》 — CUDA入门
《Programming Massively Parallel Processors》 — CUDA进阶

深度学习：
《Deep Learning》(花书) — 理论参考
《动手学深度学习》(d2l.ai) — 代码实践

推理优化：
《深入浅出 CUDA》 — 中文CUDA好书

在线课程

深度学习：
– 吴恩达 Deep Learning Specialization (Coursera)
– 李宏毅机器学习 (B站)
– Stanford CS231n (计算机视觉)
– Stanford CS224n (NLP)

CUDA：
– CUDA Programming (Udacity)
– NVIDIA DLI (Deep Learning Institute)

系统设计：
– MIT 6.824 (分布式系统)

网站和社区

刷题：
– Codeforces: https://codeforces.com
– LeetCode: https://leetcode.cn
– 洛谷: https://www.luogu.com.cn

技术社区：
– GitHub: 关注推理优化相关的仓库
– 知乎: 搜索"推理优化"、"TensorRT"、"CUDA"
– 掘金: AI工程化相关文章
– NVIDIA Developer Blog: 官方技术博客

论文追踪：
– Papers With Code: https://paperswithcode.com
– arXiv: cs.LG, cs.CL 分区

GitHub 仓库推荐

推理框架：
– https://github.com/vllm-project/vllm
– https://github.com/NVIDIA/TensorRT
– https://github.com/NVIDIA/TensorRT-LLM
– https://github.com/microsoft/onnxruntime

量化：
– https://github.com/AutoGPTQ/AutoGPTQ
– https://github.com/mit-han-lab/llm-awq
– https://github.com/ggerganov/llama.cpp

CUDA 学习：
– https://github.com/NVIDIA/cuda-samples
– https://github.com/Dao-AILab/flash-attention
– https://github.com/triton-lang/triton

大模型：
– https://github.com/meta-llama/llama
– https://github.com/QwenLM/Qwen

路线检查点

每个阶段结束时，用以下检查点自测：

□ 阶段一完成（第2月末）：
– 能用 C++ 写中等复杂度程序
– 能在 Linux 终端完成日常操作
– CF Rating ≥ 1000

□ 阶段二完成（第4月末）：
– 能用 PyTorch 训练 CNN/Transformer 模型
– 理解 Transformer 架构每一层的作用
– 能手写 Self-Attention
– CF Rating ≥ 1400

□ 阶段三完成（第5月末）：
– 能写中等复杂度的 CUDA kernel
– 能用 Shared Memory 优化 kernel
– 理解 Roofline 模型
– CF Rating ≥ 1600

□ 阶段四完成（第7月末）：
– 能用 TensorRT 部署模型并做量化
– 能搭建推理服务（Triton 或自建）
– 理解图优化和算子融合
– CF Rating ≥ 1700

□ 阶段五完成（第9月末）：
– 能独立完成大模型量化部署
– 理解 PagedAttention、Continuous Batching
– 能写优化的 CUDA kernel（Attention/LayerNorm）
– CF Rating ≥ 1800

□ 阶段六完成（第10月末）：
– GitHub 上有 2-3 个高质量推理优化项目
– 有 3-5 篇技术博客
– CF Rating ≥ 1900

□ 阶段七完成（第12月末）：
– 拿到至少一个 offer
– CF Rating ≥ 2000

最后的话：这条路不容易，但每一步都是实打实的能力积累。 不要被学历困住思维，用代码和项目证明自己。 坚持 8-12个月，你会成为一个真正稀缺的推理优化工程师。