HCIP-AI EI Developer study plan

Map the Huawei AI stack end to end: Ascend chips (310/910), CANN operator layer, MindSpore, ModelArts, and HiAI, stating what each layer does and where a developer touches it

Install and configure the ModelArts SDK and MindSpore locally, then run one training job on ModelArts and one locally to compare the two workflows

Explain the AI development lifecycle stages (data prep, training, tuning, deployment, inference, monitoring) and identify which Huawei service owns each stage

Describe Ascend hardware constraints that change model design: memory tiers, mixed precision, and operator support limits in CANN

Set up a study log and a working notebook environment with MindSpore, NumPy, and OpenCV pinned to known versions

Write Python that manipulates tensors and datasets without relying on framework helpers: slicing, broadcasting, reshaping, and generator-based batching

Build a MindSpore training loop from scratch (dataset, forward pass, loss, optimizer, checkpoint save/load) and train a small classifier to convergence

Translate a PyTorch-style model definition into MindSpore, noting differences in context mode, cell definitions, and gradient computation

Use ModelArts dataset management and labeling features to ingest a small dataset and export it in a format MindSpore can consume

Profile a training script to find the slowest stage and record the measured bottleneck

Derive and implement gradient descent, regularization, and bias-variance tradeoff behavior on a tabular dataset, then quantify overfitting with train/validation curves

Implement and tune at least three classical algorithms (for example logistic regression, random forest, gradient boosting) and compare them with cross-validation

Compute and interpret classification metrics (precision, recall, F1, ROC-AUC, confusion matrix) on an imbalanced dataset and justify a metric choice

Build a scikit-learn pipeline that handles missing values, encoding, scaling, and model fitting without data leakage

Explain how learning rate, batch size, and initialization affect convergence in a deep network, demonstrating each with a controlled experiment

Implement a convolutional network in MindSpore and train it on an image classification task, tracking loss and accuracy per epoch

Apply transfer learning by fine-tuning a pretrained backbone and compare frozen vs unfrozen layer results

Diagnose and fix underfitting and overfitting using augmentation, dropout, weight decay, and early stopping, recording the effect of each

Explain backpropagation through a convolutional layer in writing, including how padding, stride, and pooling change gradient shapes

Export a trained model and run inference through the ModelArts deployment path, measuring latency

Build an image preprocessing pipeline with OpenCV covering resize, normalization, color space conversion, and augmentation, and verify tensor shapes at each step

Train and evaluate an object detection or segmentation model, reporting mAP or IoU on a held-out split

Implement a classical CV baseline (edge detection, contour finding, or template matching) and compare its failure modes with the deep model

Explain the architecture tradeoffs among classification, detection, and segmentation backbones in terms of speed and accuracy

Convert a trained CV model for Ascend inference and verify outputs match the training-time predictions within tolerance

Build a text preprocessing pipeline covering tokenization, vocabulary construction, padding, and handling of out-of-vocabulary tokens

Train a text classification model and compare a classical baseline (TF-IDF with linear model) against a neural approach

Explain how word embeddings and attention work, and demonstrate the effect of sequence length on model accuracy and training time

Fine-tune a pretrained transformer for a downstream NLP task and evaluate with task-appropriate metrics

Identify and mitigate a data quality problem in an NLP dataset, such as label noise or class imbalance, and measure the impact

Reproduce the full pipeline for one prior project end to end on the Huawei platform, from data ingestion through deployed inference

Tune training performance using mixed precision, larger batch sizes, and data pipeline parallelism, and record throughput before and after

Implement experiment tracking that captures hyperparameters, metrics, and artifacts for at least five runs

Run a hyperparameter search and select a final configuration using validation performance only

Document the resource cost of each configuration so tradeoffs between accuracy and compute are explicit

Consolidate weak areas by retaking practice assessments per domain and ranking domains by error rate

Explain aloud, without notes, the end-to-end lifecycle of a deployed model on the Huawei platform, including failure and rollback handling

Review the API differences, metric definitions, and architecture tradeoffs logged in earlier weeks, correcting any errors found

Complete two timed mixed-domain practice sets and analyze every wrong answer to its root concept

Write a compact reference sheet of formulas, metrics, and platform components for final review