• English
  • 3.10.0

    • Documentation Overview

    This documentation is intended for all developers using the Horizon J6 computing platform. To help you understand the overall workflow more clearly, we recommend reading the documentation in the following order.

    The following sections briefly introduce the content of each section. You can also jump directly to the relevant section based on your current needs.

    1. Documentation Overview

    This section provides an overview of the relevant sections in the documentation, together with recommended reading paths.

    1. OpenExplorer Overview
    SectionDescription
    Product IntroductionThis section introduces the overall Open Explorer toolchain and briefly explains the deliverables included in the OE package.
    Key ConceptsThis section introduces commonly used concepts and related background knowledge.
    1. Environment Setup
    SectionDescription
    Pre-installation PreparationThis section introduces the dependencies, environment version requirements, and prerequisites that should be checked before installation so that the development and runtime environments can be set up correctly.
    Software Installation GuideThis section introduces the concrete setup steps for both the development environment and the runtime environment.
    1. Quick Start
    SectionDescription
    ONNX Model Quick StartIn this section, we provide a quick-start example of the complete workflow for an ONNX model, from quantization to deployment on hardware, to help you understand the basic usage process and get started quickly.
    PyTorch Model Quick StartIn this section, we provide the basic workflow for a PyTorch model, including floating-point model modification, calibration, HBIR export, fixed-point model validation, and deployment on hardware, helping you get started quickly.
    1. Platform Differences

    This section helps you first distinguish the differences among J6 platforms in quantization strategy, output precision, input and output handling, and deployment capability. If you are still deciding which quantization path to use, where to start with precision configuration, or how to validate deployment results, it is recommended to read this section first before continuing to the later model compilation and tuning sections.

    1. Model Quantization and Compilation
    SectionDescription
    OverviewIn this section, we provide an overview of two workflows: ONNX model quantization and PyTorch model quantization based on practical usage scenarios, helping you understand the actual process of model quantization and compilation.
    ONNX Model QuantizationIn this section, we focus on the ONNX model quantization path, introducing the overall PTQ workflow, core steps, deployment consistency, common problems and troubleshooting methods, and related appendix content, helping you first complete the standard PTQ workflow and then continue with accuracy and deployment-side analysis.
    PyTorch Model QuantizationIn this section, we focus on the PyTorch model quantization path, introducing floating-point model adaptation, QConfig configuration, Prepare, Calibration, QAT training, fixed-point model conversion, deployment consistency analysis, accuracy tuning, and common problems, helping you complete quantization and deployment validation step by step in the actual usage order.
    Model ModificationIn this section, we provide examples of several common model modification scenarios, together with comparisons of HBIR models before and after modification, to introduce modification methods and precautions.
    X86 SimulationIn this section, we introduce how to run model inference on the X86 simulation platform so that you can understand the usage flow on the X86 simulation platform.
    1. Model Deployment
    SectionDescription
    Board EvaluationThis section explains how to evaluate performance and accuracy on the board, including key metrics and related precautions during evaluation.
    Board Resources EvaluationThis section explains how to evaluate board-side resources, including metrics such as BPU usage, bandwidth, and memory occupancy.
    Board DeploymentThis section provides guidance for inference application development during board-side deployment, along with C++ runtime examples, to help you understand the main steps and precautions for board deployment.
    1. Model Tuning Guide
    SectionDescription
    Model Performance Tuning GuideThis section introduces Horizon's recommendations and measures for improving model performance when the current performance does not meet expectations, as well as general guidance for efficient model design on J6 platforms.
    Model Accuracy Tuning GuideThis section provides guidance and corresponding examples for accuracy tuning after quantization and compilation of ONNX and PyTorch models.
    1. Unified Computing Platform (UCP)
    SectionDescription
    OverviewThis section introduces the overall development path on the Horizon platform and how to complete visual processing and deep learning deployment using UCP.
    Function Support Comparison ListThis section explains feature differences in the current UCP version across J6 platforms under Linux and QNX.
    Vision ProcessingThis section introduces the basic knowledge and interfaces for vision processing, helping you call visual operators and use related hardware acceleration.
    High Performance LibraryThis section introduces the basic knowledge and interfaces of the high-performance operator library, which packages a set of commonly used high-performance operators for flexible deployment.
    Custom OperatorsThis section introduces the basic knowledge and interfaces for UCP custom operator development, together with reference examples.
    End-to-end Object Detection SampleThis section explains how the end-to-end object detection sample runs a detection model on J6 and displays the result.
    FAQ and Error CodesThis section provides answers to common questions in heterogeneous programming and explanations of related error codes.
    1. API
    SectionDescription
    HMCT API ReferenceThis section introduces the HMCT APIs.
    HBDK Tool API ReferenceThis section introduces the HBDK tool APIs.
    Horizon PyTorch Plugin API ReferenceThis section introduces the Horizon Plugin PyTorch APIs.
    UCP API ReferenceThis section introduces the UCP APIs.
    1. Tools Guide
    SectionDescription
    Quantization Pipeline ToolsThis section introduces the quantization pipeline tools provided by the algorithm toolchain, helping you quickly understand how to use the tools in the quantization pipeline and their basic functions.
    Performance Analysis ToolThis section introduces the usage and basic functions of hb_analyzer, which is used to analyze model or perf-file performance.
    Model Inference ToolsThis section introduces the usage of hrt_model_exec and hbm_infer, together with common command operations during model inference.
    UCP Performance Analysis ToolsThis section introduces how to use ucp_trace and hrt_ucp_monitor.
    1. Model Deployment Practice Guidance Examples

    In this section, we use the public ResNet18 example to provide full-process practice guidance for model quantization and board deployment using the PTQ scheme in several typical scenarios, helping you understand the entire workflow of an algorithm model from preparation to board deployment.

    1. Supported Operator and Constraint List

    This section lists the supported operator ranges on different computing platforms of the Horizon J6 series, and provides related content such as operator types, operator constraint conditions, and general usage restrictions for your reference during use.

    1. License Agreement and Third-party Software Vulnerability Notes
    SectionDescription
    J6 Toolchain License AgreementThis section provides the license agreement. Please read it carefully before using the J6 toolchain.
    Third-party Software and License StatementThis section provides related information about third-party software, licenses, and associated notes.
    Third-party Software Vulnerability NotesThis section provides notes related to vulnerabilities in third-party software or components.