Huawei HCIE-AI key terms

Training approach where a model learns from labeled input-output pairs, adjusting parameters to minimize the gap between its predictions and the known correct answers.

A numeric measure of how far a model's predictions deviate from the target values; training seeks to minimize it by updating parameters.

An iterative optimization method that moves parameters in the direction opposite to the loss gradient, scaled by a learning rate, to reduce error.

A condition where a model fits training data noise so closely that it generalizes poorly to unseen data, often detected by a widening train-validation gap.

Techniques such as weight decay, dropout, or early stopping that constrain model complexity to improve generalization on data not seen during training.

A resampling procedure that splits data into folds, training and validating repeatedly so performance estimates are less dependent on a single split.

Precision is the share of predicted positives that are correct; recall is the share of actual positives that were found. Their balance matters for imbalanced classification.

The harmonic mean of precision and recall, giving a single balanced metric that penalizes models strong on one measure but weak on the other.

A setting chosen before training, such as learning rate, batch size, or network depth, that governs how the learning algorithm behaves rather than being learned from data.

A positive scalar controlling the size of each parameter update during optimization; too large causes divergence, too small slows convergence.

A rule that changes the learning rate over training, for example warmup followed by cosine decay, to stabilize early steps and refine later ones.

The reverse-mode application of the chain rule that computes gradients of the loss with respect to every parameter in a computational graph.

A network architecture using shared local filters to extract spatial features from grid-structured data such as images, exploiting translation invariance and weight sharing.

A sequence architecture built on multi-head self-attention and feed-forward layers, enabling parallel processing of tokens and long-range dependency modeling without recurrence.

A mechanism where each token forms queries, keys, and values from its own representation and aggregates information weighted by query-key similarity across the sequence.

Running several attention computations in parallel with separate projections and concatenating their outputs, letting the model capture diverse relationship patterns at once.

Information added to token embeddings so an attention-based model, which is otherwise order-agnostic, can distinguish sequence positions.

A nonlinear element applied to neuron outputs, such as ReLU or GELU, that lets stacked layers represent complex functions beyond linear transformations.

A training pathology in deep or recurrent networks where gradients shrink toward zero through many layers, stalling learning in early layers.

A shortcut that adds a layer's input to its output, giving gradients a direct path backward and enabling stable training of very deep networks.

A layer that normalizes activations across a mini-batch to stabilize and accelerate training, typically with learnable scale and shift parameters.

A regularization method that randomly zeroes a fraction of activations during training, preventing units from co-adapting too strongly.

A framework capability that records operations on tensors and mechanically derives gradients, freeing developers from hand-coding backward passes.

A directed graph of tensor operations built during the forward pass, used by automatic differentiation to compute gradients efficiently.

Huawei's neural processing unit family designed for AI training and inference, organized around AI Core and AI CPU units with dedicated on-chip memory hierarchies.

Compute Architecture for Neural Networks, Huawei's heterogeneous computing software stack that sits between AI frameworks and Ascend hardware, providing operators, graph compilation, and runtime services.

The Ascend computing language interface exposing device, context, stream, memory, and model-execution APIs so applications can run inference and training on Ascend hardware.

The main compute engine inside an Ascend processor, containing cube, vector, and scalar units that execute matrix, vector, and control operations respectively.

A matrix-multiplication engine in the Ascend AI Core that performs large tiled matrix products at high throughput, central to deep learning workloads.

Huawei's scalable NPU architecture underlying Ascend chips, combining AI Core compute with on-chip buffers and interconnect for efficient neural network execution.

Partitioning large tensor operations into smaller blocks that fit on-chip memory, a key optimization when writing custom Ascend operators.

Implementing custom compute kernels for Ascend using the programming interfaces and scheduling model provided by CANN, including shape inference and tiling strategy.

The CANN component that compiles and optimizes framework graphs into executable form for Ascend devices, applying fusion and memory planning.

Combining multiple graph operators into one kernel to cut memory traffic and launch overhead, a common optimization in Ascend graph compilation.

Huawei's cloud AI development platform offering data labeling, training jobs, hyperparameter tuning, and deployment services that can target Ascend hardware.

Huawei's open-source deep learning framework supporting automatic differentiation and graph execution, designed to run across Ascend, GPU, and CPU targets.

Transforming a trained model from a source framework format into a device-executable format for Ascend, often via the ATC tool with quantization and layout options.

The Ascend Tensor Compiler command-line utility that converts framework models into offline model files optimized for Ascend inference deployment.

Reducing numeric precision of weights and activations, for example to INT8, to shrink model size and raise inference throughput at some accuracy cost.

Running a trained model on new inputs to produce predictions, typically optimized for latency and throughput rather than gradient computation.

The number of samples processed in one forward and backward step; it affects memory use, gradient noise, and training throughput.