1getconf LONG_BIT
232

1# 这里修改并填入所使用的SophonSDK路径
2set(EDGE_BMSDK_ROOT "{这里填写sdk路径}")

1# SDK内提供的一些二进制文件，填入序列号可完成自动激活，以下二进制具体使用说明参考下一小节
2./edgekit_serving --cfg=./edgekit_serving.yml
3./easyedge_image_inference {model_dir} {image_name or image_directory} {serial_num}
4./easyedge_serving {res_dir} {serial_key} {host} {port}

1global_controller()->set_licence_key("")

1export EDGE_CONTROLLER_KEY_AUTH_MODE=2
2export EDGE_CONTROLLER_KEY_INSTANCE_UPDATE_INTERVAL=30

1global_controller()->set_config(easyedge::params::CONTROLLER_KEY_AUTH_MODE, 2)
2global_controller()->set_config(easyedge::params::CONTROLLER_KEY_INSTANCE_UPDATE_INTERVAL, 300)

1#./easyedge_image_inference {model_dir} {image_name or image_directory} {serial_num}
2LD_LIBRARY_PATH=../lib ./easyedge_image_inference ../../../RES /xxx/cat.jpeg "1111-1111-1111-1111"

1 > ./easyedge_image_inference ../../../../RES 2.jpeg
22019-02-13 16:46:12,659 INFO [EasyEdge] [easyedge.cpp:34] 140606189016192 Baidu EasyEdge Linux Development Kit 0.2.1(20190213)
32019-02-13 16:46:14,083 INFO [EasyEdge] [paddlev2_edge_predictor.cpp:60] 140606189016192 Allocate graph success.
42019-02-13 16:46:14,326 DEBUG [EasyEdge] [paddlev2_edge_predictor.cpp:143] 140606189016192 Inference costs 168 ms
51, 1:txt_frame, p:0.994905 loc: 0.168161, 0.153654, 0.920856, 0.779621
6Done

1# 推荐使用 edgekit_serving 启动模型服务
2LD_LIBRARY_PATH=../lib ./edgekit_serving --cfg=./edgekit_serving.yml
3
4# 也可以使用 easyedge_serving 启动模型服务
5# ./easyedge_serving {res_dir} {serial_key} {host, default 0.0.0.0} {port, default 24401}
6# LD_LIBRARY_PATH=../lib ./easyedge_serving ../../../RES "1111-1111-1111-1111" 0.0.0.0  24401

1HTTP(or Webservice) is now serving at 0.0.0.0:24401

1cd src
2mkdir build && cd build
3cmake .. && make
4./easyedge_image_inference {模型RES文件夹}  {测试图片路径}
5# 如果是NNIE引擎，使用sudo运行
6sudo ./easyedge_image_inference {模型RES文件夹}  {测试图片路径}

1cmake -DEDGE_BUILD_OPENCV=ON .. && make -j16

1cp ${cpp_kit位置路径}/thirdparty/openvino/deployment_tools/inference_engine/external/97-myriad-usbboot.rules /etc/udev/rules.d/
2sudo udevadm control --reload-rules
3sudo udevadm trigger
4sudo ldconfig

1    // step 1: 配置运行参数
2    EdgePredictorConfig config;
3    config.model_dir = {模型文件目录};
4
5    // step 2: 创建并初始化Predictor；这这里选择合适的引擎
6    auto predictor = global_controller()->CreateEdgePredictor(config);
7
8    // step 3-1: 预测图像
9    auto img = cv::imread({图片路径});
10    std::vector<EdgeResultData> results;
11    predictor->infer(img, results);
12
13	// step 3-2: 预测视频
14	std::vector<EdgeResultData> results;
15	FrameTensor frame_tensor;
16	VideoConfig video_config;
17	video_config.source_type = static_cast<SourceType>(video_type);  // source_type 定义参考头文件 easyedge_video.h
18	video_config.source_value = video_src;
19	/*
20	... more video_configs, 根据需要配置video_config的各选项
21	*/
22	auto video_decoding = CreateVideoDecoding(video_config);
23	while (video_decoding->next(frame_tensor) == EDGE_OK) {
24	    results.clear();
25	    if (frame_tensor.is_needed) {
26	        predictor->infer(frame_tensor.frame, results);
27	        render(frame_tensor.frame, results, predictor->model_info().kind);
28	    }
29	    //video_decoding->display(frame_tensor); // 显示当前frame，需在video_config中开启配置
30	    //video_decoding->save(frame_tensor); // 存储当前frame到视频，需在video_config中开启配置
31	 }

1/**
2 * @brief 序列号设置；序列号不设置留空时，SDK将会自动尝试使用本地已经激活成功的有效期内的序列号
3 * 值类型：string
4 * 默认值：空
5 */
6static constexpr auto PREDICTOR_KEY_SERIAL_NUM = "PREDICTOR_KEY_SERIAL_NUM";

1EdgePredictorConfig config;
2config.model_dir = ...;
3config.set_config(params::PREDICTOR_KEY_SERIAL_NUM, "1DB7-1111-1111-D27D");

1auto predictor = global_controller()->CreateEdgePredictor(config);
2predictor->init();

1 /**
2  * @brief
3  * 通用接口
4  * @param image: must be BGR , HWC format (opencv default)
5  * @param result
6  * @return
7  */
8 virtual int infer(
9         cv::Mat& image, std::vector<EdgeResultData>& result
10 ) = 0;

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};

1cv::Mat mask为图像掩码的二维数组
2{
3  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
4  {0, 0, 0, 1, 1, 1, 0, 0, 0, 0},
5  {0, 0, 0, 1, 1, 1, 0, 0, 0, 0},
6  {0, 0, 0, 1, 1, 1, 0, 0, 0, 0},
7  {0, 0, 0, 1, 1, 1, 0, 0, 0, 0},
8  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
9}
10其中1代表为目标区域，0代表非目标区域

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";

1EdgePredictorConfig config;
2config.set_config(easyedge::params::PREDICTOR_KEY_SERIAL_NUM, "this-is-serial-num");

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

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()

1import requests
2
3with open('./1.jpg', 'rb') as f:
4    img_data = f.read()
5    res = requests.post('http://127.0.0.1:24401/',
6        data=img_data)
7    with open("gray_result.png", "wb") as fb:
8        fb.write(res.content) # 语义分割模型是像素点级别输出，可将api返回结果保存为灰度图，每个像素值代表该像素分类结果

1import requests
2
3with open('./1.mp4', 'rb') as f:
4    video_data = f.read()
5    result = requests.post(
6	    'http://127.0.0.1:24401/',
7	    params={'threshold': 0.1},
8	    headers={'Content-Type': 'video'},
9	    data=video_data).json()

1{
2	"image": "<base64数据>",
3	"top_num": 5
4}

1{
2	"image": "<base64数据>",
3    "threshold": 0.3
4}

1{
2	"image": "<base64数据>"
3}

1import base64
2import requests
3
4
5def main():
6    with open("1.jpg 【图片路径】", 'rb') as f:
7        result = requests.post("http://{服务ip地址}:24401/", json={
8            "image": base64.b64encode(f.read()).decode("utf8")
9        })
10        # print(result.request.body)
11        # print(result.request.headers)
12        print(result.content)
13
14
15if __name__ == '__main__':
16    main()

1import base64
2import requests
3def main():
4    with open("1.jpg 【图片路径】", 'rb') as f:
5        res = requests.post("http://{服务ip地址}:24401/", json={"image": base64.b64encode(f.read()).decode("utf8")})
6        with open("gray_result.png", "wb") as fb:
7            fb.write(res.content) # 语义分割模型是像素点级别输出，可将api返回结果保存为灰度图，每个像素值代表该像素分类结果
8if __name__ == '__main__':
9    main()

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            "mask": "...",  // 图像分割模型字段
14            "trackId": 0,  // 目标追踪模型字段
15        },
16        
17      ]
18}

1global_controller()->set_config(easyedge::params::KEY_LOG_BRAND, "MY_BRAND");

1open sys: Permission denied
2open err
3: Permission denied
4open err
5: Permission denied

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

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

1LD_LIBRARY_PATH=$LD_LIBRARY_PATH:../lib ./easyedge_demo