JD Knowledge Map

In one sentence: this page maps skill keywords from hiring JDs one-to-one to this handbook's pages and knowledge points, using a "can do / can't do / sort of" three-tier labeling system to translate "role requirements" into "a personal study plan."

After reading Module Overview & Job Landscape and the JD List, you should have 2–3 target roles and their three-layer skill keywords. Now the task is: map each skill keyword to a concrete knowledge point, and grade yourself.

1. Why Use a "Can Do / Can't Do / Sort Of" Label

Most people facing a JD think "I sort of know a bit of everything" — that vagueness is the root cause of interview failures. The three-tier system forces you to give a clear answer:

• Can do: Can independently execute, explain the principles clearly, handle follow-up questions;
• Sort of: Have used it but can't explain it clearly, or understand the theory but lack hands-on experience — this is the most dangerous tier and also the one you should prioritize;
• Can't do: Never encountered it at all. Add to the study queue by priority.

The gold standard for labeling "Can do"

For a knowledge point, you must be able to do at least two of these three things to call yourself "can do": (1) explain the core principle for 10 minutes without notes; (2) write code to reproduce a minimal example; (3) articulate its trade-offs with other methods. Just "having used it" doesn't count.

2. Skill Keyword → Page Mapping Table

The table below maps high-frequency JD skill keywords to corresponding pages in this handbook (this is your study plan map — use it directly to grade yourself):

Skill Keyword	Related Knowledge Points	Handbook Page	Category
Transformer / Attention	Self-Attention, multi-head, positional encoding	Transformer Architecture, Attention Mechanism	Architecture
Backpropagation	Chain rule, automatic differentiation	Backpropagation & Automatic Differentiation	Fundamentals
Neural Network Fundamentals	Forward pass, layers, loss	Neural Network Fundamentals, Loss Functions & Output Layers	Fundamentals
Training Optimization	Gradient descent, Adam, LR scheduling	Optimization & Gradient Descent, Training Recipes & Hyperparameter Tuning	Training
Initialization & Normalization	Xavier, BN/LN	Initialization & Normalization	Training
Overfitting & Regularization	Dropout, weight decay, early stopping	Overfitting & Regularization	Training
Evaluation Metrics	Precision/recall/F1, AUC, NDCG	Deep Learning Evaluation & Experimentation, Evaluation in Practice	Evaluation
Data Engineering	Data cleaning, annotation, imbalance handling	Data & Data Engineering, Datasets & Tool Archive	Data
CNN	Convolution, pooling, receptive field	CNNs & Computer Vision	Architecture
RNN / Sequence Modeling	LSTM, GRU, sequence tasks	RNN & Sequence Modeling	Architecture
LLM Fine-tuning	Instruction fine-tuning, LoRA, alignment	Large Language Models (LLMs)	LLM
RAG	Retrieval, vector DBs, augmented generation	Large Language Models (LLMs)	LLM
Multimodal	Image-text alignment, fusion	Multimodal Models	Direction
Generative Models	VAE, GAN, diffusion models	VAE & GAN, Diffusion Models & Generative AI	Direction
Reinforcement Learning	MDP, policy gradient, applications	Deep Reinforcement Learning, Deep RL Applications	Direction
Recommender Systems	CTR prediction, recall & ranking	Deep Learning Recommender Systems	Direction
Graph Neural Networks	Graph convolution, message passing	Graph Neural Networks	Direction
Speech & Audio	Acoustic modeling, ASR/TTS	Speech & Audio	Direction
Pre-training & Representation Learning	Self-supervised, pre-training paradigms	Representation Learning & Pre-training	Fundamentals
Deployment	Serving, inference optimization	MLOps & Model Deployment	Engineering
Distributed Training	Data parallel, hybrid parallel	Training Recipes & Hyperparameter Tuning	Engineering
Debugging & Diagnosis	Exploding/vanishing gradients, NaN	Debugging & Diagnosis, Common Pitfalls & Anti-patterns	Engineering
Framework Selection	PyTorch/JAX/framework comparison	How to Choose Frameworks & Tools	Engineering
Interpretability & Fairness	Explainability, bias	Interpretability & Fairness	Engineering
Hands-on Practice	Building from scratch, portfolio	Building a Deep Learning Project from Scratch, Portfolio Projects	Practice
Paper Reading Skills	Paper reading methods, frontiers	Getting Started, Frontier Progress	Research

How to use this table

This table only includes knowledge points that "need dedicated study." If you've already systematically studied a corresponding page through the Learning Paths, just mark it as "can do" — no need to re-study.

3. Generating a Study Plan: Three-Step Method

Step 1: Grade Yourself

Compare the table above with each skill keyword appearing in your target role's JD, labeling each as "can do / sort of / can't do." Focus on the JD's hard requirements — the bonus qualifications can be filled in later; the threshold layer must be prioritized.

Example (LLM Application Engineer):

Skill Keyword	Label	Rationale
Transformer	Sort of	Can call the API but can't explain the attention formula
PyTorch	Can do	Built complete training scripts independently
Distributed Training	Can't do	Only run on single GPU locally
LLM Fine-tuning	Sort of	Ran LoRA but don't understand the principle

Step 2: Prioritize

Order by priority from high to low:

1. Threshold + Can't do: Highest priority — may directly determine whether your resume passes screening;
2. Threshold + Sort of: Second priority — filling in the "can explain clearly" capability;
3. Bonus + Can't do / Sort of: Fill in if time allows — determines whether you can stand out.

Within the same priority, order by "study cost → high": reading a concepts page > running a notebook > building a complete project. Use the Progressive Tutorial: Three Versions Running to warm up before tackling harder knowledge points.

Step 3: Generate Study Order

Write the prioritized results into a checklist with deadlines, for example:

Order	Knowledge Point	Target Page	Success Criteria	Timeline
1	Attention Mechanism	Attention Mechanism	Can derive softmax(QKᵀ/√d)V by hand	Week 1
2	Training Optimization	Optimization & Gradient Descent	Can explain the difference between Adam and SGD	Weeks 1–2
3	LLM Fine-tuning	Large Language Models (LLMs)	Run LoRA fine-tuning on an open-source model	Weeks 3–4
4	Distributed Training	Training Recipes & Hyperparameter Tuning	Understand and reproduce the DataParallel example	Weeks 5–6

4. Study Focus for Three Typical Profiles

Profile A: Career Changer / Beginner

Background: Knows Python, halfway through the DL fundamentals pages. Study focus: Master the three pages on Neural Network Fundamentals, Backpropagation & Automatic Differentiation, and Optimization & Gradient Descent, with code reproduction. Then pick one case-study page for a project based on your target direction. Don't chase LLMs right away — without a solid foundation, your resume and interviews will fall apart under follow-up questions.

Profile B: CS/ML Graduate Student

Background: Has taken courses, reads papers, but lacks hands-on practice. Study focus: Move "sort of" and engineering skills forward — Training Recipes & Hyperparameter Tuning, Debugging & Diagnosis, MLOps & Model Deployment; simultaneously use the Paper Map to connect classic papers in your field into a system, preparing for the "research deep-dive" section of interviews.

Profile C: Software Engineer Pivoting to Algorithm

Background: Strong at coding, weak in ML theory. Study focus: Build Math Primer, Loss Functions & Output Layers, and Deep Learning Evaluation & Experimentation — these are "frequently asked in interviews but rarely used in engineering." Your strength (engineering ability) should be reflected in quantified results on your resume — see Capability Match.

5. Self-Assessment During Study

After finishing each knowledge point, go to the Interview Question Bank and self-test with related questions:

• Can you talk about it for 3 full minutes without notes?
• Can you answer a "why not use another method?" follow-up?
• Can you write a minimal code example under 20 lines?

If you pass all three, change the skill keyword from "in progress" to "can do." In this way, your study plan itself becomes your career progress tracker — more controllable than blindly grinding problems.

Further Reading

• JD List: Open Roles at Major Domestic and Overseas Companies — Where skill keywords come from
• Capability Match: What to Highlight in Your Resume — How to write study outcomes into your resume
• Interview Question Bank — How each knowledge area is tested in interviews
• Learning Paths: Three Routes — Overall plan for systematic study
• Portfolio Projects — Turn study outcomes into projects
• Math Primer — A refresher tool for math follow-up questions in interviews

References

• PyTorch Official Tutorials: Deep Learning with PyTorch (continuously updated)
• Hugging Face Learning Resources: NLP Course (continuously updated)
• d2l.ai. Dive into Deep Learning (Li Mu et al., 2023)