Huawei HCIE-AI study plan

Derive the bias-variance decomposition and compute it numerically for a synthetic regression dataset

Implement gradient descent, momentum, and Adam from scratch and compare convergence on a non-convex loss surface

Explain backpropagation through a two-layer MLP by hand-deriving every partial derivative

Distinguish L1, L2, dropout, and early stopping by their effect on the training objective

Build a CNN from scratch and compute output shapes, receptive fields, and parameter counts for each layer

Trace the vanishing-gradient problem through a deep plain network and fix it with residual connections

Implement an LSTM cell and a single-head self-attention block and compare their memory behavior

Explain how batch normalization changes the loss landscape and where to place it relative to activation

Assemble a transformer encoder from scratch: embeddings, multi-head attention, layer norm, feed-forward, and residual paths

Compute the FLOPs and memory footprint of attention as sequence length grows and justify when to use sparse or linear attention

Implement mixed-precision training and identify which operations must stay in higher precision

Diagnose overfitting and underfitting from learning curves and prescribe a concrete fix for each

Map the CANN software stack from framework adapters down to the runtime and driver layers

Describe the Ascend Da Vinci architecture: cube units, vector units, and the AI Core versus AI CPU split

Explain how on-chip buffers and data movement constrain operator design on Ascend hardware

Convert a simple PyTorch operator to run through the Ascend path and verify numerical parity with CPU output

Write and compile a custom operator using the Ascend operator development flow, including the shape and dtype inference functions

Profile a model on Ascend and attribute time to compute-bound versus memory-bound operators

Apply graph-level optimizations such as operator fusion and constant folding and measure the effect

Explain how model conversion to the offline format works and what information is lost or fixed at conversion time

Package a trained model for Ascend inference and run it end to end through the serving path

Configure multi-card distributed training and verify that gradients are synchronized correctly

Measure throughput and latency under batching changes and identify the saturation point

Explain the tradeoffs between dynamic and static shapes for deployment

Containerize the inference service and expose it behind a health-checked API endpoint

Implement input validation, request timeouts, and graceful degradation for the service

Instrument the service with latency and error-rate metrics and define an alert threshold for each

Design a rollback procedure for a bad model version and rehearse it

Sit two full timed mock exams and classify every wrong answer by domain and root cause

Re-derive the five weakest concepts from memory without notes and check against source material

Explain aloud, in under three minutes each, the Ascend architecture, attention complexity, and a deployment tradeoff

Build a personal error log mapping each recurring mistake to a corrective drill