1cd src
2mkdir build && cd build
3cmake ..
4make -j$(nproc)
5# make install 为可选，也可将lib所在路径添加为环境变量
6sudo make install
7sudo ldconfig
8./demo_batch_inference/easyedge_batch_inference {模型RES文件夹}  {测试图片路径或仅包含图片的文件夹路径} {序列号}

1baidu@nano:~/ljay/easydl/sdk/demo/build$ ./demo_batch_inference/easyedge_batch_inference ../../../../RES/ /ljay/images/mix008.jpeg
22020-08-06 20:56:30,665 INFO [EasyEdge] 548125646864 Compiling model for fast inference, this may take a while (Acceleration)
32020-08-06 20:57:58,427 INFO [EasyEdge] 548125646864 Optimized model saved to: /home/baidu/.baidu/easyedge/jetson/mcache/24110044320/m_cache, Don't remove it
4Results of image /ljay/images/mix008.jpeg: 
52, kiwi, p:0.997594 loc: 0.352087, 0.56119, 0.625748, 0.868399
62, kiwi, p:0.993221 loc: 0.45789, 0.0730294, 0.73641, 0.399429
72, kiwi, p:0.992884 loc: 0.156876, 0.0598725, 0.3802, 0.394706
81, tomato, p:0.992125 loc: 0.523592, 0.389156, 0.657738, 0.548069
91, tomato, p:0.991821 loc: 0.665461, 0.419503, 0.805282, 0.573558
101, tomato, p:0.989883 loc: 0.297427, 0.439999, 0.432197, 0.59325
111, tomato, p:0.981654 loc: 0.383444, 0.248203, 0.506606, 0.400926
121, tomato, p:0.971682 loc: 0.183775, 0.556587, 0.286996, 0.711361
131, tomato, p:0.968722 loc: 0.379391, 0.0386965, 0.51672, 0.209681
14Done

1# ./easyedge_serving {res_dir} {serial_key} {host, default 0.0.0.0} {port, default 24401}
2 ./easyedge_serving ../../../../RES "1111-1111-1111-1111" 0.0.0.0 24401

1HTTP is now serving at 0.0.0.0:24401

1// step 1: 配置模型运行参数
2EdgePredictorConfig config;
3config.model_dir = model_dir;
4config.set_config(params::PREDICTOR_KEY_SERIAL_NUM, serial_num);
5config.set_config(params::PREDICTOR_KEY_GTURBO_MAX_BATCH_SIZE, 1);  // 优化的模型可以支持的batch_size
6config.set_config(params::PREDICTOR_KEY_GTURBO_FP16, false);        // 置true开启fp16模式推理会更快，精度会略微降低，但取决于硬件是否支持fp16，不是所有模型都支持fp16，参阅文档
7config.set_config(params::PREDICTOR_KEY_GTURBO_COMPILE_LEVEL, 1);   // 编译模型的策略，如果当前设置的max_batch_size与历史编译存储的不同，则重新编译模型
8
9
10// step 2: 创建并初始化Predictor
11auto predictor = global_controller()->CreateEdgePredictor<EdgePredictorConfig>(config);
12if (predictor->init() != EDGE_OK) {
13    exit(-1);
14}
15
16// step 3-1: 预测图像
17auto img = cv::imread({图片路径});
18std::vector<EdgeResultData> results;
19predictor->infer(img, results);
20
21// step 3-2: 预测视频
22std::vector<EdgeResultData> results;
23FrameTensor frame_tensor;
24VideoConfig video_config;
25video_config.source_type = static_cast<SourceType>(video_type);  // source_type 定义参考头文件 easyedge_video.h
26video_config.source_value = video_src;
27/*
28... more video_configs, 根据需要配置video_config的各选项
29*/
30auto video_decoding = CreateVideoDecoding(video_config);
31while (video_decoding->next(frame_tensor) == EDGE_OK) {
32    results.clear();
33    if (frame_tensor.is_needed) {
34        predictor->infer(frame_tensor.frame, results);
35        render(frame_tensor.frame, results, predictor->model_info().kind);
36    }
37    //video_decoding->display(frame_tensor); // 显示当前frame，需在video_config中开启配置
38    //video_decoding->save(frame_tensor); // 存储当前frame到视频，需在video_config中开启配置
39 }

1auto predictor = global_controller()->CreateEdgePredictor<EdgePredictorConfig>(config);
2if (predictor->init() != EDGE_OK) {
3        exit(-1);
4}

1/**
2 * @brief
3 * 单图预测接口
4 * @param image: must be BGR , HWC format (opencv default)
5 * @param result
6 * @return
7 */
8virtual int infer(
9        cv::Mat& image, std::vector<EdgeResultData>& result
10) = 0;
11
12/**
13 * @brief
14 * 批量图片预测接口
15 * @param image: must be BGR , HWC format (opencv default)
16 * @param result
17 * @return
18 */
19virtual int infer(
20        std::vector<cv::Mat>& image,
21        std::vector<std::vector<EdgeResultData>>& results
22) = 0;
23
24/**
25  * @brief
26  * 批量图片预测接口，带阈值
27  * @related infer(cv::Mat & image, EdgeColorFormat origin_color_format, std::vector<EdgeResultData> &result, float threshold)
28  */
29virtual int infer(
30            std::vector<cv::Mat> &images,
31            EdgeColorFormat origin_color_format,
32            std::vector<std::vector<EdgeResultData>> &results,
33            float threshold
34) = 0;

1struct EdgePredictorConfig {
2    /**
3     * @brief 模型资源文件夹路径
4     */
5    std::string model_dir;
6
7    std::map<std::string, std::string> conf;
8
9    EdgePredictorConfig();
10
11    template<typename T>
12    T get_config(const std::string &key, const T &default_value);
13
14    template<typename T = std::string>
15    T get_config(const std::string &key);
16
17    template<typename T>
18    const T *get_config(const std::string &key, const T *default_value);
19
20    template<typename T>
21    void set_config(const std::string &key, const T &value);
22
23    template<typename T>
24    void set_config(const std::string &key, const T *value);
25
26    static EdgePredictorConfig default_config();
27};

1/**
2 * @brief 当有同类型的多个设备的时候，使用哪一个设备，如：
3 * GPU: 使用哪张GPU卡
4 * EdgeBoard(VMX)，Movidius NCS ：使用哪一张加速卡
5 * 值类型：int
6 * 默认值：0
7 */
8static constexpr auto PREDICTOR_KEY_DEVICE_ID = "PREDICTOR_KEY_DEVICE_ID";
9
10/**
11 * @brief 生成 batch_size 为 max_batch_size 的优化模型，单次预测图片数量可以小于或等于此值（推荐等于此值，见release notes）
12 * 值类型: int
13 * 默认值：4
14 */
15static constexpr auto PREDICTOR_KEY_GTURBO_MAX_BATCH_SIZE = "PREDICTOR_KEY_GTURBO_MAX_BATCH_SIZE";
16
17/**
18 * @brief 设置device对应的GPU卡可以支持的最大并发量
19 * 实际预测的时候对应GPU卡的最大并发量不超过这里设置的范围，否则预测请求会排队等待预测执行
20 * 值类型: int
21 * 默认值：1
22 */
23static constexpr auto PREDICTOR_KEY_GTURBO_MAX_CONCURRENCY = "PREDICTOR_KEY_GTURBO_MAX_CONCURRENCY";
24
25/**
26 * @brief 是否开启fp16模式预测，开启后预测速度会更快，但精度会略有降低。并且需要硬件支持fp16
27 * 值类型: bool
28 * 默认值：false
29 */
30static constexpr auto PREDICTOR_KEY_GTURBO_FP16 = "PREDICTOR_KEY_GTURBO_FP16";
31
32/**
33 * @brief 模型编译等级
34 * 1：如果当前max_batch_size与历史编译产出的max_batch_size不相等时，则重新编译模型（推荐）
35 * 2：无论历史编译产出的max_batch_size为多少，均根据当前max_batch_size重新编译模型
36 * 值类型: int
37 * 默认值：1
38 */
39static constexpr auto PREDICTOR_KEY_GTURBO_COMPILE_LEVEL = "PREDICTOR_KEY_GTURBO_COMPILE_LEVEL";
40
41/**
42 * @brief GPU工作空间大小设置
43 * workspace_size = workspace_prefix * (1 << workspace_offset)
44 * workspace_offset: 10 = KB, 20 = MB, 30 = GB
45 * 值类型: int
46 * 默认值：WORKSPACE_PREFIX: 100, WORKSPACE_OFFSET: 20，即100MB
47 */
48static constexpr auto PREDICTOR_KEY_GTURBO_WORKSPACE_PREFIX = "PREDICTOR_KEY_GTURBO_WORKSPACE_PREFIX";
49static constexpr auto PREDICTOR_KEY_GTURBO_WORKSPACE_OFFSET = "PREDICTOR_KEY_GTURBO_WORKSPACE_OFFSET";
50
51/**
52 * @brief 需要使用的dla core
53 * 值类型: int
54 * 默认值：-1(不使用)
55 */
56static constexpr auto PREDICTOR_KEY_GTURBO_DLA_CORE = "PREDICTOR_KEY_GTURBO_DLA_CORE";
57
58/**
59 * @brief 自定义缓存文件存储路径
60 * 值类型: string
61 * 默认值: ~/.baidu/easyedge/mcache/{model_id * 1000000 + release_id}
62 */
63static constexpr auto PREDICTOR_KEY_GTURBO_CACHE_DIR = "PREDICTOR_KEY_GTURBO_CACHE_DIR";
64
65/**
66 * @brief 自定义缓存文件命名，默认即可
67 * 值类型: string
68 * 默认值: 根据配置自动生成
69 */
70static constexpr auto PREDICTOR_KEY_GTURBO_CACHE_NAME = "PREDICTOR_KEY_GTURBO_CACHE_NAME";
71
72/**
73 * @brief 序列号设置；序列号不设置留空时，SDK将会自动尝试使用本地已经激活成功的有效期内的序列号
74 * 值类型：string
75 * 默认值：空
76 */
77static constexpr auto PREDICTOR_KEY_SERIAL_NUM = "PREDICTOR_KEY_SERIAL_NUM";

1    /**
2     * @brief 获取输入源的下一帧
3     * @param frame_tensor
4     * @return
5     */
6    virtual int next(FrameTensor &frame_tensor) = 0;
7
8    /**
9     * @brief 显示当前frame_tensor中的视频帧
10     * @param frame_tensor
11     * @return
12     */
13    virtual int display(const FrameTensor &frame_tensor) = 0;
14
15    /**
16     * @brief 将当前frame_tensor中的视频帧写为本地视频文件
17     * @param frame_tensor
18     * @return
19     */
20    virtual int save(FrameTensor &frame_tensor) = 0;
21
22    /**
23     * @brief 获取视频的fps属性
24     * @return
25     */
26    virtual int get_fps() = 0;
27     /**
28      * @brief 获取视频的width属性
29      * @return
30      */
31    virtual int get_width() = 0;
32
33    /**
34     * @brief 获取视频的height属性
35     * @return
36     */
37    virtual int get_height() = 0;

1/**
2 * @brief 视频源、抽帧策略、存储策略的设置选项
3 */
4struct VideoConfig {
5    SourceType source_type;            // 输入源类型
6    std::string source_value;          // 输入源地址，如视频文件路径、摄像头index、网络流地址
7    int skip_frames{0};                // 设置跳帧，每隔skip_frames帧抽取一帧，并把该抽取帧的is_needed置为true
8    int retrieve_all{false};           // 是否抽取所有frame以便于作为显示和存储，对于不满足skip_frames策略的frame，把所抽取帧的is_needed置为false
9    int input_fps{0};                  // 在采取抽帧之前设置视频的fps
10    Resolution resolution{Resolution::kAuto}; // 采样分辨率，只对camera有效
11
12    bool enable_display{false};
13    std::string window_name{"EasyEdge"};
14    bool display_all{false};           // 是否显示所有frame，若为false，仅显示根据skip_frames抽取的frame
15
16    bool enable_save{false};
17    std::string save_path;             // frame存储为视频文件的路径
18    bool save_all{false};              // 是否存储所有frame，若为false，仅存储根据skip_frames抽取的frame
19
20    std::map<std::string, std::string> conf;
21};

1video_config.conf["backend"] = "2";

1EdgeLogConfig log_config;
2log_config.enable_debug = true;
3global_controller()->set_log_config(log_config);

1struct EdgeResultData {
2    int index;  // 分类结果的index
3    std::string label;  // 分类结果的label
4    float prob;  // 置信度
5
6    // 物体检测或图像分割时才有
7    float x1, y1, x2, y2;  // (x1, y1): 左上角， （x2, y2): 右下角； 均为0~1的长宽比例值。
8
9    // 图像分割时才有
10    cv::Mat mask;  // 0, 1 的mask
11    std::string mask_rle;  // Run Length Encoding，游程编码的mask
12};

1 /**
2     * @brief 开启一个简单的demo http服务。
3     * 该方法会block直到收到sigint/sigterm。
4     * http服务里，图片的解码运行在cpu之上，可能会降低推理速度。
5     * @tparam ConfigT
6     * @param config
7     * @param host
8     * @param port
9     * @param service_id service_id  user parameter, uri '/get/service_id' will respond this value with 'text/plain'
10     * @param instance_num 实例数量，根据内存/显存/时延要求调整
11     * @return
12     */
13    template<typename ConfigT>
14    int start_http_server(
15            const ConfigT &config,
16            const std::string &host,
17            int port,
18            const std::string &service_id,
19            int instance_num = 1);

1import requests
2
3with open('./1.jpg', 'rb') as f:
4    img = f.read()
5    result = requests.post(
6	    'http://127.0.0.1:24401/',
7	    params={'threshold': 0.1},
8	    data=img).json()

1{
2    "cost_ms": 52,
3    "error_code": 0,
4    "results": [
5        {
6            "confidence": 0.94482421875,
7            "index": 1,
8            "label": "IronMan",
9            "x1": 0.059185408055782318,
10            "x2": 0.18795496225357056,
11            "y1": 0.14762254059314728,
12            "y2": 0.52510076761245728
13        },
14        {
15            "confidence": 0.94091796875,
16            "index": 1,
17            "label": "IronMan",
18            "x1": 0.79151463508605957,
19            "x2": 0.92310667037963867,
20            "y1": 0.045728668570518494,
21            "y2": 0.42920106649398804
22        }
23      ]
24}

1# 在终端输入如下命令并回车
2$ head -n 1 /etc/nv_tegra_release
3# 就会输出类似如下结果
4$ # # R32 (release), REVISION: 4.3, GCID: 21589087, BOARD: t210ref, EABI: aarch64, DATE: Fri Jun 26 04:38:25 UTC 2020

1L4T R32.6.1  --> JetPack4.6
2L4T R32.5.1  --> JetPack4.5.1
3L4T R32.5    -->  JetPack4.5
4L4T R32.4.3  -->  JetPack4.4
5L4T R32.4.2  -->  JetPack4.4DP
6L4T R32.2.1  -->  JetPack4.2.2
7L4T R32.2.0  -->  JetPack4.2.1

1# 1. 运行下面这条命令可以查询开发板当前的运行功率模式
2$ sudo nvpmodel -q verbose
3# $ NV Power Mode: MAXN
4# $ 0
5# 如果输出为MAXN代表是最大功率模式
6
7# 2. 若需要把功率调到最大，运行下面这条命令
8$ sudo nvpmodel -m 0
9
10# 如果你进入了桌面系统，也可以在桌面右上角有个按钮可以切换模式
11
12# 3. 查询资源利用率
13$ sudo tegrastats

1export HTTP_PROXY="http://192.168.1.100:8888"
2./easyedge_demo ...

1headers = curl_slist_append(headers, "Expect:");

1export LD_LIBRARY_PATH=/home/work/baidu/cpp/lib:${LD_LIBRARY_PATH}

1sudo make install

12020-12-17 16:15:07,924 INFO [EasyEdge] 547633188880 Compiling model for fast inference, this may take a while (Acceleration)
2Killed
3
4# 或
5
62020-12-17 16:15:07,924 INFO [EasyEdge] 547633188880 Build graph failed