合约现货对冲跟单量化交易系统开发（开发案例）丨现货合约跟单对冲量化交易系统开发（逻辑及方案）/成熟技术/源码运营版

　　量化合约指的是目标或任务具体明确，可以清晰度量。根据不同情况，表现为数量多少，具体的统计数字，范围衡量，时间长度等等。所谓量化就是把经过抽样得到的瞬时值将其幅度离散，即用一组规定的电平，把瞬时抽样值用最接近的电平值来表示。经过抽样的图像，只是在空间上被离散成为像素(样本)的阵列。而每个样本灰度值还是一个由无穷多个取值的连续变化量，必须将其转化为有限个离散值，赋予不同码字才能真正成为数字图像。这种转化称为量化。

　　量化交易机器人是什么？

　　实质上，交易机器人是一个软件程序，可以直接与金融(通常使用API来获取和解释相关信息)进行交互，并且可以根据对市场数据的解释来发布买卖订单。他们通过监控市场上的价格走势，并根据一套事先设置好的规则作出反应来做出这些决策。一般情况下，交易机器人会分析市场上的交易数量、订单、价格和时间等行为，并根据你的喜好来规划它们。

　　在策略设定好之后，机器人智能分配每一次进单条件，严格执行交易策略，交易策略，根据当前行情，实时进行云大数据调整。同时支持百种交易同时执行交易策略，每一个品种立线程，自动管理报价深度，策略计算，实时查看交易情况，实时执行。

　　策略执行代码参考如下：

Calibration::Calibration(MNN::NetT model, const uint8_t modelBuffer, const int bufferSize, const std::string& configPath)
: _originaleModel(model) {
// when the format of input image is RGB/BGR, channels equal to 3, GRAY is 1
int channles = 3;
// 解析量化json配置文件
rapidjson::Document document;
{
std::ifstream fileNames(configPath.c_str());
std::ostringstream output;
output << fileNames.rdbuf();
auto outputStr = output.str();
document.Parse(outputStr.c_str());
if (document.HasParseError()) {
MNN_ERROR("Invalid json\n");
return;
}
}
auto picObj = document.GetObject();
ImageProcess::Config config;
config.filterType = BILINEAR;
config.destFormat = BGR;
{
if (picObj.HasMember("format")) {
auto format = picObj["format"].GetString();
static std::map formatMap{ {"BGR", BGR}, {"RGB", RGB}, {"GRAY", GRAY}, {"RGBA", RGBA}, {"BGRA", BGRA}};
if (formatMap.find(format) != formatMap.end()) {
config.destFormat = formatMap.find(format)->second;
}
}
}

switch (config.destFormat) {
    case GRAY:
        channles = 1;
        break;
    case RGB:
    case BGR:
        channles = 3;
        break;
    case RGBA:
    case BGRA:
        channles = 4;
        break;
    default:
        break;
}

// 根据配置文件中的参数设置config
config.sourceFormat = RGBA;
std::string imagePath;
_imageNum = 0;
{
    if (picObj.HasMember("mean")) {
        auto mean = picObj["mean"].GetArray();
        int cur   = 0;
        for (auto iter = mean.begin(); iter != mean.end(); iter++) {
            config.mean[cur++] = iter->GetFloat();
        }
    }
    if (picObj.HasMember("normal")) {
        auto normal = picObj["normal"].GetArray();
        int cur     = 0;
        for (auto iter = normal.begin(); iter != normal.end(); iter++) {
            config.normal[cur++] = iter->GetFloat();
        }
    }
    if (picObj.HasMember("width")) {
        _width = picObj["width"].GetInt();
    }
    if (picObj.HasMember("height")) {
        _height = picObj["height"].GetInt();
    }
    if (picObj.HasMember("path")) {
        imagePath = picObj["path"].GetString();
    }
    if (picObj.HasMember("used_image_num")) {
        _imageNum = picObj["used_image_num"].GetInt();
    }
    if (picObj.HasMember("feature_quantize_method")) {
        std::string method = picObj["feature_quantize_method"].GetString();
        if (Helper::featureQuantizeMethod.find(method) != Helper::featureQuantizeMethod.end()) {
            _featureQuantizeMethod = method;
        } else {
            MNN_ERROR("not supported feature quantization method: %s\n", method.c_str());
            return;
        }
    }
    if (picObj.HasMember("weight_quantize_method")) {
        std::string method = picObj["weight_quantize_method"].GetString();
        if (Helper::weightQuantizeMethod.find(method) != Helper::weightQuantizeMethod.end()) {
            _weightQuantizeMethod = method;
        } else {
            MNN_ERROR("not supported weight quantization method: %s\n", method.c_str());
            return;
        }
    }
    DLOG(INFO) << "Use feature quantization method: " << _featureQuantizeMethod;
    DLOG(INFO) << "Use weight quantization method: " << _weightQuantizeMethod;
    if (picObj.HasMember("feature_clamp_value")) {
        float value = (int)picObj["feature_clamp_value"].GetFloat();
        if (value < 0.0f || value > 127.0f) {
            MNN_ERROR("feature_clamp_value should be in (0, 127], got: %f\n", value);
            return;
        }
        _featureClampValue = value;
    }
    if (picObj.HasMember("weight_clamp_value")) {
        float value = (int)picObj["weight_clamp_value"].GetFloat();
        if (value < 0.0f || value > 127.0f) {
            MNN_ERROR("weight_clamp_value should be in (0, 127], got: %f\n", value);
            return;
        }
        _weightClampValue = value;
    }
    DLOG(INFO) << "feature_clamp_value: " << _featureClampValue;
    DLOG(INFO) << "weight_clamp_value: " << _weightClampValue;
    if (picObj.HasMember("skip_quant_op_names")) {
        auto skip_quant_op_names = picObj["skip_quant_op_names"].GetArray();
        for (auto iter = skip_quant_op_names.begin(); iter != skip_quant_op_names.end(); iter++) {
            std::string skip_quant_op_name = iter->GetString();
            _skip_quant_ops.emplace_back(skip_quant_op_name);
            DLOG(INFO) << "skip quant op name: " << skip_quant_op_name;
        }
    }
    if (picObj.HasMember("debug")) {
        _debug = picObj["debug"].GetBool();
    }
}
std::shared_ptr<ImageProcess> process(ImageProcess::create(config));
_process = process;

// read images file names
Helper::readImages(_imgaes, imagePath.c_str(), &_imageNum);

_initMNNSession(modelBuffer, bufferSize, channles);
_initMaps();

}