Huawei HCIE-AI flashcards

32 cards. Read the term and the definition here. The deck at the top of this page is optional.

Bias-variance tradeoff

Total expected error splits into irreducible noise, squared bias (systematic underfitting), and variance (sensitivity to training sample). Increasing model capacity lowers bias but raises variance; regularization and more data reduce variance.

L1 vs L2 regularization

L1 adds the sum of absolute weights and produces sparse solutions with exact zeros, useful for feature selection. L2 adds squared weights, shrinks smoothly, and stabilizes ill-conditioned problems without zeroing coefficients.

Precision and recall

Precision is true positives divided by predicted positives, measuring how many flagged items are correct. Recall is true positives divided by actual positives, measuring coverage of the positive class.

F1 score

The harmonic mean of precision and recall, computed as 2PR/(P+R). It penalizes extreme imbalance between the two metrics and is preferred over accuracy on skewed class distributions.

Stratified k-fold cross-validation

Splits data into k folds while preserving class proportions in each fold, then trains k times and averages validation scores. It gives lower-variance estimates than plain k-fold on imbalanced datasets.

Data leakage

Use of information unavailable at prediction time, such as fitting scalers before splitting or encoding the target. It inflates offline validation scores that then collapse in production.

Gradient boosting

An ensemble that adds decision trees sequentially, each fitted to the negative gradient of the loss (residuals) of the current ensemble. Learning rate shrinks each tree's contribution to control overfitting.

Random forest

An ensemble of decision trees trained on bootstrap samples with random feature subsets at each split. Averaging decorrelated trees reduces variance and rarely overfits as trees grow deeper.

Backpropagation

The chain rule applied layer by layer from loss to inputs, computing gradients of each parameter for gradient descent. Reverse-mode automatic differentiation makes the cost comparable to one forward pass.

Vanishing gradient problem

Repeated multiplication of small Jacobians through many layers shrinks gradients toward zero, stalling early-layer learning. ReLU activations, residual connections, normalization, and gating mitigate it.

ReLU activation

max(0, z), which passes positive values unchanged and zeros negatives, giving a constant gradient of one for positive inputs. It is cheap and reduces vanishing gradients but can produce dead neurons.

Batch normalization

Normalizes each channel using mean and variance computed across the batch, then applies learnable scale and shift. It stabilizes training but behaves differently at inference, using running statistics.

Layer normalization

Normalizes each sample across its feature dimension independently of other samples, then applies learnable scale and shift. Being batch-size independent makes it standard inside Transformer blocks.

Scaled dot-product attention

Attention(Q,K,V) = softmax(QKᵀ/√d_k)V. Dividing by the square root of key dimension keeps logits small enough that softmax gradients do not saturate during training.

Multi-head attention

Runs several attention operations in parallel on projected query, key, and value subspaces, then concatenates outputs and applies a linear projection. Heads capture different relation types simultaneously.

Residual connection

Adds a layer's input to its output, y = F(x) + x, creating an identity path for gradients. This allows very deep networks to train without degradation from vanishing gradients.

Depthwise separable convolution

Factors a standard convolution into a per-channel depthwise convolution followed by a 1×1 pointwise convolution. It sharply reduces parameters and FLOPs, common in efficient mobile and edge models.

Mixed precision training

Uses FP16 or BF16 for forward and backward compute while keeping FP32 master weights, with loss scaling to prevent underflow. It speeds training and cuts memory with minimal accuracy loss.

Da Vinci architecture

Huawei Ascend core design separating Cube units for matrix multiply-accumulate, Vector units for elementwise math, and Scalar units for control flow, plus on-chip buffers for tiling.

CANN software stack

Huawei's heterogeneous computing stack for Ascend, sitting between frameworks and hardware. It includes graph compiler, operator libraries, runtime, and tools for operator development and profiling.

TBE operator development

Tensor Boost Engine is the Ascend framework for writing custom operators using DSL or TIK, compiled into device-executable code that runs on AI Core units.

ATC model conversion

Ascend Tensor Compiler converts exported models such as ONNX or MindIR into offline .om files with fixed input shapes and a target SoC version for efficient device execution.

HCCL collective communication

Huawei Collective Communication Library implements all-reduce, all-gather, and broadcast across Ascend devices for distributed training, playing the role NCCL plays on GPU clusters.

AI Core vs AICPU

AI Core executes dense tensor operations on Cube and Vector units. AICPU runs control-heavy or unsupported operators on the device's CPU cores, avoiding host round trips.

GE graph engine

The CANN component that optimizes the computation graph, partitions it into device and host subgraphs, and dispatches execution to the Ascend runtime.

Ascend 910 vs 310

The Ascend 910 targets data-center training with high throughput, while the 310 targets inference and edge scenarios with lower power. Both share the Da Vinci core design.

INT8 quantization formula

Maps floating values to integers via q = round(x/scale) + zero_point, with dequantization x ≈ scale·(q − zero_point). Per-channel scales preserve accuracy better than a single global scale.

Quantization-aware training

Simulates quantization rounding during training with fake-quant nodes so weights adapt to low precision. It usually beats post-training quantization on accuracy, at the cost of a full retraining cycle.

Knowledge distillation

Trains a compact student model to match a larger teacher's softened output distribution, using temperature-scaled softmax and a KL divergence loss, often combined with true-label cross-entropy.

Structured pruning

Removes entire channels, filters, or attention heads rather than individual weights, producing smaller dense tensors that yield real latency gains on standard hardware accelerators.

Canary deployment

Routes a small fraction of live traffic to a new model version while monitoring error and latency metrics, rolling back automatically if regressions exceed thresholds before full rollout.

Model drift monitoring

Compares live feature and prediction distributions against training baselines using statistics such as population stability index or KL divergence, triggering retraining when divergence crosses a defined threshold.