Learn AI: concepts and learning guide

Start with the foundations

• Supervised Learning
• Unsupervised Learning: When There Are No Human Labels, Structure Comes from Assumptions
• Reinforcement Learning: Learning Decision Policies from Delayed Feedback
• Neural Network
• Gradient Descent: How Direction, Step Size, and Noise Together Shape Learning

Understand language models

• Tokens and Tokenization: The Discrete Language That Models Actually Read and Write
• Embedding
• Attention Mechanism
• Transformer
• Large Language Model (LLM)

Build with AI

• Prompt Engineering
• RAG Retrieval-Augmented Generation
• Retrieval and Semantic Search
• Tool Calling / Function Calling
• AI Agent

All concept explanations

130 reading pages. Each page links to its available translation.

• Clustering: Similarity, Cluster Shape, and Use Case Jointly Determine Grouping

  From manual K-means assignment–update computation to hierarchical clustering, DBSCAN, mixture models, choosing k, stability, and business interpretation.

• Constitutional AI: Using Explicit Principles to Guide Critique, Revision, and Preference Learning

  From principle text, contextual interpretation, and conflict priority to AI feedback training, understand how to reduce per-example human labels and why principle selection remains a governance issue.

• The Curse of Dimensionality: Why Data Rapidly Becomes Sparse as Space Grows

  Understanding the necessity of high-dimensional retrieval, density estimation, and dimensionality reduction through exponential volume growth, distance concentration, and sample complexity.

• Decision Trees and Ensemble Methods: Combining Nonlinear Decisions with Split Rules

  From impurity, information gain, and pruning to random forests and gradient boosting, understand the advantages of tree models for tabular data and the risk of leakage.

• Dimensionality Reduction: Preserving Task-Required Structure with Fewer Coordinates

  Understand compression objectives, visualization distortion, data leakage, and downstream evaluation through PCA, random projection, t-SNE, UMAP, and autoencoders.

• Recurrent Neural Network (RNN): Compressing History into a Continuously Updated State

  From shared recurrence, time unrolling, and BPTT, to gradient multiplication, LSTM gating, teacher forcing, and streaming deployment.

• Convolutional Neural Network (CNN): Letting the Same Local Detector Scan Across Space

  From discrete convolution, weight sharing, and output shapes, to receptive fields, sampling aliasing, translation equivariance, and modern visual backbones.

• Embedding

  Turn text into vectors, making “similar meaning” become “close in distance”

• Attention Mechanism

  When processing each word, let the model decide for itself which words in the sentence to 'look at'.

• Backpropagation: Efficiently Assigning the Responsibility of One Result Back to All Parameters

  Starting from computational graphs, local derivatives, and upstream gradients, work through one complete backward traversal by hand, and understand branch accumulation, vector–Jacobian products, activation caching, and gradient checking.

• Tokens and Tokenization: The Discrete Language That Models Actually Read and Write

  From Unicode, pre-tokenization, BPE/Unigram, byte fallback, and special tokens, understand why the same text yields different lengths, different costs, and different capability boundaries.

• Batch Normalization: Stabilizing Channel Scale with Batch Statistics

  From the statistical axes of convolutional tensors, training/inference dual paths, and running means to synchronized BatchNorm, understand why it accelerates many visual networks and why it fails with small batches, domain shift, and deployment fusion.

• Fine-tuning

  Continue training on a pre-trained “generalist” to turn it into a task-specific “specialist”

• Knowledge Distillation: Making a Small Student Approach the Teacher's Conditional Distribution and Behavior

  From soft labels, temperature, and KL, to token/sequence/feature distillation, coverage gaps, capacity limits, and bias inheritance.

• Context Window

  The maximum total number of tokens a model can “see” at once

• PEFT / LoRA: Freezing the backbone, learning only low-rank weight increments

  From ΔW=BA, rank, and scaling, to trainable parameter accounting, QLoRA, target modules, merged versions, and multi-adapter interference.

• Pre-training

  Self-supervised learning on massive unlabeled text, instilling “general capabilities” into the model in one go

• Quantization: Compressing Continuous Parameters onto a Finite Lattice

  From scale, zero-point, and rounding error, to granularity, outliers, PTQ/QAT, weights/activations/KV, and hardware kernels.

• Post-training

  Pre-training provides capabilities; post-training determines how those capabilities are invoked and presented.

• Normalization: Controlling Representation Scale, Stabilizing Deep Optimization

  From LayerNorm's centering and RMSNorm's root-mean-square scaling, to Pre-Norm/Post-Norm and implementation acceptance, understand exactly which axis normalization computes statistics along, what it retains, and what it discards.

• Optimizers and Learning Rate Schedules: Turning Instantaneous Gradients into a Controllable Training Trajectory

  From the state updates of SGD, Momentum, Adam, and AdamW, to warm-up, plateau, decay, batch size, and mixed precision; understand why a training recipe must be tuned as a whole.

• Loss Function: Turning ‘Where It Went Wrong’ into a Learnable Direction

  From business cost to a differentiable proxy, from single-sample error to empirical risk; using the same numerical example, see how the loss, gradient, and parameter update connect into a closed loop.

• Self-supervised Learning: Letting Data Generate Its Own Training Targets

  A unified understanding of autoregression, masked reconstruction, contrastive learning, and self-distillation, and tracing how pretext objectives transfer, take shortcuts, or become misaligned.

• Positional Encoding and RoPE: Making Attention Know Order and Distance

  From permutation equivariance, sinusoidal absolute positions, and relative bias to rotary position embeddings, understand how order enters attention and why long-context extension is not simply changing a window number.

• Vanishing and Exploding Gradients: How Depth Turns Local Derivatives into Exponential Effects

  From scalar products to matrix Jacobians, from sigmoid saturation to RNN unrolling over time; use numerical examples to understand how initialization, gating, residuals, normalization, and gradient clipping each change which segment of the path.

• Contrastive Learning: Using Positive and Negative Pairs to Shape Representation Space

  From InfoNCE, temperature, and gradient direction, to augmentation invariance, large batches, false negative samples, representation collapse, and transfer validation.

• CLIP: Using image–text contrast to align two modalities into the same space

  From dual encoders, a normalized similarity matrix, and symmetric cross-entropy, to zero-shot classification, retrieval, compositional relations, and bias boundaries.

• System Prompts: Declare Behavioral Contracts in Probabilistic Models, Not Security Boundaries

  From message sequences, instruction priority, conflict resolution, and context assembly to injection, leakage, versioning, and contract testing—understand what system prompts can control.

• Context Engineering: Designing the Information the Model Can Actually See at This Moment

  Treat prompts, retrieved evidence, tool results, memory, and historical messages as an information system under a limited budget, rather than cramming all the text into the window.

• Assistant Response Prefilling: Letting the Model Continue from a Given Answer Prefix

  Understand how the assistant prefix changes the conditional distribution, and strictly distinguish it from input prefill, prompt caching, and constrained decoding.

• Structured Outputs: Connecting Probabilistic Text to Deterministic Software Contracts

  From minimal schema, constraint generation, and layered validation to version migration, limited repair, and secure execution.

• Model Selection and Cost: Finding the Minimal Viable Solution That Satisfies Constraints

  From task distribution, strong-model upper bound, and multidimensional gates, to cost per successful task, Pareto frontier, and exit strategy.

• Retrieval and Semantic Search

  Surface the most relevant snippets from a knowledge base and feed them to the model for answering.

• LLM Observability and Tracing: Reconstructing Why an AI Request Got This Result

  Use traces, spans, versions, quality signals, and minimized data to turn “occasional wrong answers” into locatable, replayable, regression-testable problems.

• Data Drift and Continuous Monitoring: When Distribution Change Actually Harms the System

  From P(x), P(y), and P(y|x) to PSI, delayed labels, proxy metrics, slice alerts, and safe response.

• Hallucination

  Fluent, confident, but fabricated — why this is structural, not 'just make it bigger'.

• AI Privacy: Controlling Identifiability, Memorization, and Unauthorized Use Along Data Flows

  From collection, prompts, retrieval, logs, vendors, to model weights, understand station by station how personal data spreads, and how to reduce risk through minimization, isolation, and verifiable deletion.

• Reflection and Self-Correction: Making Failure Evidence Change the Next Action

  Distinguish vague self-assessments, external feedback, and verifiable corrections; use minimal changes, stopping conditions, and versioned experience to avoid “thinking it over again” producing more confident errors.

• Self-consistency: Voting with Multiple Independent Reasoning Paths

  Understand sampling diversity, answer aggregation, correlated errors, cost, and confidence estimation; and distinguish majority agreement from factual correctness.

• Agent Planning: Turning Goals into Executable, Revisable State Diagrams

  Understand planning–execution separation, rolling planning, checkpoints, and local replanning through goals, preconditions, artifacts, and completion predicates.

• Agent Frameworks: Abstract the Run Loop, but Don't Outsource Correctness and Control

  From model adaptation, tool registration, state graphs, persistence, and tracing, to abstraction leaks, version migration, and escape hatches, determine when a framework is worth adopting.

• Agent Memory: Writable, Findable, and Correctable External State

  Separate conversational context, working state, episodic records, and long-term facts; understand writing, integration, retrieval, forgetting, conflict, and privacy governance.

• Code Generation / AI Coding

  Let models write code, from completing a line to implementing an entire feature.

• Multi-agent Systems: Organizing Complex Tasks with Boundaries, Parallelism, and Independent Verification

  From task dependency graphs, communication topologies, and shared state to critical paths, handoff losses, and common-source errors, determine when multi-agent truly outperforms single-agent.

• Human-in-the-loop: put scarce human judgment at the points where it can change risk

  From risk stratification, escalation thresholds, review interfaces, and queue capacity to automation bias and feedback sampling, design a human-machine loop that truly reduces harm.

• Workflow Orchestration: Carrying Probabilistic Models with Persistent State and Deterministic Control

  From DAGs, state machines, and durable execution, to idempotency, retries, compensation, version migration, and human tasks, build recoverable, auditable AI processes.

• Flow Matching: Directly Learning the Velocity Field That Continuously Transports Noise to Data

  From probability paths, conditional and marginal velocities, to straight-line paths, ODE sampling, numerical error, coupling design, and the relationship with diffusion/continuous flows.

• Variational Autoencoder (VAE): Compressing Data with a Sampleable Probabilistic Latent Space

  From the encoding distribution, reparameterization, and the ELBO, to the KL–reconstruction trade-off, posterior collapse, latent-space interpolation, and limits of generation quality.

• Generative Adversarial Network (GAN): Letting the Generator Learn the Data Distribution Against a Dynamic Discriminator

  From minimax games, optimal discriminators, and JS divergence, to non-saturating loss, mode collapse, training oscillation, Wasserstein distance, and evaluation boundaries.

• AI Content Detection and Provenance: Distinguishing Statistical Guesses, Watermark Signals, and Signature Origins

  From base rates, ROC, and calibration, to distribution drift in model fingerprints, robust watermarking, C2PA-style signature manifests, chained edits, and “no signal does not equal human creation.”

• AI Red Teaming: Using Threat Models to Systematically Find Failure Chains That Can Cause Real Impact

  From assets, attackers, and attack surfaces, to test cases, evidence, remediation regression, and residual risk, understand why red teaming is not about collecting a few jailbreak prompts.

• Data Poisoning: How Attackers Use a Small Amount of Training Signal to Change a Model's Specific Behavior

  Distinguish availability disruption, targeted misclassification, clean-label attacks, and backdoors, and trace from poisoning rates and gradient influence to data lineage, training-time detection, and trigger evaluation.

• Adversarial Robustness: Seeking the worst case within an explicit perturbation set, not claiming the model is “attack-proof”

  From decision boundaries, FGSM/PGD, robust optimization and certified radius, to adaptive attacks, out-of-distribution transformations and system-level loss control, understand the applicable domain of guarantees.

• AI Alignment

  Making model behavior align with human intentions and values

• Reasoning Models

  Use more training and inference compute for search, verification, and correction in exchange for accuracy on hard problems.

• Reranking: Making Fine-Grained Relevance Judgments Among High-Recall Candidates

  Understand two-tower retrieval, cross-encoders, late interaction, Large Language Model (LLM) reranking, and position bias, and design evaluation from Recall@k to end-to-end answers.

• Advanced RAG: Making Retrieval a Diagnosable, Iterative Evidence Process

  From query rewriting, hybrid retrieval, reranking, multi-hop, corrective retrieval, and answer citation, understand when to upgrade basic RAG.

• Controllable Generation: Decomposing “what it looks like” into multi-channel conditions of semantics, structure, identity, and constraints

  From conditional probability and classifier-free guidance, to edges, depth, pose, segmentation, reference images, multi-condition conflicts, control strength, and verifiable control.

• Audio Generation: Modeling Temporal Structure across Waveforms, Spectrograms, and Discrete Codecs

  From sampling rate, neural codecs, and multi-codebook tokens to autoregressive/diffusion generation, text and melody conditioning, long-range musical structure, and subjective evaluation.

• Reward Hacking: The System Achieves the Metric but Deviates from the True Goal

  Starting from the gap between goals and proxy metrics, identify specification gaming, evaluator overfitting, and feedback tampering, and reduce risk through independent evaluation and layered defenses.

• Code Execution and Sandboxing: Let the Model Compute, but Don’t Hand Over the Host to It

  Understand where the generate–execute–observe loop’s capabilities come from, and the isolation boundary made up of processes, files, network, resources, credentials, and human authorization.

• Computer-Use Agent: Closing the Loop Between Observation, Action, and State Verification

  From action grounding in screenshots, the DOM, and the accessibility tree, to focus, idempotency, permissions, and recovery, understand why 'knowing how to click buttons' is far from reliably completing tasks.

• Constrained Decoding: Using Automata to Set Illegal Token Probabilities to Zero

  From JSON Schema, grammar states, and tokenizer boundaries to dead ends, complexity, streaming output, and semantic validation.

• Streaming Output: Turning One Generation into a Cancelable, Resumable Event Protocol

  From tokens, UTF-8 byte chunks, and SSE events, to TTFT, backpressure, structural buffering, safety review, and final commit.

• AI Deployment: Turning Offline Capability into a Capacity-Measurable, Canary-Releasable, and Rollbackable Service

  From runtime location, queuing and batching, to version release, idempotent side effects, degradation, and incident response.

• Distributed Training: Split along the Four Axes of Data, Tensor, Pipeline, and State

  From global batch and all-reduce, to tensor parallelism, pipeline bubble, ZeRO/FSDP, 3D parallelism, and fault checkpointing.

• World Models: Predicting the World After Actions in Internal States

  From state representations, transition and reward models, to imagined rollouts, model predictive control, uncertainty, and model exploitation, understand how “trying things out in the mind” helps and misleads agents.

• Lost in the Middle: When context fits, why might the model still fail to find it?

  Understand position effects in long contexts, learn to measure them with controlled experiments, and use retrieval, reordering, and structural design to reduce the probability that key evidence is ignored.

• Model Families: Understanding Capability Boundaries from Information Flow and Training Objectives

  Instead of memorizing brand rankings, use four axes—architecture, objectives, modality, and product layer—to judge why a model excels at a particular type of task.

• Model Merging: Combining Weight Deltas in a Shared Coordinate System

  From checkpoint averaging, model soups, and task vectors, to permutation alignment, sign conflict, TIES/DARE, coefficient search, and safety regression.

• Mixture of Experts (MoE): Have each token activate only a few feed-forward networks

  From top-k routing and weighted outputs, to load balancing, capacity overflow, all-to-all, expert specialization, and inference batching.

• Sampling and Decoding Parameters: From Logits to Final Sequence

  Use a set of hand-computable candidate distributions to tie together temperature, top-k, top-p, repetition penalty, stopping conditions, and random seed, and understand which step each knob changes and what it cannot guarantee.

• Tree of Thoughts (ToT): Searching and Backtracking Across Multiple Intermediate Solutions

  Understand states, candidate generation, value evaluation, BFS/DFS, pruning, and search budget, and distinguish between expanding the search space and getting the answer right.

• Unsupervised Learning: When There Are No Human Labels, Structure Comes from Assumptions

  Using clustering, dimensionality reduction, density estimation, and generative modeling to understand the objective design, non-uniqueness, Pseudo-structure, and validation when there is “no standard answer”.

• Agent Identity, Authorization, and Secrets Management

  The model states intent; the controlled execution layer proves who can perform which action on what.

• AI Coding Tools: The Evidence Closed Loop from Repository Understanding to Patch Verification

  From search, call-chain localization, and minimal edits to testing, diff review, working tree protection, and safe rollback, understand why repository-level agents are more than code generation.

• ReAct: Closing the Loop on Reasoning, Action, and Observation

  Use external evidence to revise assumptions instead of letting a reasoning chain run its course unsupported

• MCP Architecture: Enabling the MCP Host to Connect External Capabilities Within an Isolation Boundary

  From MCP Host–MCP Client–MCP Server, JSON-RPC, capability negotiation, and three types of primitives, understand what MCP standardizes, and who remains responsible for authorization and execution security.

• Agent Skills: Packaging repetitive tasks into discoverable, verifiable, and governable capability packages

  From trigger descriptions, progressive disclosure, scripts and assets, to selection confusion, permissions, versions, and regressions, understand the boundaries between skills, prompts, tools, and workflows.

• AI Agent

  From “one question, one answer” to “give it a goal and it gets the whole thing done on its own”

• Large Language Model (LLM)

  From “predicting the next word” to “conversing like an assistant”

• Bias and Fairness: First Choose the Relationship to Protect, Then Compute Group Differences

  Use the same hiring example to understand representational bias, label bias, proxy variables, demographic parity, equal opportunity, calibration, and the boundaries where they cannot all be satisfied simultaneously.

• RLHF and Preference Alignment: Turning “What People Prefer” into a Trainable Signal

  From demonstration data, preference comparisons, reward models, to policy optimization, understand what RLHF optimizes and why it cannot be equated with “making the model absolutely safe.”

• Context Compaction: Preserving Decision-Relevant Information Within a Token Budget

  Understand the lossy nature of truncation, summarization, extraction, retrieval, and prompt compression, and design must-not-drop constraints, source tracking, and compaction regression.

• Chain of Thought (CoT)

  Have the model write out step-by-step reasoning before giving an answer—more accurate on complex problems

• Overfitting: How models mistake chance in a finite sample for regularity

  Starting from the separation of empirical risk and unknown risk, learn to read training/validation curves, recognize leakage, repetition, and tuning contamination, and understand the boundaries of capacity, double descent, and large model memorization.

• Reinforcement Learning: Learning Decision Policies from Delayed Feedback

  Use MDPs, returns, value functions, Bellman equations, exploration, and policy gradients to understand how an RL agent optimizes long-term outcomes through interaction.

• Gradient Descent: How Direction, Step Size, and Noise Together Shape Learning

  Starting from one-dimensional slopes and directional derivatives, work through one update by hand, then see why learning rate, curvature, mini-batch, momentum, and Adam change the training trajectory.

• Multimodal Models

  One model that understands images, sounds, and text all at once.

• Regularization: Constraining How Models Learn with Interpretable Preferences

  Starting from L2/L1, AdamW, Dropout, data augmentation, and early stopping, understand how four types of constraints—on parameters, representations, data, and training paths—change generalization, instead of treating regularization as a one-size-fits-all knob.

• Voice Cloning

  Split "what is said" and "who it sounds like" into two conditions, then accept using intelligibility, naturalness, speaker similarity, and authorization together

• Logprobs and Confidence: Model Preference Does Not Equal Answer Trustworthiness

  Understand when logprob is useful from token log probabilities, sequence likelihood, calibration, and selective prediction, and how tokenization and semantic equivalence mislead thresholds.

• Prompt Engineering

  Design the wording and structure of inputs so that the model consistently produces the results you want.

• Model Evaluation and Benchmarks: Turning "Stronger" into Reproducible Evidence

  From estimation target, sampling budget, and pass@k, to contamination, judge bias, confidence intervals, and release thresholds.

• Prompt Caching: Reusing KV Computation for Shared Prefixes

  From longest common token prefix, KV footprint, and hit value, to prompt ordering, routing affinity, invalidation, and tenant isolation.

• Super-resolution: Inferring high resolution from degraded observations does not equal recovering true detail.

  From blur–downsampling–noise models, pixel loss and perceptual loss, to Generative Adversarial Network (GAN)/diffusion priors, blind super-resolution, hallucination boundaries, and task-oriented evaluation.

• Speech systems: converting between text, linguistic content, speaker identity, and acoustic waveforms

  Put speech recognition, speech synthesis, and voice cloning into the same pipeline, understanding acoustic features, alignment, vocoders, streaming latency, WER, and identity authorization.

• Tool Calling / Function Calling

  Give a model that can only talk a pair of “hands” that can look things up, calculate, and do things.

• Agent Loop

  Turn a single answer into an observable, verifiable, and stoppable state machine

• Document Chunking: The Evidence Unit That Determines Retrieval Systems

  Understand fixed-length, structural, semantic, and parent-child chunking; handle overlap, context loss, tables, code, and embedding budgets.

• Citation and Evidence Alignment: Connecting Every Verifiable Claim to the Minimal Sufficient Source Text

  From atomic claims, stable anchors, and entailment judgment to citation correctness, completeness, and source quality: build a truly verifiable answer.

• Knowledge Graphs: Organizing Identity, Relationships, Time, and Evidence into Queryable Facts

  From ontologies, entity resolution, and temporal edges to path retrieval and GraphRAG, understand when graphs outperform similarity and how they propagate errors.

• RAG Retrieval-Augmented Generation

  Before answering, first retrieve relevant materials, letting the model 'answer with the book open' rather than making things up from memory.

• Diffusion Models

  Learn “to denoise from a blob of noise step by step” and “develop” the image.

• LLM Application Evaluation: Measuring Whether the Entire System Completes Real Tasks

  Break business goals into observable attributes and locate failures caused by retrieval, generation, tools, and processes.

• Training Data Governance: Making What Models Learn Traceable, Auditable, and Actionable

  From sources and licensing, lineage, filtering, deduplication, and mixing ratios, to contamination, deletion requests, training snapshots, and incident response.

• Uncertainty and Calibration: Making “80% Confidence” Really Mean About 80% Correct

  From confidence scores, reliability diagrams, and ECE to selective prediction, rejection thresholds, and distribution shift.

• AI Guardrails: Using Defense-in-Depth Controls to Limit the Blast Radius of Probabilistic Systems

  From five layers of control—input, context, output, tool, and runtime—to threshold cost, policy composition, and fault injection, understand what AI Guardrails can and cannot guarantee.

• Prompt Injection

  Hiding malicious instructions in content the model reads to hijack its behavior

• Scaling Laws: Using Power Laws to Plan Parameters, Data, and Compute

  From log-log straight lines and diminishing marginal returns to compute-optimal allocation, and then to data quality, capability thresholds, and total lifecycle cost.

• In-context Learning

  Learn a new task using just a few examples in the prompt, without changing a single parameter

• Model Interpretability: From Input Attribution to Causal Intervention, Distinguishing Story, Evidence, and Mechanism

  Comparing feature attribution, probes, counterfactuals, activation replacement, sparse features, and circuit analysis to understand fidelity, stability, completeness, and “readable does not equal true.”

• Jailbreak Attacks: Using Adversarial Instructions to Find Policy Boundaries, but System Risk Depends on Whether Assets Can Be Reached

  From direct/indirect, multi-turn, encoding, suffix optimization, and multimodal jailbreaking to threat models, base rates, defense in depth, adaptive red teaming, and false rejection of legitimate requests.

• Kernel Methods and SVM: Just Computing Similarity Can Learn Nonlinear Boundaries

  Understand the capabilities, hyperparameters, and scale limitations of linear, RBF, and polynomial kernels through maximum margin, the dual problem, and the kernel trick.

• Model Routing and Cascades: Assign Requests of Different Difficulties to Sufficient Capability

  From direct routing, small-then-large, and quality-gap prediction, to escalation thresholds, cascade latency, fairness risk, and online recalibration.

• Vector Databases: Approximate Nearest Neighbor Search in Large-Scale Embeddings

  Understand vectors, distance metrics, HNSW/IVF/PQ, filtering, updates, and consistency, and separate index recall, latency, and end-to-end Retrieval-Augmented Generation (RAG).

• Residual Connections: Preserving an Identity Information Highway for Deep Transformations

  Starting from the forward increment y=x+F(x) and the backward Jacobian I+JF, understand depth degradation, projection shortcuts, branch scaling, zero initialization, and Transformer's Pre-Norm/Post-Norm.

• State Space Models (SSM): Compressing Long Sequences with Controllable Dynamical Systems

  From continuous state equations, discretization, and convolution equivalence, to selective scanning, linear complexity, stability, and random-access boundaries.

• Synthetic Data: Generating Candidates Is Easy, Increasing Useful Information Is Hard

  From teacher demonstrations, programmatic ground truth, self-training, and augmentation, to verifier selection bias, coverage ratios, feedback loops, and model collapse.

• Test-time Compute and Verifiers

  Without changing the weights, use sampling, search, tools, and checking to convert extra computation into more reliable answers.

• Video Generation: Jointly Modeling Spatial Appearance, Temporal Motion, and Cross-Shot State

  From video latent variables, spatiotemporal attention, and diffusion, to image-to-video, cascaded super-resolution, identity consistency, physics failures, long video planning, and temporal evaluation.

• Information Theory and Entropy: From Probability to Coding Cost

  First distinguish the true distribution P from the model distribution Q, then derive cross-entropy, KL divergence, and perplexity step by step from self-information and entropy.

• AI Governance: Turning Risk Judgments into an Accountable, Evidence-Preserving, Stoppable System

  From system inventory, risk classification, and responsibility matrix to go-live gate, change approval, incident response, and decommissioning, understand how governance translates principles into lifecycle evidence.

• Image Generation

  Turn a sentence into a picture nobody has ever taken.

• Inference Optimization: First Locate Whether the Bottleneck Is Prefill, Decode, KV, or Queuing

  From TTFT/TPOT, arithmetic intensity, and continuous batching, to PagedAttention, FlashAttention, quantization, speculative decoding, and real-workload validation.

• MCP Model Context Protocol

  Let any tool and data plug into AI applications through the same standard interface.

• Generative Image Editing: Changing target attributes while proving the rest is preserved

  From mask inpainting, img2img noise strength, attention control, and instruction editing, to inversion, locality, identity consistency, reversibility, and edit provenance.

• Transformer

  Packaging attention into a standard building block that can be stacked deeply and trained in parallel.

• Supervised Learning

  Learn from “input + target” samples and make reliable predictions on unseen data.

• Neural Network

  From “Why We Need It” to “How It Learns Through Backpropagation”