nihui
/
ncnn
Not watched
1
0
Fork 0
Code
Releases 46 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 61ba8ec68e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '61ba8ec68e'
${ noResults }
ncnn/tools/caffe/caffe2ncnn.cpp

1727 lines
64 kB
Raw Blame History 

  1. // Tencent is pleased to support the open source community by making ncnn available.

  2. //

  3. // Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.

  4. //

  5. // Licensed under the BSD 3-Clause License (the "License"); you may not use this file except

  6. // in compliance with the License. You may obtain a copy of the License at

  7. //

  8. // https://opensource.org/licenses/BSD-3-Clause

  9. //

  10. // Unless required by applicable law or agreed to in writing, software distributed

  11. // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR

  12. // CONDITIONS OF ANY KIND, either express or implied. See the License for the

  13. // specific language governing permissions and limitations under the License.

  14. 

  15. #include <stdio.h>

  16. #include <limits.h>

  17. #include <math.h>

  18. 

  19. #include <fstream>

  20. #include <set>

  21. #include <limits>

  22. #include <map>

  23. #include <algorithm>

  24. 

  25. #include <google/protobuf/io/coded_stream.h>

  26. #include <google/protobuf/io/zero_copy_stream_impl.h>

  27. #include <google/protobuf/text_format.h>

  28. #include <google/protobuf/message.h>

  29. 

  30. #include "caffe.pb.h"

  31. 

  32. 

  33. static inline size_t alignSize(size_t sz, int n)

  34. {

  35.     return (sz + n-1) & -n;

  36. }

  37. 

  38. // convert float to half precision floating point

  39. static unsigned short float2half(float value)

  40. {

  41.     // 1 : 8 : 23

  42.     union

  43.     {

  44.         unsigned int u;

  45.         float f;

  46.     } tmp;

  47. 

  48.     tmp.f = value;

  49. 

  50.     // 1 : 8 : 23

  51.     unsigned short sign = (tmp.u & 0x80000000) >> 31;

  52.     unsigned short exponent = (tmp.u & 0x7F800000) >> 23;

  53.     unsigned int significand = tmp.u & 0x7FFFFF;

  54. 

  55. //     fprintf(stderr, "%d %d %d\n", sign, exponent, significand);

  56. 

  57.     // 1 : 5 : 10

  58.     unsigned short fp16;

  59.     if (exponent == 0)

  60.     {

  61.         // zero or denormal, always underflow

  62.         fp16 = (sign << 15) | (0x00 << 10) | 0x00;

  63.     }

  64.     else if (exponent == 0xFF)

  65.     {

  66.         // infinity or NaN

  67.         fp16 = (sign << 15) | (0x1F << 10) | (significand ? 0x200 : 0x00);

  68.     }

  69.     else

  70.     {

  71.         // normalized

  72.         short newexp = exponent + (- 127 + 15);

  73.         if (newexp >= 31)

  74.         {

  75.             // overflow, return infinity

  76.             fp16 = (sign << 15) | (0x1F << 10) | 0x00;

  77.         }

  78.         else if (newexp <= 0)

  79.         {

  80.             // underflow

  81.             if (newexp >= -10)

  82.             {

  83.                 // denormal half-precision

  84.                 unsigned short sig = (significand | 0x800000) >> (14 - newexp);

  85.                 fp16 = (sign << 15) | (0x00 << 10) | sig;

  86.             }

  87.             else

  88.             {

  89.                 // underflow

  90.                 fp16 = (sign << 15) | (0x00 << 10) | 0x00;

  91.             }

  92.         }

  93.         else

  94.         {

  95.             fp16 = (sign << 15) | (newexp << 10) | (significand >> 13);

  96.         }

  97.     }

  98. 

  99.     return fp16;

  100. }

  101. 

  102. // round to nearest

  103. static signed char float2int8(float value)

  104. {

  105.     float tmp;

  106.     if (value >= 0.f) tmp = value + 0.5;

  107.     else tmp = value - 0.5;

  108. 

  109.     if (tmp > 127)

  110.         return 127;

  111.     if (tmp < -127)

  112.         return -127;

  113. 

  114.     return tmp;

  115. }

  116. 

  117. static bool read_int8scale_table(const char* filepath, std::map<std::string, std::vector<float> >& blob_int8scale_table, std::map<std::string, std::vector<float> >& weight_int8scale_table)

  118. {

  119.     blob_int8scale_table.clear();

  120.     weight_int8scale_table.clear();

  121. 

  122.     FILE* fp = fopen(filepath, "rb");

  123.     if (!fp)

  124.     {

  125.         fprintf(stderr, "fopen %s failed\n", filepath);

  126.         return false;

  127.     }

  128. 

  129.     bool in_scale_vector = false;

  130. 

  131.     std::string keystr;

  132.     std::vector<float> scales;

  133. 

  134.     while (!feof(fp))

  135.     {

  136.         char key[256];

  137.         int nscan = fscanf(fp, "%255s", key);

  138.         if (nscan != 1)

  139.         {

  140.             break;

  141.         }

  142. 

  143.         if (in_scale_vector)

  144.         {

  145.             float scale = 1.f;

  146.             int nscan = sscanf(key, "%f", &scale);

  147.             if (nscan == 1)

  148.             {

  149.                 scales.push_back(scale);

  150.                 continue;

  151.             }

  152.             else

  153.             {

  154.                 // XYZ_param_N pattern

  155.                 if (strstr(keystr.c_str(), "_param_"))

  156.                 {

  157.                     weight_int8scale_table[ keystr ] = scales;

  158.                 }

  159.                 else

  160.                 {

  161.                     blob_int8scale_table[ keystr ] = scales;

  162.                 }

  163. 

  164.                 keystr.clear();

  165.                 scales.clear();

  166. 

  167.                 in_scale_vector = false;

  168.             }

  169.         }

  170. 

  171.         if (!in_scale_vector)

  172.         {

  173.             keystr = key;

  174. 

  175.             in_scale_vector = true;

  176.         }

  177.     }

  178. 

  179.     if (in_scale_vector)

  180.     {

  181.         // XYZ_param_N pattern

  182.         if (strstr(keystr.c_str(), "_param_"))

  183.         {

  184.             weight_int8scale_table[ keystr ] = scales;

  185.         }

  186.         else

  187.         {

  188.             blob_int8scale_table[ keystr ] = scales;

  189.         }

  190.     }

  191. 

  192.     fclose(fp);

  193. 

  194.     return true;

  195. }

  196. 

  197. static int quantize_weight(float *data, size_t data_length, std::vector<unsigned short>& float16_weights)

  198. {

  199.     float16_weights.resize(data_length);

  200. 

  201.     for (size_t i = 0; i < data_length; i++)

  202.     {

  203.         float f = data[i];

  204. 

  205.         unsigned short fp16 = float2half(f);

  206. 

  207.         float16_weights[i] = fp16;

  208.     }

  209. 

  210.     // magic tag for half-precision floating point

  211.     return 0x01306B47;

  212. }

  213. 

  214. static int quantize_weight(float *data, size_t data_length, std::vector<float> scales, std::vector<signed char>& int8_weights)

  215. {

  216.     int8_weights.resize(data_length);

  217. 

  218.     int length_per_group = data_length / scales.size();

  219. 

  220.     for (size_t i = 0; i < data_length; i++)

  221.     {

  222.         float f = data[i];

  223. 

  224.         signed char int8 = float2int8(f * scales[ i / length_per_group ]);

  225. 

  226.         int8_weights[i] = int8;

  227.     }

  228. 

  229.     // magic tag for int8

  230.     return 0x000D4B38;

  231. }

  232. 

  233. static bool quantize_weight(float *data, size_t data_length, int quantize_level, std::vector<float> &quantize_table, std::vector<unsigned char> &quantize_index) {

  234. 

  235.     assert(quantize_level != 0);

  236.     assert(data != NULL);

  237.     assert(data_length > 0);

  238. 

  239.     if (data_length < static_cast<size_t>(quantize_level)) {

  240.         fprintf(stderr, "No need quantize,because: data_length < quantize_level");

  241.         return false;

  242.     }

  243. 

  244.     quantize_table.reserve(quantize_level);

  245.     quantize_index.reserve(data_length);

  246. 

  247.     // 1. Find min and max value

  248.     float max_value = std::numeric_limits<float>::min();

  249.     float min_value = std::numeric_limits<float>::max();

  250. 

  251.     for (size_t i = 0; i < data_length; ++i)

  252.     {

  253.         if (max_value < data[i]) max_value = data[i];

  254.         if (min_value > data[i]) min_value = data[i];

  255.     }

  256.     float strides = (max_value - min_value) / quantize_level;

  257. 

  258.     // 2. Generate quantize table

  259.     for (int i = 0; i < quantize_level; ++i)

  260.     {

  261.         quantize_table.push_back(min_value + i * strides);

  262.     }

  263. 

  264.     // 3. Align data to the quantized value

  265.     for (size_t i = 0; i < data_length; ++i)

  266.     {

  267.         size_t table_index = int((data[i] - min_value) / strides);

  268.         table_index = std::min<float>(table_index, quantize_level - 1);

  269. 

  270.         float low_value  = quantize_table[table_index];

  271.         float high_value = low_value + strides;

  272. 

  273.         // find a nearest value between low and high value.

  274.         float targetValue = data[i] - low_value < high_value - data[i] ? low_value : high_value;

  275. 

  276.         table_index = int((targetValue - min_value) / strides);

  277.         table_index = std::min<float>(table_index, quantize_level - 1);

  278.         quantize_index.push_back(table_index);

  279.     }

  280. 

  281.     return true;

  282. }

  283. 

  284. static bool read_proto_from_text(const char* filepath, google::protobuf::Message* message)

  285. {

  286.     std::ifstream fs(filepath, std::ifstream::in);

  287.     if (!fs.is_open())

  288.     {

  289.         fprintf(stderr, "open failed %s\n", filepath);

  290.         return false;

  291.     }

  292. 

  293.     google::protobuf::io::IstreamInputStream input(&fs);

  294.     bool success = google::protobuf::TextFormat::Parse(&input, message);

  295. 

  296.     fs.close();

  297. 

  298.     return success;

  299. }

  300. 

  301. static bool read_proto_from_binary(const char* filepath, google::protobuf::Message* message)

  302. {

  303.     std::ifstream fs(filepath, std::ifstream::in | std::ifstream::binary);

  304.     if (!fs.is_open())

  305.     {

  306.         fprintf(stderr, "open failed %s\n", filepath);

  307.         return false;

  308.     }

  309. 

  310.     google::protobuf::io::IstreamInputStream input(&fs);

  311.     google::protobuf::io::CodedInputStream codedstr(&input);

  312. 

  313.     codedstr.SetTotalBytesLimit(INT_MAX, INT_MAX / 2);

  314. 

  315.     bool success = message->ParseFromCodedStream(&codedstr);

  316. 

  317.     fs.close();

  318. 

  319.     return success;

  320. }

  321. 

  322. int main(int argc, char** argv)

  323. {

  324.     if (!(argc == 3 || argc == 5 || argc == 6 || argc == 7))

  325.     {

  326.         fprintf(stderr, "Usage: %s [caffeproto] [caffemodel] [ncnnproto] [ncnnbin] [quantizelevel] [int8scaletable]\n", argv[0]);

  327.         return -1;

  328.     }

  329. 

  330.     const char* caffeproto = argv[1];

  331.     const char* caffemodel = argv[2];

  332.     const char* ncnn_prototxt = argc >= 5 ? argv[3] : "ncnn.proto";

  333.     const char* ncnn_modelbin = argc >= 5 ? argv[4] : "ncnn.bin";

  334.     const char* quantize_param = argc >= 6 ? argv[5] : "0";

  335.     const char* int8scale_table_path = argc == 7 ? argv[6] : NULL;

  336.     int quantize_level = atoi(quantize_param);

  337. 

  338.     if (quantize_level != 0 && quantize_level != 256 && quantize_level != 65536) {

  339.         fprintf(stderr, "%s: only support quantize level = 0, 256, or 65536", argv[0]);

  340.         return -1;

  341.     }

  342. 

  343.     caffe::NetParameter proto;

  344.     caffe::NetParameter net;

  345. 

  346.     // load

  347.     bool s0 = read_proto_from_text(caffeproto, &proto);

  348.     if (!s0)

  349.     {

  350.         fprintf(stderr, "read_proto_from_text failed\n");

  351.         return -1;

  352.     }

  353. 

  354.     bool s1 = read_proto_from_binary(caffemodel, &net);

  355.     if (!s1)

  356.     {

  357.         fprintf(stderr, "read_proto_from_binary failed\n");

  358.         return -1;

  359.     }

  360. 

  361.     std::map<std::string, std::vector<float> > blob_int8scale_table;

  362.     std::map<std::string, std::vector<float> > weight_int8scale_table;

  363.     if (int8scale_table_path)

  364.     {

  365.         bool s2 = read_int8scale_table(int8scale_table_path, blob_int8scale_table, weight_int8scale_table);

  366.         if (!s2)

  367.         {

  368.             fprintf(stderr, "read_int8scale_table failed\n");

  369.             return -1;

  370.         }

  371.     }

  372. 

  373.     FILE* pp = fopen(ncnn_prototxt, "wb");

  374.     FILE* bp = fopen(ncnn_modelbin, "wb");

  375. 

  376.     // magic

  377.     fprintf(pp, "7767517\n");

  378. 

  379.     // rename mapping for identical bottom top style

  380.     std::map<std::string, std::string> blob_name_decorated;

  381. 

  382.     // bottom blob reference

  383.     std::map<std::string, int> bottom_reference;

  384. 

  385.     // global definition line

  386.     // [layer count] [blob count]

  387.     int layer_count = proto.layer_size();

  388.     std::set<std::string> blob_names;

  389.     for (int i=0; i<layer_count; i++)

  390.     {

  391.         const caffe::LayerParameter& layer = proto.layer(i);

  392. 

  393.         for (int j=0; j<layer.bottom_size(); j++)

  394.         {

  395.             std::string blob_name = layer.bottom(j);

  396.             if (blob_name_decorated.find(blob_name) != blob_name_decorated.end())

  397.             {

  398.                 blob_name = blob_name_decorated[blob_name];

  399.             }

  400. 

  401.             blob_names.insert(blob_name);

  402. 

  403.             if (bottom_reference.find(blob_name) == bottom_reference.end())

  404.             {

  405.                 bottom_reference[blob_name] = 1;

  406.             }

  407.             else

  408.             {

  409.                 bottom_reference[blob_name] = bottom_reference[blob_name] + 1;

  410.             }

  411.         }

  412. 

  413.         if (layer.bottom_size() == 1 && layer.top_size() == 1 && layer.bottom(0) == layer.top(0))

  414.         {

  415.             std::string blob_name = layer.top(0) + "_" + layer.name();

  416.             blob_name_decorated[layer.top(0)] = blob_name;

  417.             blob_names.insert(blob_name);

  418.         }

  419.         else

  420.         {

  421.             for (int j=0; j<layer.top_size(); j++)

  422.             {

  423.                 std::string blob_name = layer.top(j);

  424.                 blob_names.insert(blob_name);

  425.             }

  426.         }

  427.     }

  428.     // remove bottom_reference entry with reference equals to one

  429.     int splitncnn_blob_count = 0;

  430.     std::map<std::string, int>::iterator it = bottom_reference.begin();

  431.     while (it != bottom_reference.end())

  432.     {

  433.         if (it->second == 1)

  434.         {

  435.             bottom_reference.erase(it++);

  436.         }

  437.         else

  438.         {

  439.             splitncnn_blob_count += it->second;

  440. //             fprintf(stderr, "%s %d\n", it->first.c_str(), it->second);

  441.             ++it;

  442.         }

  443.     }

  444.     fprintf(pp, "%lu %lu\n", layer_count + bottom_reference.size(), blob_names.size() + splitncnn_blob_count);

  445. 

  446.     // populate

  447.     blob_name_decorated.clear();

  448.     int internal_split = 0;

  449.     for (int i=0; i<layer_count; i++)

  450.     {

  451.         const caffe::LayerParameter& layer = proto.layer(i);

  452. 

  453.         // layer definition line, repeated

  454.         // [type] [name] [bottom blob count] [top blob count] [bottom blobs] [top blobs] [layer specific params]

  455.         if (layer.type() == "BN")

  456.         {

  457.             fprintf(pp, "%-16s", "Scale");

  458.         }

  459.         else if (layer.type() == "Convolution")

  460.         {

  461.             const caffe::ConvolutionParameter& convolution_param = layer.convolution_param();

  462.             if (convolution_param.group() != 1)

  463.                 fprintf(pp, "%-16s", "ConvolutionDepthWise");

  464.             else

  465.                 fprintf(pp, "%-16s", "Convolution");

  466.         }

  467.         else if (layer.type() == "ConvolutionDepthwise" || layer.type() == "DepthwiseConvolution")

  468.         {

  469.             fprintf(pp, "%-16s", "ConvolutionDepthWise");

  470.         }

  471.         else if (layer.type() == "Deconvolution")

  472.         {

  473.             const caffe::ConvolutionParameter& convolution_param = layer.convolution_param();

  474.             if (convolution_param.group() != 1)

  475.                 fprintf(pp, "%-16s", "DeconvolutionDepthWise");

  476.             else

  477.                 fprintf(pp, "%-16s", "Deconvolution");

  478.         }

  479.         else if (layer.type() == "MemoryData")

  480.         {

  481.             fprintf(pp, "%-16s", "Input");

  482.         }

  483.         else if (layer.type() == "Python")

  484.         {

  485.             const caffe::PythonParameter& python_param = layer.python_param();

  486.             std::string python_layer_name = python_param.layer();

  487.             if (python_layer_name == "ProposalLayer")

  488.                 fprintf(pp, "%-16s", "Proposal");

  489.             else

  490.                 fprintf(pp, "%-16s", python_layer_name.c_str());

  491.         }

  492.         else if (layer.type() == "ReLU6")

  493.         {

  494.             fprintf(pp, "%-16s", "Clip");

  495.         }

  496.         else if (layer.type() == "Silence")

  497.         {

  498.             fprintf(pp, "%-16s", "Noop");

  499.         }

  500.         else

  501.         {

  502.             fprintf(pp, "%-16s", layer.type().c_str());

  503.         }

  504.         fprintf(pp, " %-16s %d %d", layer.name().c_str(), layer.bottom_size(), layer.top_size());

  505. 

  506.         for (int j=0; j<layer.bottom_size(); j++)

  507.         {

  508.             std::string blob_name = layer.bottom(j);

  509.             if (blob_name_decorated.find(layer.bottom(j)) != blob_name_decorated.end())

  510.             {

  511.                 blob_name = blob_name_decorated[layer.bottom(j)];

  512.             }

  513. 

  514.             if (bottom_reference.find(blob_name) != bottom_reference.end())

  515.             {

  516.                 int refidx = bottom_reference[blob_name] - 1;

  517.                 bottom_reference[blob_name] = refidx;

  518. 

  519.                 char splitsuffix[256];

  520.                 sprintf(splitsuffix, "_splitncnn_%d", refidx);

  521.                 blob_name = blob_name + splitsuffix;

  522.             }

  523. 

  524.             fprintf(pp, " %s", blob_name.c_str());

  525.         }

  526. 

  527.         // decorated

  528.         if (layer.bottom_size() == 1 && layer.top_size() == 1 && layer.bottom(0) == layer.top(0))

  529.         {

  530.             std::string blob_name = layer.top(0) + "_" + layer.name();

  531.             blob_name_decorated[layer.top(0)] = blob_name;

  532. 

  533.             fprintf(pp, " %s", blob_name.c_str());

  534.         }

  535.         else

  536.         {

  537.             for (int j=0; j<layer.top_size(); j++)

  538.             {

  539.                 std::string blob_name = layer.top(j);

  540.                 fprintf(pp, " %s", blob_name.c_str());

  541.             }

  542.         }

  543. 

  544.         // find blob binary by layer name

  545.         int netidx;

  546.         for (netidx=0; netidx<net.layer_size(); netidx++)

  547.         {

  548.             if (net.layer(netidx).name() == layer.name())

  549.             {

  550.                 break;

  551.             }

  552.         }

  553. 

  554.         // layer specific params

  555.         if (layer.type() == "BatchNorm")

  556.         {

  557.             const caffe::LayerParameter& binlayer = net.layer(netidx);

  558. 

  559.             const caffe::BlobProto& mean_blob = binlayer.blobs(0);

  560.             const caffe::BlobProto& var_blob = binlayer.blobs(1);

  561.             fprintf(pp, " 0=%d", (int)mean_blob.data_size());

  562. 

  563.             const caffe::BatchNormParameter& batch_norm_param = layer.batch_norm_param();

  564.             float eps = batch_norm_param.eps();

  565. 

  566.             std::vector<float> ones(mean_blob.data_size(), 1.f);

  567.             fwrite(ones.data(), sizeof(float), ones.size(), bp);// slope

  568. 

  569.             if (binlayer.blobs_size() < 3)

  570.             {

  571.                 fwrite(mean_blob.data().data(), sizeof(float), mean_blob.data_size(), bp);

  572.                 float tmp;

  573.                 for (int j=0; j<var_blob.data_size(); j++)

  574.                 {

  575.                     tmp = var_blob.data().data()[j] + eps;

  576.                     fwrite(&tmp, sizeof(float), 1, bp);

  577.                 }

  578.             }

  579.             else

  580.             {

  581.                 float scale_factor = binlayer.blobs(2).data().data()[0] == 0 ? 0 : 1 / binlayer.blobs(2).data().data()[0];

  582.                 // premultiply scale_factor to mean and variance

  583.                 float tmp;

  584.                 for (int j=0; j<mean_blob.data_size(); j++)

  585.                 {

  586.                     tmp = mean_blob.data().data()[j] * scale_factor;

  587.                     fwrite(&tmp, sizeof(float), 1, bp);

  588.                 }

  589.                 for (int j=0; j<var_blob.data_size(); j++)

  590.                 {

  591.                     tmp = var_blob.data().data()[j] * scale_factor + eps;

  592.                     fwrite(&tmp, sizeof(float), 1, bp);

  593.                 }

  594.             }

  595. 

  596.             std::vector<float> zeros(mean_blob.data_size(), 0.f);

  597.             fwrite(zeros.data(), sizeof(float), zeros.size(), bp);// bias

  598.         }

  599.         else if (layer.type() == "BN")

  600.         {

  601.             const caffe::LayerParameter& binlayer = net.layer(netidx);

  602. 

  603.             const caffe::BlobProto& scale_blob = binlayer.blobs(0);

  604.             const caffe::BlobProto& shift_blob = binlayer.blobs(1);

  605.             fprintf(pp, " 0=%d", (int)scale_blob.data_size());

  606.             fprintf(pp, " 1=1");

  607. 

  608.             fwrite(scale_blob.data().data(), sizeof(float), scale_blob.data_size(), bp);

  609.             fwrite(shift_blob.data().data(), sizeof(float), shift_blob.data_size(), bp);

  610.         }

  611.         else if (layer.type() == "Concat")

  612.         {

  613.             const caffe::ConcatParameter& concat_param = layer.concat_param();

  614.             int dim = concat_param.axis() - 1;

  615.             fprintf(pp, " 0=%d", dim);

  616.         }

  617.         else if (layer.type() == "Convolution" || layer.type() == "ConvolutionDepthwise" || layer.type() == "DepthwiseConvolution")

  618.         {

  619.             const caffe::LayerParameter& binlayer = net.layer(netidx);

  620. 

  621.             const caffe::BlobProto& weight_blob = binlayer.blobs(0);

  622.             const caffe::ConvolutionParameter& convolution_param = layer.convolution_param();

  623.             fprintf(pp, " 0=%d", convolution_param.num_output());

  624.             if (convolution_param.has_kernel_w() && convolution_param.has_kernel_h())

  625.             {

  626.                 fprintf(pp, " 1=%d", convolution_param.kernel_w());

  627.                 fprintf(pp, " 11=%d", convolution_param.kernel_h());

  628.             }

  629.             else

  630.             {

  631.                 fprintf(pp, " 1=%d", convolution_param.kernel_size(0));

  632.             }

  633.             fprintf(pp, " 2=%d", convolution_param.dilation_size() != 0 ? convolution_param.dilation(0) : 1);

  634.             if (convolution_param.has_stride_w() && convolution_param.has_stride_h())

  635.             {

  636.                 fprintf(pp, " 3=%d", convolution_param.stride_w());

  637.                 fprintf(pp, " 13=%d", convolution_param.stride_h());

  638.             }

  639.             else

  640.             {

  641.                 fprintf(pp, " 3=%d", convolution_param.stride_size() != 0 ? convolution_param.stride(0) : 1);

  642.             }

  643.             if (convolution_param.has_pad_w() && convolution_param.has_pad_h())

  644.             {

  645.                 fprintf(pp, " 4=%d", convolution_param.pad_w());

  646.                 fprintf(pp, " 14=%d", convolution_param.pad_h());

  647.             }

  648.             else

  649.             {

  650.                 fprintf(pp, " 4=%d", convolution_param.pad_size() != 0 ? convolution_param.pad(0) : 0);

  651.             }

  652.             fprintf(pp, " 5=%d", convolution_param.bias_term());

  653.             fprintf(pp, " 6=%d", weight_blob.data_size());

  654. 

  655.             int num_group = 1;

  656.             if (layer.type() == "ConvolutionDepthwise" || layer.type() == "DepthwiseConvolution")

  657.             {

  658.                 num_group = convolution_param.num_output();

  659.             }

  660.             else

  661.             {

  662.                 num_group = convolution_param.group();

  663.             }

  664. 

  665.             if (num_group != 1)

  666.             {

  667.                 fprintf(pp, " 7=%d", num_group);

  668.             }

  669. 

  670.             bool int8_scale_term = false;

  671.             std::vector<float> weight_int8scale;

  672.             std::vector<float> blob_int8scale;

  673. 

  674.             if (int8scale_table_path)

  675.             {

  676.                 char key[256];

  677.                 sprintf(key, "%s_param_0", layer.name().c_str());

  678.                 if (weight_int8scale_table.find(std::string(key)) != weight_int8scale_table.end())

  679.                 {

  680.                     weight_int8scale = weight_int8scale_table[std::string(key)];

  681.                 }

  682. 

  683.                 if (blob_int8scale_table.find(layer.name()) != blob_int8scale_table.end())

  684.                 {

  685.                     blob_int8scale = blob_int8scale_table[layer.name()];

  686.                 }

  687. 

  688.                 int8_scale_term = !weight_int8scale.empty() && !blob_int8scale.empty();

  689. 

  690.                 if (int8_scale_term)

  691.                 {

  692.                     if ((int)weight_int8scale.size() == num_group)

  693.                     {

  694.                         fprintf(pp, " 8=1");

  695.                     }

  696.                     else

  697.                     {

  698.                         fprintf(pp, " 8=2");

  699.                     }

  700.                 }

  701.             }

  702. 

  703.             for (int j = 0; j < binlayer.blobs_size(); j++)

  704.             {

  705.                 int quantize_tag = 0;

  706.                 const caffe::BlobProto& blob = binlayer.blobs(j);

  707. 

  708.                 std::vector<float> quantize_table;

  709.                 std::vector<unsigned char> quantize_index;

  710. 

  711.                 std::vector<unsigned short> float16_weights;

  712.                 std::vector<signed char> int8_weights;

  713. 

  714.                 // we will not quantize the bias values

  715.                 if (j == 0)

  716.                 {

  717.                     if (int8_scale_term)

  718.                     {

  719.                         if (quantize_level == 0)

  720.                         {

  721.                             quantize_tag = 0x0002C056;

  722.                         }

  723.                         else if (quantize_level == 256)

  724.                         {

  725.                             quantize_tag = quantize_weight((float *)blob.data().data(), blob.data_size(), weight_int8scale, int8_weights);

  726.                         }

  727.                     }

  728.                     else if (quantize_level == 256)

  729.                     {

  730.                         quantize_tag = quantize_weight((float *)blob.data().data(), blob.data_size(), quantize_level, quantize_table, quantize_index);

  731.                     }

  732.                     else if (quantize_level == 65536)

  733.                     {

  734.                         quantize_tag = quantize_weight((float *)blob.data().data(), blob.data_size(), float16_weights);

  735.                     }

  736. 

  737.                     // write quantize tag first

  738.                     fwrite(&quantize_tag, sizeof(int), 1, bp);

  739. 

  740.                     if (quantize_tag)

  741.                     {

  742.                         int p0 = ftell(bp);

  743.                         if (int8_scale_term)

  744.                         {

  745.                             if (quantize_level == 0)

  746.                             {

  747.                                 // write original data and int8scale

  748.                                 fwrite(blob.data().data(), sizeof(float), blob.data_size(), bp);

  749.                             }

  750.                             else if (quantize_level == 256)

  751.                             {

  752.                                 fwrite(int8_weights.data(), sizeof(signed char), int8_weights.size(), bp);

  753.                             }

  754.                         }

  755.                         else if (quantize_level == 256)

  756.                         {

  757.                             // write quantize table and index

  758.                             fwrite(quantize_table.data(), sizeof(float), quantize_table.size(), bp);

  759.                             fwrite(quantize_index.data(), sizeof(unsigned char), quantize_index.size(), bp);

  760.                         }

  761.                         else if (quantize_level == 65536)

  762.                         {

  763.                             fwrite(float16_weights.data(), sizeof(unsigned short), float16_weights.size(), bp);

  764.                         }

  765. 

  766.                         // padding to 32bit align

  767.                         int nwrite = ftell(bp) - p0;

  768.                         int nalign = alignSize(nwrite, 4);

  769.                         unsigned char padding[4] = {0x00, 0x00, 0x00, 0x00};

  770.                         fwrite(padding, sizeof(unsigned char), nalign - nwrite, bp);

  771.                     }

  772.                     else

  773.                     {

  774.                         // write original data

  775.                         fwrite(blob.data().data(), sizeof(float), blob.data_size(), bp);

  776.                     }

  777.                 }

  778.                 else

  779.                 {

  780.                     // write original data

  781.                     fwrite(blob.data().data(), sizeof(float), blob.data_size(), bp);

  782.                 }

  783.             }

  784. 

  785.             if (int8_scale_term)

  786.             {

  787.                 // write int8_scale data

  788.                 fwrite(weight_int8scale.data(), sizeof(float), weight_int8scale.size(), bp);

  789.                 fwrite(blob_int8scale.data(), sizeof(float), blob_int8scale.size(), bp);

  790.             }

  791.         }

  792.         else if (layer.type() == "Crop")

  793.         {

  794.             const caffe::CropParameter& crop_param = layer.crop_param();

  795.             int num_offset = crop_param.offset_size();

  796.             if (num_offset == 1)

  797.             {

  798.                 int offset = crop_param.offset(0);

  799.                 int axis = crop_param.axis();

  800.                 if (axis == 1)

  801.                 {

  802.                     fprintf(pp, " 0=%d", offset);

  803.                     fprintf(pp, " 1=%d", offset);

  804.                     fprintf(pp, " 2=%d", offset);

  805.                 }

  806.                 else if (axis == 2)

  807.                 {

  808.                     fprintf(pp, " 0=%d", offset);

  809.                     fprintf(pp, " 1=%d", offset);

  810.                 }

  811.                 else if (axis == 3)

  812.                 {

  813.                     fprintf(pp, " 0=%d", offset);

  814.                 }

  815.             }

  816.             else if (num_offset == 2)

  817.             {

  818.                 int woffset = crop_param.offset(1);

  819.                 int hoffset = crop_param.offset(0);

  820.                 fprintf(pp, " 0=%d", woffset);

  821.                 fprintf(pp, " 1=%d", hoffset);

  822.             }

  823.             else if (num_offset == 3)

  824.             {

  825.                 int woffset = crop_param.offset(2);

  826.                 int hoffset = crop_param.offset(1);

  827.                 int coffset = crop_param.offset(0);

  828.                 fprintf(pp, " 0=%d", woffset);

  829.                 fprintf(pp, " 1=%d", hoffset);

  830.                 fprintf(pp, " 2=%d", coffset);

  831.             }

  832.         }

  833.         else if (layer.type() == "Deconvolution")

  834.         {

  835.             const caffe::LayerParameter& binlayer = net.layer(netidx);

  836. 

  837.             const caffe::BlobProto& weight_blob = binlayer.blobs(0);

  838.             const caffe::ConvolutionParameter& convolution_param = layer.convolution_param();

  839.             fprintf(pp, " 0=%d", convolution_param.num_output());

  840.             if (convolution_param.has_kernel_w() && convolution_param.has_kernel_h())

  841.             {

  842.                 fprintf(pp, " 1=%d", convolution_param.kernel_w());

  843.                 fprintf(pp, " 11=%d", convolution_param.kernel_h());

  844.             }

  845.             else

  846.             {

  847.                 fprintf(pp, " 1=%d", convolution_param.kernel_size(0));

  848.             }

  849.             fprintf(pp, " 2=%d", convolution_param.dilation_size() != 0 ? convolution_param.dilation(0) : 1);

  850.             if (convolution_param.has_stride_w() && convolution_param.has_stride_h())

  851.             {

  852.                 fprintf(pp, " 3=%d", convolution_param.stride_w());

  853.                 fprintf(pp, " 13=%d", convolution_param.stride_h());

  854.             }

  855.             else

  856.             {

  857.                 fprintf(pp, " 3=%d", convolution_param.stride_size() != 0 ? convolution_param.stride(0) : 1);

  858.             }

  859.             if (convolution_param.has_pad_w() && convolution_param.has_pad_h())

  860.             {

  861.                 fprintf(pp, " 4=%d", convolution_param.pad_w());

  862.                 fprintf(pp, " 14=%d", convolution_param.pad_h());

  863.             }

  864.             else

  865.             {

  866.                 fprintf(pp, " 4=%d", convolution_param.pad_size() != 0 ? convolution_param.pad(0) : 0);

  867.             }

  868.             fprintf(pp, " 5=%d", convolution_param.bias_term());

  869.             fprintf(pp, " 6=%d", weight_blob.data_size());

  870. 

  871.             int group = convolution_param.group();

  872.             if (group != 1)

  873.             {

  874.                 fprintf(pp, " 7=%d", group);

  875.             }

  876. 

  877.             int quantized_weight = 0;

  878.             fwrite(&quantized_weight, sizeof(int), 1, bp);

  879. 

  880.             int maxk = 0;

  881.             if (convolution_param.has_kernel_w() && convolution_param.has_kernel_h())

  882.             {

  883.                 maxk = convolution_param.kernel_w() * convolution_param.kernel_h();

  884.             }

  885.             else

  886.             {

  887.                 maxk = convolution_param.kernel_size(0) * convolution_param.kernel_size(0);

  888.             }

  889.             for (int g=0; g<group; g++)

  890.             {

  891.             // reorder weight from inch-outch to outch-inch

  892.             int num_output = convolution_param.num_output() / group;

  893.             int num_input = weight_blob.data_size() / maxk / num_output / group;

  894.             const float* weight_data_ptr = weight_blob.data().data() + g * maxk * num_output * num_input;

  895.             for (int k=0; k<num_output; k++)

  896.             {

  897.                 for (int j=0; j<num_input; j++)

  898.                 {

  899.                     fwrite(weight_data_ptr + (j*num_output + k) * maxk, sizeof(float), maxk, bp);

  900.                 }

  901.             }

  902.             }

  903. 

  904.             for (int j=1; j<binlayer.blobs_size(); j++)

  905.             {

  906.                 const caffe::BlobProto& blob = binlayer.blobs(j);

  907.                 fwrite(blob.data().data(), sizeof(float), blob.data_size(), bp);

  908.             }

  909.         }

  910.         else if (layer.type() == "DetectionOutput")

  911.         {

  912.             const caffe::DetectionOutputParameter& detection_output_param = layer.detection_output_param();

  913.             const caffe::NonMaximumSuppressionParameter& nms_param = detection_output_param.nms_param();

  914.             fprintf(pp, " 0=%d", detection_output_param.num_classes());

  915.             fprintf(pp, " 1=%e", nms_param.nms_threshold());

  916.             fprintf(pp, " 2=%d", nms_param.top_k());

  917.             fprintf(pp, " 3=%d", detection_output_param.keep_top_k());

  918.             fprintf(pp, " 4=%e", detection_output_param.confidence_threshold());

  919.         }

  920.         else if (layer.type() == "Dropout")

  921.         {

  922.             const caffe::DropoutParameter& dropout_param = layer.dropout_param();

  923.             if (dropout_param.has_scale_train() && !dropout_param.scale_train())

  924.             {

  925.                 float scale = 1.f - dropout_param.dropout_ratio();

  926.                 fprintf(pp, " 0=%e", scale);

  927.             }

  928.         }

  929.         else if (layer.type() == "Eltwise")

  930.         {

  931.             const caffe::EltwiseParameter& eltwise_param = layer.eltwise_param();

  932.             int coeff_size = eltwise_param.coeff_size();

  933.             fprintf(pp, " 0=%d", (int)eltwise_param.operation());

  934.             fprintf(pp, " -23301=%d", coeff_size);

  935.             for (int j=0; j<coeff_size; j++)

  936.             {

  937.                 fprintf(pp, ",%e", eltwise_param.coeff(j));

  938.             }

  939.         }

  940.         else if (layer.type() == "ELU")

  941.         {

  942.             const caffe::ELUParameter& elu_param = layer.elu_param();

  943.             fprintf(pp, " 0=%e", elu_param.alpha());

  944.         }

  945.         else if (layer.type() == "Embed")

  946.         {

  947.             const caffe::LayerParameter& binlayer = net.layer(netidx);

  948. 

  949.             const caffe::BlobProto& weight_blob = binlayer.blobs(0);

  950.             const caffe::EmbedParameter& embed_param = layer.embed_param();

  951.             fprintf(pp, " 0=%d", embed_param.num_output());

  952.             fprintf(pp, " 1=%d", embed_param.input_dim());

  953.             fprintf(pp, " 2=%d", embed_param.bias_term());

  954.             fprintf(pp, " 3=%d", weight_blob.data_size());

  955. 

  956.             for (int j=0; j<binlayer.blobs_size(); j++)

  957.             {

  958.                 int quantize_tag = 0;

  959.                 const caffe::BlobProto& blob = binlayer.blobs(j);

  960. 

  961.                 std::vector<float> quantize_table;

  962.                 std::vector<unsigned char> quantize_index;

  963. 

  964.                 std::vector<unsigned short> float16_weights;

  965. 

  966.                 // we will not quantize the bias values

  967.                 if (j == 0 && quantize_level != 0)

  968.                 {

  969.                     if (quantize_level == 256)

  970.                     {

  971.                         quantize_tag = quantize_weight((float *)blob.data().data(), blob.data_size(), quantize_level, quantize_table, quantize_index);

  972.                     }

  973.                     else if (quantize_level == 65536)

  974.                     {

  975.                         quantize_tag = quantize_weight((float *)blob.data().data(), blob.data_size(), float16_weights);

  976.                     }

  977.                 }

  978. 

  979.                 // write quantize tag first

  980.                 if (j == 0)

  981.                     fwrite(&quantize_tag, sizeof(int), 1, bp);

  982. 

  983.                 if (quantize_tag)

  984.                 {

  985.                     int p0 = ftell(bp);

  986.                     if (quantize_level == 256)

  987.                     {

  988.                         // write quantize table and index

  989.                         fwrite(quantize_table.data(), sizeof(float), quantize_table.size(), bp);

  990.                         fwrite(quantize_index.data(), sizeof(unsigned char), quantize_index.size(), bp);

  991.                     }

  992.                     else if (quantize_level == 65536)

  993.                     {

  994.                         fwrite(float16_weights.data(), sizeof(unsigned short), float16_weights.size(), bp);

  995.                     }

  996.                     // padding to 32bit align

  997.                     int nwrite = ftell(bp) - p0;

  998.                     int nalign = alignSize(nwrite, 4);

  999.                     unsigned char padding[4] = {0x00, 0x00, 0x00, 0x00};

  1000.                     fwrite(padding, sizeof(unsigned char), nalign - nwrite, bp);

  1001.                 }

  1002.                 else

  1003.                 {

  1004.                     // write original data

  1005.                     fwrite(blob.data().data(), sizeof(float), blob.data_size(), bp);

  1006.                 }

  1007.             }

  1008.         }

  1009.         else if (layer.type() == "InnerProduct")

  1010.         {

  1011.             const caffe::LayerParameter& binlayer = net.layer(netidx);

  1012. 

  1013.             const caffe::BlobProto& weight_blob = binlayer.blobs(0);

  1014.             const caffe::InnerProductParameter& inner_product_param = layer.inner_product_param();

  1015.             fprintf(pp, " 0=%d", inner_product_param.num_output());

  1016.             fprintf(pp, " 1=%d", inner_product_param.bias_term());

  1017.             fprintf(pp, " 2=%d", weight_blob.data_size());

  1018. 

  1019.             bool int8_scale_term = false;

  1020.             std::vector<float> weight_int8scale;

  1021.             std::vector<float> blob_int8scale;

  1022. 

  1023.             if (int8scale_table_path)

  1024.             {

  1025.                 char key[256];

  1026.                 sprintf(key, "%s_param_0", layer.name().c_str());

  1027.                 if (weight_int8scale_table.find(std::string(key)) != weight_int8scale_table.end())

  1028.                 {

  1029.                     weight_int8scale = weight_int8scale_table[std::string(key)];

  1030.                 }

  1031. 

  1032.                 if (blob_int8scale_table.find(layer.name()) != blob_int8scale_table.end())

  1033.                 {

  1034.                     blob_int8scale = blob_int8scale_table[layer.name()];

  1035.                 }

  1036. 

  1037.                 int8_scale_term = !weight_int8scale.empty() && !blob_int8scale.empty();

  1038. 

  1039.                 if (int8_scale_term)

  1040.                 {

  1041.                     fprintf(pp, " 8=1");

  1042.                 }

  1043.             }

  1044. 

  1045.             for (int j=0; j<binlayer.blobs_size(); j++)

  1046.             {

  1047.                 int quantize_tag = 0;

  1048.                 const caffe::BlobProto& blob = binlayer.blobs(j);

  1049. 

  1050.                 std::vector<float> quantize_table;

  1051.                 std::vector<unsigned char> quantize_index;

  1052. 

  1053.                 std::vector<unsigned short> float16_weights;

  1054.                 std::vector<signed char> int8_weights;

  1055. 

  1056.                 // we will not quantize the bias values

  1057.                 if (j == 0)

  1058.                 {

  1059.                     if (int8_scale_term)

  1060.                     {

  1061.                         if (quantize_level == 0)

  1062.                         {

  1063.                             quantize_tag = 0x0002C056;

  1064.                         }

  1065.                         else if (quantize_level == 256)

  1066.                         {

  1067.                             quantize_tag = quantize_weight((float *)blob.data().data(), blob.data_size(), weight_int8scale, int8_weights);

  1068.                         }

  1069.                     }

  1070.                     else if (quantize_level == 256)

  1071.                     {

  1072.                         quantize_tag = quantize_weight((float *)blob.data().data(), blob.data_size(), quantize_level, quantize_table, quantize_index);

  1073.                     }

  1074.                     else if (quantize_level == 65536)

  1075.                     {

  1076.                         quantize_tag = quantize_weight((float *)blob.data().data(), blob.data_size(), float16_weights);

  1077.                     }

  1078. 

  1079.                     // write quantize tag first

  1080.                     fwrite(&quantize_tag, sizeof(int), 1, bp);

  1081. 

  1082.                     if (quantize_tag)

  1083.                     {

  1084.                         int p0 = ftell(bp);

  1085.                         if (int8_scale_term)

  1086.                         {

  1087.                             if (quantize_level == 0)

  1088.                             {

  1089.                                 // write original data and int8scale

  1090.                                 fwrite(blob.data().data(), sizeof(float), blob.data_size(), bp);

  1091.                             }

  1092.                             else if (quantize_level == 256)

  1093.                             {

  1094.                                 fwrite(int8_weights.data(), sizeof(signed char), int8_weights.size(), bp);

  1095.                             }

  1096.                         }

  1097.                         else if (quantize_level == 256)

  1098.                         {

  1099.                             // write quantize table and index

  1100.                             fwrite(quantize_table.data(), sizeof(float), quantize_table.size(), bp);

  1101.                             fwrite(quantize_index.data(), sizeof(unsigned char), quantize_index.size(), bp);

  1102.                         }

  1103.                         else if (quantize_level == 65536)

  1104.                         {

  1105.                             fwrite(float16_weights.data(), sizeof(unsigned short), float16_weights.size(), bp);

  1106.                         }

  1107. 

  1108.                         // padding to 32bit align

  1109.                         int nwrite = ftell(bp) - p0;

  1110.                         int nalign = alignSize(nwrite, 4);

  1111.                         unsigned char padding[4] = {0x00, 0x00, 0x00, 0x00};

  1112.                         fwrite(padding, sizeof(unsigned char), nalign - nwrite, bp);

  1113.                     }

  1114.                     else

  1115.                     {

  1116.                         // write original data

  1117.                         fwrite(blob.data().data(), sizeof(float), blob.data_size(), bp);

  1118.                     }

  1119.                 }

  1120.                 else

  1121.                 {

  1122.                     // write original data

  1123.                     fwrite(blob.data().data(), sizeof(float), blob.data_size(), bp);

  1124.                 }

  1125.             }

  1126. 

  1127.             if (int8_scale_term)

  1128.             {

  1129.                 // write int8_scale data

  1130.                 fwrite(weight_int8scale.data(), sizeof(float), weight_int8scale.size(), bp);

  1131.                 fwrite(blob_int8scale.data(), sizeof(float), blob_int8scale.size(), bp);

  1132.             }

  1133.         }

  1134.         else if (layer.type() == "Input")

  1135.         {

  1136.             const caffe::InputParameter& input_param = layer.input_param();

  1137.             const caffe::BlobShape& bs = input_param.shape(0);

  1138.             if (bs.dim_size() == 4)

  1139.             {

  1140.                 fprintf(pp, " 0=%ld", bs.dim(3));

  1141.                 fprintf(pp, " 1=%ld", bs.dim(2));

  1142.                 fprintf(pp, " 2=%ld", bs.dim(1));

  1143.             }

  1144.             else if (bs.dim_size() == 3)

  1145.             {

  1146.                 fprintf(pp, " 0=%ld", bs.dim(2));

  1147.                 fprintf(pp, " 1=%ld", bs.dim(1));

  1148.                 fprintf(pp, " 2=-233");

  1149.             }

  1150.             else if (bs.dim_size() == 2)

  1151.             {

  1152.                 fprintf(pp, " 0=%ld", bs.dim(1));

  1153.                 fprintf(pp, " 1=-233");

  1154.                 fprintf(pp, " 2=-233");

  1155.             }

  1156.         }

  1157.         else if (layer.type() == "Interp")

  1158.         {

  1159.             const caffe::InterpParameter& interp_param = layer.interp_param();

  1160.             fprintf(pp, " 0=%d", 2);

  1161.             fprintf(pp, " 1=%e", (float)interp_param.zoom_factor());

  1162.             fprintf(pp, " 2=%e", (float)interp_param.zoom_factor());

  1163.             fprintf(pp, " 3=%d", interp_param.height());

  1164.             fprintf(pp, " 4=%d", interp_param.width());

  1165.         }

  1166.         else if (layer.type() == "LRN")

  1167.         {

  1168.             const caffe::LRNParameter& lrn_param = layer.lrn_param();

  1169.             fprintf(pp, " 0=%d", lrn_param.norm_region());

  1170.             fprintf(pp, " 1=%d", lrn_param.local_size());

  1171.             fprintf(pp, " 2=%e", lrn_param.alpha());

  1172.             fprintf(pp, " 3=%e", lrn_param.beta());

  1173.         }

  1174.         else if (layer.type() == "LSTM")

  1175.         {

  1176.             const caffe::LayerParameter& binlayer = net.layer(netidx);

  1177. 

  1178.             const caffe::BlobProto& weight_blob = binlayer.blobs(0);

  1179.             const caffe::RecurrentParameter& recurrent_param = layer.recurrent_param();

  1180.             fprintf(pp, " 0=%d", recurrent_param.num_output());

  1181.             fprintf(pp, " 1=%d", weight_blob.data_size());

  1182. 

  1183.             for (int j=0; j<binlayer.blobs_size(); j++)

  1184.             {

  1185.                 int quantize_tag = 0;

  1186.                 const caffe::BlobProto& blob = binlayer.blobs(j);

  1187. 

  1188.                 std::vector<float> quantize_table;

  1189.                 std::vector<unsigned char> quantize_index;

  1190. 

  1191.                 std::vector<unsigned short> float16_weights;

  1192. 

  1193.                 if (quantize_level != 0)

  1194.                 {

  1195.                     if (quantize_level == 256)

  1196.                     {

  1197.                         quantize_tag = quantize_weight((float *)blob.data().data(), blob.data_size(), quantize_level, quantize_table, quantize_index);

  1198.                     }

  1199.                     else if (quantize_level == 65536)

  1200.                     {

  1201.                         quantize_tag = quantize_weight((float *)blob.data().data(), blob.data_size(), float16_weights);

  1202.                     }

  1203.                 }

  1204. 

  1205.                 // write quantize tag first

  1206.                 fwrite(&quantize_tag, sizeof(int), 1, bp);

  1207. 

  1208.                 if (quantize_tag)

  1209.                 {

  1210.                     int p0 = ftell(bp);

  1211.                     if (quantize_level == 256)

  1212.                     {

  1213.                         // write quantize table and index

  1214.                         fwrite(quantize_table.data(), sizeof(float), quantize_table.size(), bp);

  1215.                         fwrite(quantize_index.data(), sizeof(unsigned char), quantize_index.size(), bp);

  1216.                     }

  1217.                     else if (quantize_level == 65536)

  1218.                     {

  1219.                         fwrite(float16_weights.data(), sizeof(unsigned short), float16_weights.size(), bp);

  1220.                     }

  1221.                     // padding to 32bit align

  1222.                     int nwrite = ftell(bp) - p0;

  1223.                     int nalign = alignSize(nwrite, 4);

  1224.                     unsigned char padding[4] = {0x00, 0x00, 0x00, 0x00};

  1225.                     fwrite(padding, sizeof(unsigned char), nalign - nwrite, bp);

  1226.                 }

  1227.                 else

  1228.                 {

  1229.                     // write original data

  1230.                     fwrite(blob.data().data(), sizeof(float), blob.data_size(), bp);

  1231.                 }

  1232.             }

  1233.         }

  1234.         else if (layer.type() == "MemoryData")

  1235.         {

  1236.             const caffe::MemoryDataParameter& memory_data_param = layer.memory_data_param();

  1237.             fprintf(pp, " 0=%d", memory_data_param.width());

  1238.             fprintf(pp, " 1=%d", memory_data_param.height());

  1239.             fprintf(pp, " 2=%d", memory_data_param.channels());

  1240.         }

  1241.         else if (layer.type() == "MVN")

  1242.         {

  1243.             const caffe::MVNParameter& mvn_param = layer.mvn_param();

  1244.             fprintf(pp, " 0=%d", mvn_param.normalize_variance());

  1245.             fprintf(pp, " 1=%d", mvn_param.across_channels());

  1246.             fprintf(pp, " 2=%e", mvn_param.eps());

  1247.         }

  1248.         else if (layer.type() == "Normalize")

  1249.         {

  1250.             const caffe::LayerParameter& binlayer = net.layer(netidx);

  1251.             const caffe::BlobProto& scale_blob = binlayer.blobs(0);

  1252.             const caffe::NormalizeParameter& norm_param = layer.norm_param();

  1253.             fprintf(pp, " 0=%d", norm_param.across_spatial());

  1254.             fprintf(pp, " 1=%d", norm_param.channel_shared());

  1255.             fprintf(pp, " 2=%e", norm_param.eps());

  1256.             fprintf(pp, " 3=%d", scale_blob.data_size());

  1257. 

  1258.             fwrite(scale_blob.data().data(), sizeof(float), scale_blob.data_size(), bp);

  1259.         }

  1260.         else if (layer.type() == "Permute")

  1261.         {

  1262.             const caffe::PermuteParameter& permute_param = layer.permute_param();

  1263.             int order_size = permute_param.order_size();

  1264.             int order_type = 0;

  1265.             if (order_size == 0)

  1266.                 order_type = 0;

  1267.             if (order_size == 1)

  1268.             {

  1269.                 int order0 = permute_param.order(0);

  1270.                 if (order0 == 0)

  1271.                     order_type = 0;

  1272.                 // permute with N not supported

  1273.             }

  1274.             if (order_size == 2)

  1275.             {

  1276.                 int order0 = permute_param.order(0);

  1277.                 int order1 = permute_param.order(1);

  1278.                 if (order0 == 0)

  1279.                 {

  1280.                     if (order1 == 1) // 0 1 2 3

  1281.                         order_type = 0;

  1282.                     else if (order1 == 2) // 0 2 1 3

  1283.                         order_type = 2;

  1284.                     else if (order1 == 3) // 0 3 1 2

  1285.                         order_type = 4;

  1286.                 }

  1287.                 // permute with N not supported

  1288.             }

  1289.             if (order_size == 3 || order_size == 4)

  1290.             {

  1291.                 int order0 = permute_param.order(0);

  1292.                 int order1 = permute_param.order(1);

  1293.                 int order2 = permute_param.order(2);

  1294.                 if (order0 == 0)

  1295.                 {

  1296.                     if (order1 == 1)

  1297.                     {

  1298.                         if (order2 == 2) // 0 1 2 3

  1299.                             order_type = 0;

  1300.                         if (order2 == 3) // 0 1 3 2

  1301.                             order_type = 1;

  1302.                     }

  1303.                     else if (order1 == 2)

  1304.                     {

  1305.                         if (order2 == 1) // 0 2 1 3

  1306.                             order_type = 2;

  1307.                         if (order2 == 3) // 0 2 3 1

  1308.                             order_type = 3;

  1309.                     }

  1310.                     else if (order1 == 3)

  1311.                     {

  1312.                         if (order2 == 1) // 0 3 1 2

  1313.                             order_type = 4;

  1314.                         if (order2 == 2) // 0 3 2 1

  1315.                             order_type = 5;

  1316.                     }

  1317.                 }

  1318.                 // permute with N not supported

  1319.             }

  1320.             fprintf(pp, " 0=%d", order_type);

  1321.         }

  1322.         else if (layer.type() == "Pooling")

  1323.         {

  1324.             const caffe::PoolingParameter& pooling_param = layer.pooling_param();

  1325.             fprintf(pp, " 0=%d", pooling_param.pool());

  1326.             if (pooling_param.has_kernel_w() && pooling_param.has_kernel_h())

  1327.             {

  1328.                 fprintf(pp, " 1=%d", pooling_param.kernel_w());

  1329.                 fprintf(pp, " 11=%d", pooling_param.kernel_h());

  1330.             }

  1331.             else

  1332.             {

  1333.                 fprintf(pp, " 1=%d", pooling_param.kernel_size());

  1334.             }

  1335.             if (pooling_param.has_stride_w() && pooling_param.has_stride_h())

  1336.             {

  1337.                 fprintf(pp, " 2=%d", pooling_param.stride_w());

  1338.                 fprintf(pp, " 12=%d", pooling_param.stride_h());

  1339.             }

  1340.             else

  1341.             {

  1342.                 fprintf(pp, " 2=%d", pooling_param.stride());

  1343.             }

  1344.             if (pooling_param.has_pad_w() && pooling_param.has_pad_h())

  1345.             {

  1346.                 fprintf(pp, " 3=%d", pooling_param.pad_w());

  1347.                 fprintf(pp, " 13=%d", pooling_param.pad_h());

  1348.             }

  1349.             else

  1350.             {

  1351.                 fprintf(pp, " 3=%d", pooling_param.pad());

  1352.             }

  1353.             fprintf(pp, " 4=%d", pooling_param.has_global_pooling() ? pooling_param.global_pooling() : 0);

  1354.         }

  1355.         else if (layer.type() == "Power")

  1356.         {

  1357.             const caffe::PowerParameter& power_param = layer.power_param();

  1358.             fprintf(pp, " 0=%e", power_param.power());

  1359.             fprintf(pp, " 1=%e", power_param.scale());

  1360.             fprintf(pp, " 2=%e", power_param.shift());

  1361.         }

  1362.         else if (layer.type() == "PReLU")

  1363.         {

  1364.             const caffe::LayerParameter& binlayer = net.layer(netidx);

  1365.             const caffe::BlobProto& slope_blob = binlayer.blobs(0);

  1366.             fprintf(pp, " 0=%d", slope_blob.data_size());

  1367.             fwrite(slope_blob.data().data(), sizeof(float), slope_blob.data_size(), bp);

  1368.         }

  1369.         else if (layer.type() == "PriorBox")

  1370.         {

  1371.             const caffe::PriorBoxParameter& prior_box_param = layer.prior_box_param();

  1372. 

  1373.             int num_aspect_ratio = prior_box_param.aspect_ratio_size();

  1374.             for (int j=0; j<prior_box_param.aspect_ratio_size(); j++)

  1375.             {

  1376.                 float ar = prior_box_param.aspect_ratio(j);

  1377.                 if (fabs(ar - 1.) < 1e-6) {

  1378.                     num_aspect_ratio--;

  1379.                 }

  1380.             }

  1381. 

  1382.             float variances[4] = {0.1f, 0.1f, 0.1f, 0.1f};

  1383.             if (prior_box_param.variance_size() == 4)

  1384.             {

  1385.                 variances[0] = prior_box_param.variance(0);

  1386.                 variances[1] = prior_box_param.variance(1);

  1387.                 variances[2] = prior_box_param.variance(2);

  1388.                 variances[3] = prior_box_param.variance(3);

  1389.             }

  1390.             else if (prior_box_param.variance_size() == 1)

  1391.             {

  1392.                 variances[0] = prior_box_param.variance(0);

  1393.                 variances[1] = prior_box_param.variance(0);

  1394.                 variances[2] = prior_box_param.variance(0);

  1395.                 variances[3] = prior_box_param.variance(0);

  1396.             }

  1397. 

  1398.             int flip = prior_box_param.has_flip() ? prior_box_param.flip() : 1;

  1399.             int clip = prior_box_param.has_clip() ? prior_box_param.clip() : 0;

  1400.             int image_width = -233;

  1401.             int image_height = -233;

  1402.             if (prior_box_param.has_img_size())

  1403.             {

  1404.                 image_width = prior_box_param.img_size();

  1405.                 image_height = prior_box_param.img_size();

  1406.             }

  1407.             else if (prior_box_param.has_img_w() && prior_box_param.has_img_h())

  1408.             {

  1409.                 image_width = prior_box_param.img_w();

  1410.                 image_height = prior_box_param.img_h();

  1411.             }

  1412. 

  1413.             float step_width = -233;

  1414.             float step_height = -233;

  1415.             if (prior_box_param.has_step())

  1416.             {

  1417.                 step_width = prior_box_param.step();

  1418.                 step_height = prior_box_param.step();

  1419.             }

  1420.             else if (prior_box_param.has_step_w() && prior_box_param.has_step_h())

  1421.             {

  1422.                 step_width = prior_box_param.step_w();

  1423.                 step_height = prior_box_param.step_h();

  1424.             }

  1425. 

  1426.             fprintf(pp, " -23300=%d", prior_box_param.min_size_size());

  1427.             for (int j=0; j<prior_box_param.min_size_size(); j++)

  1428.             {

  1429.                 fprintf(pp, ",%e", prior_box_param.min_size(j));

  1430.             }

  1431.             fprintf(pp, " -23301=%d", prior_box_param.max_size_size());

  1432.             for (int j=0; j<prior_box_param.max_size_size(); j++)

  1433.             {

  1434.                 fprintf(pp, ",%e", prior_box_param.max_size(j));

  1435.             }

  1436.             fprintf(pp, " -23302=%d", num_aspect_ratio);

  1437.             for (int j=0; j<prior_box_param.aspect_ratio_size(); j++)

  1438.             {

  1439.                 float ar = prior_box_param.aspect_ratio(j);

  1440.                 if (fabs(ar - 1.) < 1e-6) {

  1441.                     continue;

  1442.                 }

  1443.                 fprintf(pp, ",%e", ar);

  1444.             }

  1445.             fprintf(pp, " 3=%e", variances[0]);

  1446.             fprintf(pp, " 4=%e", variances[1]);

  1447.             fprintf(pp, " 5=%e", variances[2]);

  1448.             fprintf(pp, " 6=%e", variances[3]);

  1449.             fprintf(pp, " 7=%d", flip);

  1450.             fprintf(pp, " 8=%d", clip);

  1451.             fprintf(pp, " 9=%d", image_width);

  1452.             fprintf(pp, " 10=%d", image_height);

  1453.             fprintf(pp, " 11=%e", step_width);

  1454.             fprintf(pp, " 12=%e", step_height);

  1455.             fprintf(pp, " 13=%e", prior_box_param.offset());

  1456.         }

  1457.         else if (layer.type() == "PSROIPooling")

  1458.         {

  1459.             const caffe::PSROIPoolingParameter& psroi_pooling_param = layer.psroi_pooling_param();

  1460.             fprintf(pp, " 0=%d", psroi_pooling_param.group_size());

  1461.             fprintf(pp, " 1=%d", psroi_pooling_param.group_size());

  1462.             fprintf(pp, " 2=%e", psroi_pooling_param.spatial_scale());

  1463.             fprintf(pp, " 3=%d", psroi_pooling_param.output_dim());

  1464.         }

  1465.         else if (layer.type() == "Python")

  1466.         {

  1467.             const caffe::PythonParameter& python_param = layer.python_param();

  1468.             std::string python_layer_name = python_param.layer();

  1469.             if (python_layer_name == "ProposalLayer")

  1470.             {

  1471.                 int feat_stride = 16;

  1472.                 sscanf(python_param.param_str().c_str(), "'feat_stride': %d", &feat_stride);

  1473. 

  1474.                 int base_size = 16;

  1475. //                 float ratio;

  1476. //                 float scale;

  1477.                 int pre_nms_topN = 6000;

  1478.                 int after_nms_topN = 300;

  1479.                 float nms_thresh = 0.7;

  1480.                 int min_size = 16;

  1481.                 fprintf(pp, " 0=%d", feat_stride);

  1482.                 fprintf(pp, " 1=%d", base_size);

  1483.                 fprintf(pp, " 2=%d", pre_nms_topN);

  1484.                 fprintf(pp, " 3=%d", after_nms_topN);

  1485.                 fprintf(pp, " 4=%e", nms_thresh);

  1486.                 fprintf(pp, " 5=%d", min_size);

  1487.             }

  1488.         }

  1489.         else if (layer.type() == "ReLU")

  1490.         {

  1491.             const caffe::ReLUParameter& relu_param = layer.relu_param();

  1492.             if (relu_param.has_negative_slope())

  1493.             {

  1494.                 fprintf(pp, " 0=%e", relu_param.negative_slope());

  1495.             }

  1496.         }

  1497.         else if (layer.type() == "ReLU6")

  1498.         {

  1499.             float min = 0.f;

  1500.             float max = 6.f;

  1501.             fprintf(pp, " 0=%e", min);

  1502.             fprintf(pp, " 1=%e", max);

  1503.         }

  1504.         else if (layer.type() == "Reorg")

  1505.         {

  1506.             const caffe::ReorgParameter& reorg_param = layer.reorg_param();

  1507.             fprintf(pp, " 0=%d", reorg_param.stride());

  1508.         }

  1509.         else if (layer.type() == "Reshape")

  1510.         {

  1511.             const caffe::ReshapeParameter& reshape_param = layer.reshape_param();

  1512.             const caffe::BlobShape& bs = reshape_param.shape();

  1513.             if (bs.dim_size() == 1)

  1514.             {

  1515.                 fprintf(pp, " 0=%ld 1=-233 2=-233", bs.dim(0));

  1516.             }

  1517.             else if (bs.dim_size() == 2)

  1518.             {

  1519.                 fprintf(pp, " 0=%ld 1=-233 2=-233", bs.dim(1));

  1520.             }

  1521.             else if (bs.dim_size() == 3)

  1522.             {

  1523.                 fprintf(pp, " 0=%ld 1=%ld 2=-233", bs.dim(2), bs.dim(1));

  1524.             }

  1525.             else // bs.dim_size() == 4

  1526.             {

  1527.                 fprintf(pp, " 0=%ld 1=%ld 2=%ld", bs.dim(3), bs.dim(2), bs.dim(1));

  1528.             }

  1529.             fprintf(pp, " 3=0");// permute

  1530.         }

  1531.         else if (layer.type() == "ROIAlign")

  1532.         {

  1533.             const caffe::ROIAlignParameter& roi_align_param = layer.roi_align_param();

  1534.             fprintf(pp, " 0=%d", roi_align_param.pooled_w());

  1535.             fprintf(pp, " 1=%d", roi_align_param.pooled_h());

  1536.             fprintf(pp, " 2=%e", roi_align_param.spatial_scale());

  1537.         }

  1538.         else if (layer.type() == "ROIPooling")

  1539.         {

  1540.             const caffe::ROIPoolingParameter& roi_pooling_param = layer.roi_pooling_param();

  1541.             fprintf(pp, " 0=%d", roi_pooling_param.pooled_w());

  1542.             fprintf(pp, " 1=%d", roi_pooling_param.pooled_h());

  1543.             fprintf(pp, " 2=%e", roi_pooling_param.spatial_scale());

  1544.         }

  1545.         else if (layer.type() == "Scale")

  1546.         {

  1547.             const caffe::LayerParameter& binlayer = net.layer(netidx);

  1548. 

  1549.             const caffe::ScaleParameter& scale_param = layer.scale_param();

  1550.             bool scale_weight = scale_param.bias_term() ? (binlayer.blobs_size() == 2) : (binlayer.blobs_size() == 1);

  1551.             if (scale_weight)

  1552.             {

  1553.                 const caffe::BlobProto& weight_blob = binlayer.blobs(0);

  1554.                 fprintf(pp, " 0=%d", (int)weight_blob.data_size());

  1555.             }

  1556.             else

  1557.             {

  1558.                 fprintf(pp, " 0=-233");

  1559.             }

  1560. 

  1561.             fprintf(pp, " 1=%d", scale_param.bias_term());

  1562. 

  1563.             for (int j=0; j<binlayer.blobs_size(); j++)

  1564.             {

  1565.                 const caffe::BlobProto& blob = binlayer.blobs(j);

  1566.                 fwrite(blob.data().data(), sizeof(float), blob.data_size(), bp);

  1567.             }

  1568.         }

  1569.         else if (layer.type() == "ShuffleChannel")

  1570.         {

  1571.             const caffe::ShuffleChannelParameter& shuffle_channel_param = layer.shuffle_channel_param();

  1572.             fprintf(pp, " 0=%d", shuffle_channel_param.group());

  1573.         }

  1574.         else if (layer.type() == "Slice")

  1575.         {

  1576.             const caffe::SliceParameter& slice_param = layer.slice_param();

  1577.             if (slice_param.slice_point_size() == 0)

  1578.             {

  1579.                 int num_slice = layer.top_size();

  1580.                 fprintf(pp, " -23300=%d", num_slice);

  1581.                 for (int j=0; j<num_slice; j++)

  1582.                 {

  1583.                     fprintf(pp, ",-233");

  1584.                 }

  1585.             }

  1586.             else

  1587.             {

  1588.                 int num_slice = slice_param.slice_point_size() + 1;

  1589.                 fprintf(pp, " -23300=%d", num_slice);

  1590.                 int prev_offset = 0;

  1591.                 for (int j=0; j<slice_param.slice_point_size(); j++)

  1592.                 {

  1593.                     int offset = slice_param.slice_point(j);

  1594.                     fprintf(pp, ",%d", offset - prev_offset);

  1595.                     prev_offset = offset;

  1596.                 }

  1597.                 fprintf(pp, ",-233");

  1598.             }

  1599.             int axis = 0;

  1600.             if (slice_param.has_axis())

  1601.             {

  1602.                 axis = slice_param.axis() - 1;

  1603.             }

  1604.             else if (slice_param.has_slice_dim())

  1605.             {

  1606.                 axis = slice_param.slice_dim() - 1;

  1607.             }

  1608.             fprintf(pp, " 1=%d", axis);

  1609.         }

  1610.         else if (layer.type() == "Softmax")

  1611.         {

  1612.             const caffe::SoftmaxParameter& softmax_param = layer.softmax_param();

  1613.             int dim = softmax_param.axis() - 1;

  1614.             fprintf(pp, " 0=%d", dim);

  1615.             fprintf(pp, " 1=1");

  1616.         }

  1617.         else if (layer.type() == "Threshold")

  1618.         {

  1619.             const caffe::ThresholdParameter& threshold_param = layer.threshold_param();

  1620.             fprintf(pp, " 0=%e", threshold_param.threshold());

  1621.         }

  1622.         else if (layer.type() == "YoloDetectionOutput")

  1623.         {

  1624.             const caffe::YoloDetectionOutputParameter& yolo_detection_output_param = layer.yolo_detection_output_param();

  1625. 

  1626.             fprintf(pp, " 0=%d", yolo_detection_output_param.num_classes());

  1627.             fprintf(pp, " 1=%d", yolo_detection_output_param.num_box());

  1628.             fprintf(pp, " 2=%e", yolo_detection_output_param.confidence_threshold());

  1629.             fprintf(pp, " 3=%e", yolo_detection_output_param.nms_threshold());

  1630. 

  1631.             int num_bias = yolo_detection_output_param.biases_size();

  1632.             fprintf(pp, " -23304=%d", num_bias);

  1633.             for (int j=0; j<num_bias; j++)

  1634.             {

  1635.                 fprintf(pp, ",%e", yolo_detection_output_param.biases(j));

  1636.             }

  1637.         }

  1638. 		else if (layer.type() == "Yolov3DetectionOutput")

  1639. 		{

  1640. 			const caffe::Yolov3DetectionOutputParameter& yolov3_detection_output_param = layer.yolov3_detection_output_param();

  1641. 

  1642. 			fprintf(pp, " 0=%d", yolov3_detection_output_param.num_classes());

  1643. 			fprintf(pp, " 1=%d", yolov3_detection_output_param.num_box());

  1644. 			fprintf(pp, " 2=%e", yolov3_detection_output_param.confidence_threshold());

  1645. 			fprintf(pp, " 3=%e", yolov3_detection_output_param.nms_threshold());

  1646. 

  1647. 			int num_bias = yolov3_detection_output_param.biases_size();

  1648. 			fprintf(pp, " -23304=%d", num_bias);

  1649. 			for (int j = 0; j<num_bias; j++)

  1650. 			{

  1651. 				fprintf(pp, ",%e", yolov3_detection_output_param.biases(j));

  1652. 			}

  1653. 			int num_mask = yolov3_detection_output_param.mask_size();

  1654. 			fprintf(pp, " -23305=%d", num_mask);

  1655. 			for (int j = 0; j<num_mask; j++)

  1656. 			{

  1657. 				fprintf(pp, ",%e", (float)yolov3_detection_output_param.mask(j));

  1658. 			}

  1659. 			int num_anchors = yolov3_detection_output_param.anchors_scale_size();

  1660. 			fprintf(pp, " -23306=%d", num_anchors);

  1661. 			for (int j = 0; j<num_anchors; j++)

  1662. 			{

  1663. 				fprintf(pp, ",%e", (float)yolov3_detection_output_param.anchors_scale(j));

  1664. 			}

  1665. 			fprintf(pp, " 7=%d", yolov3_detection_output_param.mask_group_num());

  1666. 		}

  1667.         fprintf(pp, "\n");

  1668. 

  1669.         // add split layer if top reference larger than one

  1670.         if (layer.bottom_size() == 1 && layer.top_size() == 1 && layer.bottom(0) == layer.top(0))

  1671.         {

  1672.             std::string blob_name = blob_name_decorated[layer.top(0)];

  1673.             if (bottom_reference.find(blob_name) != bottom_reference.end())

  1674.             {

  1675.                 int refcount = bottom_reference[blob_name];

  1676.                 if (refcount > 1)

  1677.                 {

  1678.                     char splitname[256];

  1679.                     sprintf(splitname, "splitncnn_%d", internal_split);

  1680.                     fprintf(pp, "%-16s %-16s %d %d", "Split", splitname, 1, refcount);

  1681.                     fprintf(pp, " %s", blob_name.c_str());

  1682. 

  1683.                     for (int j=0; j<refcount; j++)

  1684.                     {

  1685.                         fprintf(pp, " %s_splitncnn_%d", blob_name.c_str(), j);

  1686.                     }

  1687.                     fprintf(pp, "\n");

  1688. 

  1689.                     internal_split++;

  1690.                 }

  1691.             }

  1692.         }

  1693.         else

  1694.         {

  1695.             for (int j=0; j<layer.top_size(); j++)

  1696.             {

  1697.                 std::string blob_name = layer.top(j);

  1698.                 if (bottom_reference.find(blob_name) != bottom_reference.end())

  1699.                 {

  1700.                     int refcount = bottom_reference[blob_name];

  1701.                     if (refcount > 1)

  1702.                     {

  1703.                         char splitname[256];

  1704.                         sprintf(splitname, "splitncnn_%d", internal_split);

  1705.                         fprintf(pp, "%-16s %-16s %d %d", "Split", splitname, 1, refcount);

  1706.                         fprintf(pp, " %s", blob_name.c_str());

  1707. 

  1708.                         for (int j=0; j<refcount; j++)

  1709.                         {

  1710.                             fprintf(pp, " %s_splitncnn_%d", blob_name.c_str(), j);

  1711.                         }

  1712.                         fprintf(pp, "\n");

  1713. 

  1714.                         internal_split++;

  1715.                     }

  1716.                 }

  1717.             }

  1718.         }

  1719. 

  1720.     }

  1721. 

  1722.     fclose(pp);

  1723.     fclose(bp);

  1724. 

  1725.     return 0;

  1726. }