weixin_38168547

OpenVINO 目标检测底层C++代码改写实现（待优化）

System: Centos7.4

I：OpenVINO 的安装

refer:https://docs.openvinotoolkit.org/latest/_docs_install_guides_installing_openvino_linux.html

II: 基于OpenVINO tensorflow 的model optimizer 参考（SSD部分）

https://www.cnblogs.com/fourmi/p/10888513.html

执行路径：/opt/intel/openvino/deployment_tools/model_optimizer

执行指令：

python3.6 mo_tf.py  --input_model=/home/gsj/object-detection/test_models/ssd_inception_v2_coco_2018_01_28/frozen_inference_graph.pb --tensorflow_use_custom_operations_config /opt/intel/openvino_2019.2.201/deployment_tools/model_optimizer/extensions/front/tf/ssd_v2_support.json --tensorflow_object_detection_api_pipeline_config /home/gsj/object-detection/test_models/ssd_inception_v2_coco_2018_01_28/pipeline.config --reverse_input_channels --batch 32

II:改写文件路径：

/opt/intel/openvino/inference_engine/samples/self_object_detection

包含文件

main.cpp   self_object_detection_engine_head.h 
CMakeLists.txt  README.md  self_object_detection.h

1. main.cpp

  1 // Copyright (C) 2018-2019 Intel Corporation
  2 // SPDX-License-Identifier: Apache-2.0
  3 //
  4 /*******************************************************************
  5 * Copyright:2019-2030, CC
  6 * File Name: Main.cpp
  7 * Description: main function includes ObjectDetection,
  8 *                          Initialize_Check, readInputimagesNames,
  9 *                          load_inference_engine, readIRfiles,
 10 *                          prepare_input_blobs, load_and_create_request,*                          
 11 *                          prepare_input , process
 12 *Author: Gao Shengjun
 13 *Date: 2019-07-19
 14 *******************************************************************/
 15 #include 
 16 #include 
 17 #include <string>
 18 #include 
 19 #include 
 20 #include 
 21 #include 
 22 
 23 #include 
 24 #include 
 25 #include 
 26 
 27 #include 
 28 #include 
 29 #include 
 30 
 31 #include 
 32 #include 
 33 
 34 #include "self_object_detection_engine_head.h"
 35 
 36 
 37 bool ParseAndCheckCommandLine(int argc, char *argv[]) {
 38     gflags::ParseCommandLineNonHelpFlags(&argc, &argv, true);
 39     if (FLAGS_h) {
 40         showUsage();
 41         showAvailableDevices();
 42         return false;
 43     }
 44 
 45     slog::info << "Parsing input parameters" << slog::endl;
 46 
 47     if (FLAGS_i.empty()) {
 48         throw std::logic_error("Parameter -i is not set");
 49     }
 50 
 51     if (FLAGS_m.empty()) {
 52         throw std::logic_error("Parameter -m is not set");
 53     }
 54 
 55     return true;
 56 }
 57 
 58 
 59 
 60 static std::mapstring, std::string> configure(const std::string& confFileName) {
 61     auto config = parseConfig(confFileName);
 62 
 63     return config;
 64 }
 65 
 66 
 67 
 68 void Initialize_Check_params(int argc,char* argv[]){
 69       slog::info << "InferenceEngine: " << GetInferenceEngineVersion()<<"\n";
 70       if(!ParseAndCheckCommandLine(argc,argv)){
 71           slog::info<<"Check successfully"<<"\n";
 72           return ;
 73       }
 74       return;
 75 }
 76 
 77 
 78 
 79 std::vectorstring> readInputimagesNames(){
 80         std::vectorstring>images;
 81         parseInputFilesArguments(images);
 82         if(images.empty()) throw std::logic_error("No suitable images were found");
 83         return images;
 84 }
 85 
 86 
 87 void load_inference_engine(Core &ie){
 88        slog::info <<"Loading Inference Engine"<<slog::endl;
 89        slog::info <<"Device info:" <<slog::endl;
 90        std::cout<<ie.GetVersions(FLAGS_d);
 91        if(FLAGS_p_msg){
 92        ie.SetLogCallback(error_listener);
 93        }
 94        if (FLAGS_d.find("CPU")!=std::string::npos){
 95           ie.AddExtension(std::make_shared(),"CPU");
 96        }
 97        if(!FLAGS_l.empty()){
 98           IExtensionPtr  extension_ptr = make_so_pointer(FLAGS_l);
 99           ie.AddExtension(extension_ptr,"CPU");
100           slog::info <<"CPU Extension loaded: "<slog::endl;
101        }
102        if(!FLAGS_c.empty()){
103           ie.SetConfig({{PluginConfigParams::KEY_CONFIG_FILE,FLAGS_c}},"GPU");
104           slog::info<<"GPU Extension loaded: "<slog::endl;
105        }
106 
107 }
108 
109 
110 struct NetworkReader_networkinfo readIRfiles(){
111       struct NetworkReader_networkinfo nettools;
112       std::string binFileName = fileNameNoExt(FLAGS_m) +".bin";
113       slog::info << "Loading network files:"
114             "\n\t" << FLAGS_m <<
115             "\n\t" << binFileName <<
116             slog::endl;
117       CNNNetReader  networkReader;
118       networkReader.ReadNetwork(FLAGS_m);
119       networkReader.ReadWeights(binFileName);
120       CNNNetwork network = networkReader.getNetwork();
121       nettools.networkReader = networkReader;
122       nettools.network = network;
123       return nettools;
124 }
125 
126 
127 
128 struct inputInfo_imageName prepare_input_blobs( CNNNetwork &network,CNNNetReader  &networkReader, InputsDataMap &inputsInfo){
129        slog::info << "Preparing input blobs" << slog::endl;
130        struct inputInfo_imageName res;
131        if (inputsInfo.size() != 1 && inputsInfo.size() != 2) throw std::logic_error("Sample supports topologies only with 1 or 2 inputs");
132        std::string imageInputName,imInfoInputName;
133        InputInfo::Ptr inputInfo  = nullptr;
134        SizeVector inputImageDims;
135        for(auto &item:inputsInfo){
136          if(item.second->getInputData()->getTensorDesc().getDims().size()==4){
137             imageInputName = item.first;
138             inputInfo = item.second;
139             slog::info<<"Batch size is "<slog::endl;
140             Precision inputPrecision =Precision::U8;
141             item.second->setPrecision(inputPrecision);
142             }else if(item.second->getInputData()->getTensorDesc().getDims().size()==2){
143              imInfoInputName = item.first;
144              Precision inputPrecision = Precision::FP32;
145              item.second->setPrecision(inputPrecision);
146              if((item.second->getTensorDesc().getDims()[1]!=3 && item.second->getTensorDesc().getDims()[1]!=6)){
147                   throw std::logic_error("Invalid input info. Should be 3 or 6 values length");
148                }
149             }
150        }
151        if(inputInfo == nullptr){
152            inputInfo = inputsInfo.begin()->second;
153    }
154    res.inputInfo = inputInfo;
155    res.InputName = imageInputName;
156    res.imInfoInputName=imInfoInputName;
157    return res;
158 }
159 
160 
161 
162 struct outputInfoStruct prepare_output_blobs(CNNNetwork &network){
163    struct outputInfoStruct res_output;
164    slog::info << "Preparing output blobs" << slog::endl;
165    OutputsDataMap outputsInfo(network.getOutputsInfo());
166    std::string outputName;
167    DataPtr outputInfo;
168    for(const auto& out : outputsInfo){
169        if(out.second->getCreatorLayer().lock()->type=="DetectionOutput"){
170              outputName = out.first;
171              outputInfo = out.second;
172        }
173    }
174    if(outputInfo == nullptr){
175        throw std::logic_error("Can't find a DetectionOutput layers in the topology");
176    }
177    const SizeVector outputDims = outputInfo->getTensorDesc().getDims();
178    res_output.maxProposalCount=outputDims[2];
179    res_output.objectSize=outputDims[3];
180    res_output.outputName=outputName;
181    if (res_output.objectSize != 7) {
182             throw std::logic_error("Output item should have 7 as a last dimension");
183         }
184 
185    if (outputDims.size() != 4) {
186             throw std::logic_error("Incorrect output dimensions for SSD model");
187         }
188 
189    outputInfo->setPrecision(Precision::FP32);
190    return res_output;
191 }
192 
193 
194 
195 struct exenet_requests load_and_create_request(CNNNetwork& network,Core &ie){
196    struct exenet_requests res;
197    slog::info << "Loading model to the device" << slog::endl;
198    res.executable_network = ie.LoadNetwork(network, FLAGS_d, configure(FLAGS_config));
199    slog::info << "Create infer request" << slog::endl;
200    res.infer_request = res.executable_network.CreateInferRequest();
201    return res;
202 }
203 
204 
205 
206 
207 struct res_outputStruct prepare_input(std::vectorstring>& images,CNNNetwork& network, struct inputInfo_imageName& res,InferRequest& infer_request,InputsDataMap& inputsInfo){
208      struct res_outputStruct output_res2;
209      std::vectorchar>> imageData,originalImagesData;
210      std::vectorimageWidths,imageHeights;
211      for(auto &i : images){
212          FormatReader::ReaderPtr reader(i.c_str());
213          if(reader.get()==nullptr){
214             slog::warn << "Image" + i + "cannot be read!" <<slog::endl;
215             continue;
216          }
217      std::shared_ptrchar>originalData(reader->getData());
218      std::shared_ptrchar>data(reader->getData(res.inputInfo->getTensorDesc().getDims()[3],res.inputInfo->getTensorDesc().getDims()[2]));
219      if(data.get()!=nullptr){
220           originalImagesData.push_back(originalData);
221           imageData.push_back(data);
222           imageWidths.push_back(reader->width());
223           imageHeights.push_back(reader->height());
224 
225         }
226 
227      }
228      if(imageData.empty())throw std::logic_error("Valid input images were not found!");
229      size_t batchSize = network.getBatchSize();
230      slog::info << "Batch Size is "<slog::endl;
231      if(batchSize!=imageData.size()){
232        slog::warn << "Number of images " + std::to_string(imageData.size()) + \
233          "dosen't match batch size "+std::to_string(batchSize)<<slog::endl;
234      batchSize = std::min(batchSize,imageData.size());
235      slog::warn <<"Number of images to be processed is "<slog::endl;
236     }
237     Blob::Ptr imageInput = infer_request.GetBlob(res.InputName);
238     size_t num_channels = imageInput->getTensorDesc().getDims()[1];
239     size_t image_size=imageInput->getTensorDesc().getDims()[3]*imageInput->getTensorDesc().getDims()[2];
240     unsigned char* data = static_castchar*>(imageInput->buffer());
241     for(size_t image_id = 0 ; image_id < std::min(imageData.size(),batchSize);++image_id){
242        for(size_t pid = 0; pid < image_size; pid++){
243           for(size_t ch = 0 ; ch  < num_channels;++ch){
244              data[image_id*image_size*num_channels + ch*image_size+pid] = imageData.at(image_id).get()[pid*num_channels + ch];
245           }
246        }
247     }
248     if(res.imInfoInputName!=""){
249         Blob::Ptr input2 = infer_request.GetBlob(res.imInfoInputName);
250         auto imInfoDim = inputsInfo.find(res.imInfoInputName)->second->getTensorDesc().getDims()[1];
251         float *p = input2->buffer().as::value_type*>();
252         for(size_t image_id=0;image_idimage_id){
253             p[image_id*imInfoDim+0] = static_cast<float>(inputsInfo[res.InputName]->getTensorDesc().getDims()[2]);
254             p[image_id*imInfoDim+1] = static_cast<float>(inputsInfo[res.InputName]->getTensorDesc().getDims()[3]);
255             for(size_t k = 2; k < imInfoDim; ++k){
256                p[image_id*imInfoDim+k]=1.0f;
257             }
258         }
259     }
260      output_res2.originalImagesData=originalImagesData;
261      output_res2.imageWidths=imageWidths;
262      output_res2.imageHeights=imageHeights;
263      output_res2.batchSize=batchSize;
264      slog::info<<"Start inference"<<slog::endl;
265      infer_request.Infer();
266      return output_res2;
267 }
268 
269 
270 
271 void process(InferRequest& infer_request,std::string& outputName,size_t& batchSize,const int& maxProposalCount,const int& objectSize,std::vector& imageWidths,std::vector& imageHeights,std::vectorchar>>& originalImagesData){
272     slog::info << "Processing output blobs" <<slog::endl;
273     const Blob::Ptr output_blob = infer_request.GetBlob(outputName);
274     const float* detection = static_cast::value_type*>(output_blob->buffer());
275     std::vectorint>>boxes(batchSize);
276     std::vectorint>>classes(batchSize);
277     std::cout<0]<<"--"<0]<<"   "<3]<<std::endl;
278     
279     for(int curProposal = 0; curProposal < maxProposalCount;curProposal++){
280        auto image_id = static_cast<int>(detection[curProposal * objectSize +0]);
281        if(image_id < 0){break;}
282        float confidence =detection[curProposal * objectSize + 2];
283        auto label = static_cast<int>(detection[curProposal * objectSize + 1]);
284        auto xmin  = static_cast<int>(detection[curProposal * objectSize + 3] * imageWidths[image_id]);
285        auto ymin  = static_cast<int>(detection[curProposal * objectSize + 4] * imageHeights[image_id]);
286        auto xmax  = static_cast<int>(detection[curProposal * objectSize + 5] * imageWidths[image_id]);
287        auto ymax  = static_cast<int>(detection[curProposal * objectSize + 6] * imageHeights[image_id]);
288        std::cout << "[" << curProposal << "," << label << "] element, prob = " << confidence <<
289                 "    (" << xmin << "," << ymin << ")-(" << xmax << "," << ymax << ")" << " batch id : " << image_id;
290        if(confidence > 0.3){
291            classes[image_id].push_back(label);
292            boxes[image_id].push_back(xmin);
293            boxes[image_id].push_back(ymin);
294            boxes[image_id].push_back(xmax - xmin);
295            boxes[image_id].push_back(ymax - ymin);
296            std::cout << " WILL BE PRINTED!";
297        }
298        std::cout<<std::endl;
299    }
300    for(size_t batch_id = 0 ; batch_id < batchSize; ++batch_id){
301         addRectangles(originalImagesData[batch_id].get(),imageHeights[batch_id],imageWidths[batch_id],boxes[batch_id],classes[batch_id],BBOX_THICKNESS);
302    const std::string image_path = "out_" + std::to_string(batch_id) + ".bmp";
303    if (writeOutputBmp(image_path, originalImagesData[batch_id].get(), imageHeights[batch_id], imageWidths[batch_id])) {
304           slog::info << "Image " + image_path + " created!" << slog::endl;
305             } else {
306                 throw std::logic_error(std::string("Can't create a file: ") + image_path);
307             }
308 
309 }
310 
311 }
312 
313 /****************************************MAIN***************************************************/
314 
315 int main(int argc, char *argv[]) {
316     try {
317         /** This sample covers certain topology and cannot be generalized for any object detection one **/
318         // --------------------------- 1. Parsing and validation of input args ---------------------------------
319         Initialize_Check_params(argc,argv);
320         // --------------------------- 2. Read input -----------------------------------------------------------
321         /** This vector stores paths to the processed images **/
322         std::vectorstring> images = readInputimagesNames();
323         // -----------------------------------------------------------------------------------------------------
324 
325         // --------------------------- 3. Load inference engine -------------------------------------
326         Core ie;
327         load_inference_engine(ie);
328 
329         // --------------------------- 4. Read IR Generated by ModelOptimizer (.xml and .bin files) ------------
330         CNNNetwork network = readIRfiles().network;
331         CNNNetReader networkReader = readIRfiles().networkReader;
332         // -----------------------------------------------------------------------------------------------------
333 
334         // --------------------------- 5. Prepare input blobs --------------------------------------------------
335           /** Taking information about all topology inputs **/
336           InputsDataMap inputsInfo(network.getInputsInfo());
337 
338           struct inputInfo_imageName res =  prepare_input_blobs(network,networkReader, inputsInfo);
339           InputInfo::Ptr inputInfo = res.inputInfo;
340           std::string imageInputName = res.InputName;
341           std::string imInfoInputName = res.imInfoInputName;
342 
343         // -----------------------------------------------------------------------------------------------------
344 
345         // --------------------------- 6. Prepare output blobs -------------------------------------------------
346         struct outputInfoStruct res_output = prepare_output_blobs(network);
347         const int maxProposalCount = res_output.maxProposalCount;
348         const int objectSize =res_output.objectSize;
349         std::string outputName = res_output.outputName;
350 
351         // -----------------------------------------------------------------------------------------------------
352 
353         // --------------------------- 7. Loading model to the device ------------------------------------------
354         struct exenet_requests exe_req =  load_and_create_request(network,ie);
355         ExecutableNetwork executable_network = exe_req.executable_network;
356         InferRequest infer_request = exe_req.infer_request;
357         // -----------------------------------------------------------------------------------------------------
358         // --------------------------- 8. Prepare input --------------------------------------------------------
359          struct res_outputStruct out_struct =prepare_input(images,network,res,infer_request,inputsInfo);
360         std::vectorchar>>originalImagesData=out_struct.originalImagesData;
361         std::vectorimageWidths=out_struct.imageWidths;
362         std::vectorimageHeights=out_struct.imageHeights;
363         size_t batchSize = out_struct.batchSize;
364         // -----------------------------------------------------------------------------------------------------
365         // --------------------------- 9. Process output -------------------------------------------------------
366          process(infer_request, outputName, batchSize, maxProposalCount, objectSize, imageWidths,imageHeights,originalImagesData);
367         // -----------------------------------------------------------------------------------------------------
368     }
369     catch (const std::exception& error) {
370         slog::err << error.what() << slog::endl;
371         return 1;
372     }
373     catch (...) {
374         slog::err << "Unknown/internal exception happened." << slog::endl;
375         return 1;
376     }
377 
378     slog::info << "Execution successful" << slog::endl;
379     slog::info << slog::endl << "This sample is an API example, for any performance measurements "
380                                 "please use the dedicated benchmark_app tool" << slog::endl;
381     return 0;
382 }

2. self_object_detection_engine_head.h

  1 /*******************************************************************
  2 * Copyright:2019-2030, CC
  3 * File Name: self_object_detection_engine_head.h
  4 * Description: main function includes ObjectDetection,
  5 *                          Initialize_Check, readInputimagesNames,
  6 *                          load_inference_engine, readIRfiles,
  7 *                          prepare_input_blobs, load_and_create_request,*                          
  8 *                          prepare_input , process
  9 *Author: Gao Shengjun
 10 *Date: 2019-07-19
 11 *******************************************************************/
 12 #ifndef SELF_OBJECT_DETECTION_ENGINE_HEAD_H
 13 #define SELF_OBJECT_DETECTION_ENGINE_HEAD_H
 14 
 15 #include "self_object_detection.h"
 16 #include 
 17 #include 
 18 #include <string>
 19 #include 
 20 #include 
 21 #include 
 22 #include 
 23 
 24 #include 
 25 #include 
 26 #include 
 27 
 28 #include 
 29 #include 
 30 #include 
 31 
 32 #include 
 33 #include 
 34 using namespace InferenceEngine;
 35 ConsoleErrorListener error_listener;
 36 
 37 typedef struct NetworkReader_networkinfo{
 38         CNNNetReader networkReader;
 39         CNNNetwork network;
 40       }NetworkReader_networkinfo;
 41 
 42 typedef struct inputInfo_imageName{
 43         InputInfo::Ptr inputInfo;
 44         std::string InputName;
 45         std::string imInfoInputName;
 46 
 47 }inputInfo_imageName;
 48 
 49 typedef struct outputInfoStruct{
 50       int maxProposalCount ;
 51       int objectSize; 
 52       std::string outputName; 
 53 }outputInfoStruct;
 54 
 55 typedef struct exenet_requests{
 56       ExecutableNetwork executable_network;
 57       InferRequest infer_request;
 58 
 59 }exenet_requests;
 60 
 61 typedef struct res_outputStruct {
 62    std::vectorchar>>originalImagesData;
 63    std::vectorimageWidths;
 64    std::vectorimageHeights;
 65    size_t batchSize;
 66  
 67 }res_outputStruct;
 68 
 69 #ifdef __cplusplus
 70 extern "C"
 71 {
 72 #endif
 73 
 74 /**
 75  * @brief get the version of the InferenceEngine and parse the input params, print the help information about the instruct if needed, check the required input params eg. the file of model and the input images both are required.
 76  
 77 
 78  * @ param[in] argc: the number of the input params,
 79  *            argv: the vector to store the input params
 80  * @ param[out] None         
 81  */
 82 void Initialize_Check_params(int argc,char* argv[]);
 83 
 84 
 85 /**
 86  *@brief get the input images filenames and store the in a vector
 87 
 88  *@ param[in] None
 89  *@ param[out] return the filenames of the images
 90  *@ Parse the info of the inputimages by call " parseInputFilesArguments "  build in OpenVINO
 91  */
 92 std::vectorstring> readInputimagesNames();
 93 
 94 
 95 /**
 96  * @brief load the extension_plugin according the specific devices,eg CPU,GPU
 97  * @ param[in] Core &ie
 98  * @ param[out] None
 99  */
100 void load_inference_engine(Core& ie);
101 
102 
103 
104 /**
105  * @brief read the proto and weights files which produced by openvino model optimizer tools of the network.
106  * @ param[in] flags_m: the model files *.bin,*.xml
107  * @ param[out] Struct contains NetworkReader and the structure info of the model
108  */
109 struct NetworkReader_networkinfo readIRfiles();
110 
111 
112 
113 /*
114  * @brief get the detail  InputsInfo for the blob format according the InputsInfo, and set the precision of the inputs according to the input format ,eg,[NCHW]:U8 [HW]:FP32
115  * @ param[in] network,CNNNetReader,inputsInfo
116  * @ param[out] strcut contains the inputInfo,ImageInputName,the info name of the input Image 
117  */
118 struct inputInfo_imageName  prepare_input_blobs( CNNNetwork &network,CNNNetReader  &networkReader,  InputsDataMap &inputsInfo);
119 
120 
121 
122 /*
123  * @brief get the info of the ouputs from the network by calling the OPENVINO's "getOutputsInof()" 
124  * @ param[in] network
125  * @ param[out] strcut contains the model's maxProposals,objectSize,outputName
126  */
127 struct outputInfoStruct prepare_output_blobs(CNNNetwork &network);
128 
129 
130 /*
131  * @brief Load the network to the device and create the infer request
132  * @ param[in] network, Core
133  * @ param[out] struct contains the excuteable network and the inferRequest
134  */
135 struct exenet_requests load_and_create_request(CNNNetwork& network,Core &ie);
136 
137 
138 /*
139  * @brief read the input images and create the input blob and start the infer request
140  * @ param[in] images:the path of the images , network: the info of the model, inputInfo_imageName,inputInfo_imageName, infer_request, inputsInfo
141  * @ param[out] return the data of the input images and its height ,width,batchSize. 
142  */
143 struct res_outputStruct prepare_input(std::vectorstring>& images,CNNNetwork& network, struct inputInfo_imageName& res,InferRequest& infer_request,InputsDataMap& inputsInfo);
144 
145 
146 /*
147  * @brief get the output according the output_blob,and get the (label,xmin,ymin,xmax,ymax) about the detection boxes ,  I set the thread value :0.3 it gets the better result.
148  * @param [in] infer_request, outputName,batchSize,maxProposalCount,objectSize,imageWidths,imageHeights,originalImagesData
149  * @param [out] None
150  */
151 void process(InferRequest& infer_request,std::string& outputName,size_t& batchSize,const int& maxProposalCount,const int& objectSize,std::vector& imageWidths,std::vector& imageHeights,std::vectorchar>>& originalImagesData);
152 #ifdef __cplusplus
153 }
154 #endif
155 #endif

3.self_object_detection.h

 1 // Copyright (C) 2018-2019 Intel Corporation
 2 // SPDX-License-Identifier: Apache-2.0
 3 //
 4 
 5 #pragma once
 6 
 7 #include <string>
 8 #include 
 9 #include 
10 #include 
11 
12 /* thickness of a line (in pixels) to be used for bounding boxes */
13 #define BBOX_THICKNESS 2
14 
15 /// @brief message for help argument
16 static const char help_message[] = "Print a usage message.";
17 
18 /// @brief message for images argument
19 static const char image_message[] = "Required. Path to an .bmp image.";
20 
21 /// @brief message for model argument
22 static const char model_message[] = "Required. Path to an .xml file with a trained model.";
23 
24 /// @brief message for plugin argument
25 static const char plugin_message[] = "Plugin name. For example MKLDNNPlugin. If this parameter is pointed, " \
26 "the sample will look for this plugin only";
27 
28 /// @brief message for assigning cnn calculation to device
29 static const char target_device_message[] = "Optional. Specify the target device to infer on (the list of available devices is shown below). " \
30 "Default value is CPU. Use \"-d HETERO:\" format to specify HETERO plugin. " \
31 "Sample will look for a suitable plugin for device specified";
32 
33 /// @brief message for clDNN custom kernels desc
34 static const char custom_cldnn_message[] = "Required for GPU custom kernels. "\
35 "Absolute path to the .xml file with the kernels descriptions.";
36 
37 /// @brief message for user library argument
38 static const char custom_cpu_library_message[] = "Required for CPU custom layers. " \
39 "Absolute path to a shared library with the kernels implementations.";
40 
41 /// @brief message for plugin messages
42 static const char plugin_err_message[] = "Optional. Enables messages from a plugin";
43 
44 /// @brief message for config argument
45 static constexpr char config_message[] = "Path to the configuration file. Default value: \"config\".";
46 
47 /// \brief Define flag for showing help message 

48 DEFINE_bool(h, false, help_message);
49 
50 /// \brief Define parameter for set image file 

51 /// It is a required parameter
52 DEFINE_string(i, "", image_message);
53 
54 /// \brief Define parameter for set model file 

55 /// It is a required parameter
56 DEFINE_string(m, "", model_message);
57 
58 /// \brief device the target device to infer on 

59 DEFINE_string(d, "CPU", target_device_message);
60 
61 /// @brief Define parameter for clDNN custom kernels path 

62 /// Default is ./lib
63 DEFINE_string(c, "", custom_cldnn_message);
64 
65 /// @brief Absolute path to CPU library with user layers 

66 /// It is a optional parameter
67 DEFINE_string(l, "", custom_cpu_library_message);
68 
69 /// @brief Enable plugin messages
70 DEFINE_bool(p_msg, false, plugin_err_message);
71 
72 /// @brief Define path to plugin config
73 DEFINE_string(config, "", config_message);
74 
75 /**
76 * \brief This function show a help message
77 */
78 static void showUsage() {
79     std::cout << std::endl;
80     std::cout << "object_detection_sample_ssd [OPTION]" << std::endl;
81     std::cout << "Options:" << std::endl;
82     std::cout << std::endl;
83     std::cout << "    -h                      " << help_message << std::endl;
84     std::cout << "    -i \"\"             " << image_message << std::endl;
85     std::cout << "    -m \"\"             " << model_message << std::endl;
86     std::cout << "      -l \"\"  " << custom_cpu_library_message << std::endl;
87     std::cout << "          Or" << std::endl;
88     std::cout << "      -c \"\"  " << custom_cldnn_message << std::endl;
89     std::cout << "    -d \"\"           " << target_device_message << std::endl;
90     std::cout << "    -p_msg                  " << plugin_err_message << std::endl;
91 }

IV: 编译

执行路径：

/opt/intel/openvino/inference_engine/samples

sh ./build_samples.sh

V: Test

执行路径：

/root/inference_engine_samples_build/intel64/Release

执行命令：

./self_object_detection -m /opt/intel/openvino_2019.2.201/deployment_tools/model_optimizer/./frozen_inference_graph.xml -d CPU -i /home/gsj/dataset/coco_val/val8

VI: result

[ INFO ] InferenceEngine:
        API version ............ 2.0
        Build .................. custom_releases/2019/R2_3044732e25bc7dfbd11a54be72e34d512862b2b3
        Description ....... API
Parsing input parameters
[ INFO ] Files were added: 8
[ INFO ]     /home/gsj/dataset/coco_val/val8/000000000785.jpg
[ INFO ]     /home/gsj/dataset/coco_val/val8/000000000139.jpg
[ INFO ]     /home/gsj/dataset/coco_val/val8/000000000724.jpg
[ INFO ]     /home/gsj/dataset/coco_val/val8/000000000285.jpg
[ INFO ]     /home/gsj/dataset/coco_val/val8/000000000802.jpg
[ INFO ]     /home/gsj/dataset/coco_val/val8/000000000632.jpg
[ INFO ]     /home/gsj/dataset/coco_val/val8/000000000872.jpg
[ INFO ]     /home/gsj/dataset/coco_val/val8/000000000776.jpg
[ INFO ] Loading Inference Engine
[ INFO ] Device info:
        CPU
        MKLDNNPlugin version ......... 2.0
        Build ........... 26451
[ INFO ] Loading network files:
        /opt/intel/openvino_2019.2.201/deployment_tools/model_optimizer/./frozen_inference_graph.xml
        /opt/intel/openvino_2019.2.201/deployment_tools/model_optimizer/./frozen_inference_graph.bin
[ INFO ] Loading network files:
        /opt/intel/openvino_2019.2.201/deployment_tools/model_optimizer/./frozen_inference_graph.xml
        /opt/intel/openvino_2019.2.201/deployment_tools/model_optimizer/./frozen_inference_graph.bin
[ INFO ] Preparing input blobs
[ INFO ] Batch size is 32
[ INFO ] Preparing output blobs
[ INFO ] Loading model to the device
[ INFO ] Create infer request
[ WARNING ] Image is resized from (640, 425) to (300, 300)
[ WARNING ] Image is resized from (640, 426) to (300, 300)
[ WARNING ] Image is resized from (375, 500) to (300, 300)
[ WARNING ] Image is resized from (586, 640) to (300, 300)
[ WARNING ] Image is resized from (424, 640) to (300, 300)
[ WARNING ] Image is resized from (640, 483) to (300, 300)
[ WARNING ] Image is resized from (621, 640) to (300, 300)
[ WARNING ] Image is resized from (428, 640) to (300, 300)
[ INFO ] Batch Size is 32
[ WARNING ] Number of images 8dosen't match batch size 32
[ WARNING ] Number of images to be processed is 8
[ INFO ] Start inference
[ INFO ] Processing output blobs
640--425   0.452099
[0,1] element, prob = 0.851202    (289,42)-(485,385) batch id : 0 WILL BE PRINTED!
[1,35] element, prob = 0.495117    (205,360)-(600,397) batch id : 0 WILL BE PRINTED!
[2,1] element, prob = 0.376695    (380,177)-(398,208) batch id : 1 WILL BE PRINTED!
[3,1] element, prob = 0.337178    (398,159)-(459,292) batch id : 1 WILL BE PRINTED!
[4,62] element, prob = 0.668834    (365,214)-(428,310) batch id : 1 WILL BE PRINTED!
[5,62] element, prob = 0.558071    (294,220)-(365,321) batch id : 1 WILL BE PRINTED!
[6,62] element, prob = 0.432652    (388,205)-(440,307) batch id : 1 WILL BE PRINTED!
[7,62] element, prob = 0.313619    (218,228)-(300,319) batch id : 1 WILL BE PRINTED!
[8,64] element, prob = 0.488229    (217,178)-(269,217) batch id : 1 WILL BE PRINTED!
[9,72] element, prob = 0.885867    (9,165)-(149,263) batch id : 1 WILL BE PRINTED!
[10,86] element, prob = 0.305516    (239,196)-(255,217) batch id : 1 WILL BE PRINTED!
[11,3] element, prob = 0.332538    (117,284)-(146,309) batch id : 2 WILL BE PRINTED!
[12,13] element, prob = 0.992781    (122,73)-(254,223) batch id : 2 WILL BE PRINTED!
[13,23] element, prob = 0.988277    (4,75)-(580,632) batch id : 3 WILL BE PRINTED!
[14,79] element, prob = 0.981469    (29,292)-(161,516) batch id : 4 WILL BE PRINTED!
[15,82] element, prob = 0.94848    (244,189)-(412,525) batch id : 4 WILL BE PRINTED!
[16,62] element, prob = 0.428106    (255,233)-(348,315) batch id : 5 WILL BE PRINTED!
[17,64] element, prob = 0.978832    (336,217)-(429,350) batch id : 5 WILL BE PRINTED!
[18,64] element, prob = 0.333557    (192,148)-(235,234) batch id : 5 WILL BE PRINTED!
[19,65] element, prob = 0.985633    (-5,270)-(404,477) batch id : 5 WILL BE PRINTED!
[20,84] element, prob = 0.882272    (461,246)-(472,288) batch id : 5 WILL BE PRINTED!
[21,84] element, prob = 0.874527    (494,192)-(503,223) batch id : 5 WILL BE PRINTED!
[22,84] element, prob = 0.850498    (482,247)-(500,285) batch id : 5 WILL BE PRINTED!
[23,84] element, prob = 0.844409    (461,296)-(469,335) batch id : 5 WILL BE PRINTED!
[24,84] element, prob = 0.787552    (414,24)-(566,364) batch id : 5 WILL BE PRINTED!
[25,84] element, prob = 0.748578    (524,189)-(533,224) batch id : 5 WILL BE PRINTED!
[26,84] element, prob = 0.735457    (524,98)-(535,133) batch id : 5 WILL BE PRINTED!
[27,84] element, prob = 0.712015    (528,49)-(535,84) batch id : 5 WILL BE PRINTED!
[28,84] element, prob = 0.689215    (496,51)-(504,82) batch id : 5 WILL BE PRINTED!
[29,84] element, prob = 0.620327    (456,192)-(467,224) batch id : 5 WILL BE PRINTED!
[30,84] element, prob = 0.614535    (481,154)-(514,173) batch id : 5 WILL BE PRINTED!
[31,84] element, prob = 0.609089    (506,151)-(537,172) batch id : 5 WILL BE PRINTED!
[32,84] element, prob = 0.604894    (456,148)-(467,181) batch id : 5 WILL BE PRINTED!
[33,84] element, prob = 0.554959    (485,102)-(505,125) batch id : 5 WILL BE PRINTED!
[34,84] element, prob = 0.549844    (508,244)-(532,282) batch id : 5 WILL BE PRINTED!
[35,84] element, prob = 0.404613    (437,143)-(443,180) batch id : 5 WILL BE PRINTED!
[36,84] element, prob = 0.366167    (435,245)-(446,287) batch id : 5 WILL BE PRINTED!
[37,84] element, prob = 0.320608    (438,191)-(446,226) batch id : 5 WILL BE PRINTED!
[38,1] element, prob = 0.996094    (197,115)-(418,568) batch id : 6 WILL BE PRINTED!
[39,1] element, prob = 0.9818    (266,99)-(437,542) batch id : 6 WILL BE PRINTED!
[40,1] element, prob = 0.517957    (152,117)-(363,610) batch id : 6 WILL BE PRINTED!
[41,40] element, prob = 0.302339    (154,478)-(192,542) batch id : 6 WILL BE PRINTED!
[42,88] element, prob = 0.98227    (8,24)-(372,533) batch id : 7 WILL BE PRINTED!
[43,88] element, prob = 0.924668    (0,268)-(323,640) batch id : 7 WILL BE PRINTED!
[ INFO ] Image out_0.bmp created!
[ INFO ] Image out_1.bmp created!
[ INFO ] Image out_2.bmp created!
[ INFO ] Image out_3.bmp created!
[ INFO ] Image out_4.bmp created!
[ INFO ] Image out_5.bmp created!
[ INFO ] Image out_6.bmp created!
[ INFO ] Image out_7.bmp created!
[ INFO ] Execution successful

[ INFO ] This sample is an API example, for any performance measurements please use the dedicated benchmark_app tool

转载于:https://www.cnblogs.com/fourmi/p/11217470.html

你可能感兴趣的:(c/c++,人工智能,json)

机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
android系统selinux中添加新属性property 辉色投像
1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
【iOS】MVC设计模式 Magnetic_h ios mvc 设计模式 objective-c 学习 ui
MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
OC语言多界面传值五大方式 Magnetic_h ios ui 学习 objective-c 开发语言
前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
UI学习——cell的复用和自定义cell Magnetic_h ui 学习
目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
element实现动态路由+面包屑软件技术NINI vue案例 vue.js 前端
el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
C语言宏函数南林yan C语言 c语言
一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
C语言如何定义宏函数？小九格物 c语言
在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
理解Gunicorn：Python WSGI服务器的基石范范0825 ipython linux 运维
理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断尐尐呅
结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
c++ 的iostream 和 c++的stdio的区别和联系黄卷青灯77 c++算法开发语言 iostream stdio
在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
swagger访问路径 igotyback swagger
Swagger2.x版本访问地址：http://{ip}:{port}/{context-path}/swagger-ui.html{ip}是你的服务器IP地址。{port}是你的应用服务端口，通常为8080。{context-path}是你的应用上下文路径，如果应用部署在根路径下，则为空。Swagger3.x版本对于Swagger3.x版本（也称为OpenAPI3）访问地址：http://{ip
mysql禁用远程登录 igotyback mysql
去mysql库中的user表里，将host都改成localhost之后刷新权限FLUSHPRIVILEGES;
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码说私域人工智能小程序
摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
html 中如何使用 uniapp 的部分方法某公司摸鱼前端 html uni-app 前端
示例代码：Documentconsole.log(window);效果展示：好了，现在就可以uni.使用相关的方法了
ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值）研学随笔 arcgis 经验分享
我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
高级编程--XML+socket练习题 masa010 java 开发语言
1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
水平垂直居中的几种方法（总结） LJ小番茄 CSS_玄学语言 html javascript 前端 css css3
1.使用flexbox的justify-content和align-items.parent{display:flex;justify-content:center;/*水平居中*/align-items:center;/*垂直居中*/height:100vh;/*需要指定高度*/}2.使用grid的place-items:center.parent{display:grid;place-item
回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录 leetcode 算法职场和发展
重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
每日一题——第八十九题互联网打工人no1 C语言程序设计每日一练 c语言
题目：在字符串中找到提取数字，并统计一共找到多少整数，a123xxyu23&8889，那么找到的整数为123，23，8889//思想：#include#include#includeintmain(){charstr[]="a123xxyu23&8889";intcount=0;intnum=0;//用于临时存放当前正在构建的整数。boolinNum=false;//用于标记当前是否正在读取一个整
每日一题——第九十题互联网打工人no1 C语言程序设计每日一练 c语言
题目：判断子串是否与主串匹配#include#include#include//////判断子串是否在主串中匹配//////主串///子串///boolisSubstring(constchar*str,constchar*substr){intlenstr=strlen(str);//计算主串的长度intlenSub=strlen(substr);//计算子串的长度//遍历主字符串，对每个可能得
每日一题——第八十一题互联网打工人no1 C语言程序设计每日一练 c语言
打印如下图案:#includeintmain(){inti,j;charch='A';for(i=1;i<5;i++,ch++){for(j=0;j<5-i;j++){printf("");//控制空格输出}for(j=1;j<2*i;j++)//条件j<2*i{printf("%c",ch);//控制字符输出}printf("\n");}return0;}
每日一题——第八十四题互联网打工人no1 C语言程序设计每日一练 c语言
题目：编写函数1、输入10个职工的姓名和职工号2、按照职工由大到小顺序排列，姓名顺序也随之调整3、要求输入一个职工号，用折半查找法找出该职工的姓名#define_CRT_SECURE_NO_WARNINGS#include#include#defineMAX_EMPLOYEES10typedefstruct{intid;charname[50];}Empolyee;voidinputEmploye
每日一题——第八十二题互联网打工人no1 C语言程序设计每日一练 c语言
题目：将一个控制台输入的字符串中的所有元音字母复制到另一字符串中#include#include#include#include#defineMAX_INPUT1024boolisVowel(charp);intmain(){charinput[MAX_INPUT];charoutput[MAX_INPUT];printf("请输入一串字符串：\n");fgets(input,sizeof(inp
每日一题——第八十三题互联网打工人no1 C语言程序设计每日一练 c语言
题目：将输入的整形数字输出,输出1990，输出"1990"#include#defineMAX_INPUT1024intmain(){intarrr_num[MAX_INPUT];intnum,i=0;printf("请输入一个数字：");scanf_s("%d",&num);while(num!=0){arrr_num[i++]=num%10;num/=10;}printf("\"");for(
C#中使用split分割字符串互联网打工人no1 c#
1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
WPF中的ComboBox控件几种数据绑定的方式互联网打工人no1 wpf c#
一、用字典给ItemsSource赋值（此绑定用的地方很多，建议熟练掌握）在XMAL中：在CS文件中privatevoidBindData(){DictionarydicItem=newDictionary();dicItem.add(1,"北京");dicItem.add(2,"上海");dicItem.add(3,"广州");cmb_list.ItemsSource=dicItem;cmb_l
关于旗正规则引擎规则中的上传和下载问题何必如此文件下载压缩 jsp 文件上传
文件的上传下载都是数据流的输入输出，大致流程都是一样的。一、文件打包下载 1.文件写入压缩包 string mainPath="D:\upload\"; 下载路径 string tmpfileName=jar.zip; &n
【Spark九十九】Spark Streaming的batch interval时间内的数据流转源码分析 bit1129 Stream
以如下代码为例（SocketInputDStream）： Spark Streaming从Socket读取数据的代码是在SocketReceiver的receive方法中，撇开异常情况不谈(Receiver有重连机制，restart方法，默认情况下在Receiver挂了之后，间隔两秒钟重新建立Socket连接)，读取到的数据通过调用store(textRead)方法进行存储。数据
spark master web ui 端口8080被占用解决方法 daizj 8080 端口占用 spark master web ui
spark master web ui 默认端口为8080，当系统有其它程序也在使用该接口时，启动master时也不会报错，spark自己会改用其它端口，自动端口号加1，但为了可以控制到指定的端口，我们可以自行设置，修改方法： 1、cd SPARK_HOME/sbin 2、vi start-master.sh 3、定位到下面部分
oracle_执行计划_谓词信息和数据获取周凡杨 oracle 执行计划
oracle_执行计划_谓词信息和数据获取(上) 一：简要说明在查看执行计划的信息中，经常会看到两个谓词filter和access，它们的区别是什么，理解了这两个词对我们解读Oracle的执行计划信息会有所帮助。简单说，执行计划如果显示是access，就表示这个谓词条件的值将会影响数据的访问路径（表还是索引），而filter表示谓词条件的值并不会影响数据访问路径，只起到
spring中datasource配置 g21121 dataSource
datasource配置有很多种，我介绍的一种是采用c3p0的，它的百科地址是： http://baike.baidu.com/view/920062.htm  <bean name="propertiesConfig" class="org.springframework.b
web报表工具FineReport使用中遇到的常见报错及解决办法（三）老A不折腾 finereport FAQ 报表软件
这里写点抛砖引玉，希望大家能把自己整理的问题及解决方法晾出来，Mark一下，利人利己。出现问题先搜一下文档上有没有，再看看度娘有没有，再看看论坛有没有。有报错要看日志。下面简单罗列下常见的问题，大多文档上都有提到的。 1、repeated column width is largerthan paper width：这个看这段话应该是很好理解的。比如做的模板页面宽度只能放
mysql 用户管理墙头上一根草 linux mysql user
1.新建用户 //登录MYSQL@>mysql -u root -p@>密码//创建用户mysql> insert into mysql.user(Host,User,Password) values(‘localhost’,'jeecn’,password(‘jeecn’));//刷新系统权限表mysql>flush privileges;这样就创建了一个名为：
关于使用Spring导致c3p0数据库死锁问题 aijuans spring Spring 入门 Spring 实例 Spring3 Spring 教程
这个问题我实在是为整个 springsource 的员工蒙羞如果大家使用 spring 控制事务，使用 Open Session In View 模式， com.mchange.v2.resourcepool.TimeoutException: A client timed out while waiting to acquire a resource from com.mchange.
百度词库联想 annan211 百度
<!DOCTYPE html> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>RunJS</title&g
int数据与byte之间的相互转换实现代码百合不是茶位移 int转byte byte转int 基本数据类型的实现
在BMP文件和文件压缩时需要用到的int与byte转换,现将理解的贴出来; 主要是要理解;位移等概念 http://baihe747.iteye.com/blog/2078029 int转byte; byte转int; /** * 字节转成int,int转成字节 * @author Administrator *
简单模拟实现数据库连接池 bijian1013 java thread java多线程简单模拟实现数据库连接池
简单模拟实现数据库连接池实例1： package com.bijian.thread; public class DB { //private static final int MAX_COUNT = 10; private static final DB instance = new DB(); private int count = 0; private i
一种基于Weblogic容器的鉴权设计 bijian1013 java weblogic
服务器对请求的鉴权可以在请求头中加Authorization之类的key，将用户名、密码保存到此key对应的value中，当然对于用户名、密码这种高机密的信息，应该对其进行加砂加密等，最简单的方法如下： String vuser_id = "weblogic"; String vuse
【RPC框架Hessian二】Hessian 对象序列化和反序列化 bit1129 hessian
任何一个对象从一个JVM传输到另一个JVM，都要经过序列化为二进制数据(或者字符串等其他格式，比如JSON)，然后在反序列化为Java对象，这最后都是通过二进制的数据在不同的JVM之间传输(一般是通过Socket和二进制的数据传输)，本文定义一个比较符合工作中。 1. 定义三个POJO Person类 package com.tom.hes
【Hadoop十四】Hadoop提供的脚本的功能 bit1129 hadoop
1. hadoop-daemon.sh 1.1 启动HDFS ./hadoop-daemon.sh start namenode ./hadoop-daemon.sh start datanode 通过这种逐步启动的方式，比start-all.sh方式少了一个SecondaryNameNode进程，这不影响Hadoop的使用，其实在 Hadoop2.0中，SecondaryNa
中国互联网走在“灰度”上 ronin47 管理灰度
中国互联网走在“灰度”上（转）文/孕峰第一次听说灰度这个词，是任正非说新型管理者所需要的素质。第二次听说是来自马化腾。似乎其他人包括马云也用不同的语言说过类似的意思。灰度这个词所包含的意义和视野是广远的。要理解这个词，可能同样要用“灰度”的心态。灰度的反面，是规规矩矩，清清楚楚，泾渭分明，严谨条理，是决不妥协，不转弯，认死理。黑白分明不是灰度，像彩虹那样
java-51-输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。 bylijinnan java
public class PrintMatrixClockwisely { /** * Q51.输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。例如：如果输入如下矩阵： 1 2 3 4 5 6 7 8 9
mongoDB 用户管理开窍的石头 mongoDB用户管理
1:添加用户第一次设置用户需要进入admin数据库下设置超级用户（use admin） db.addUsr({user:'useName',pwd:'111111',roles:[readWrite,dbAdmin]}); 第一个参数用户的名字第二个参数
[游戏与生活]玩暗黑破坏神3的一些问题 comsci 生活
暗黑破坏神3是有史以来最让人激动的游戏。。。。但是有几个问题需要我们注意玩这个游戏的时间，每天不要超过一个小时，且每次玩游戏最好在白天结束游戏之后，最好在太阳下面来晒一下身上的暗黑气息，让自己恢复人的生气 &nb
java 二维数组如何存入数据库 cuiyadll java
using System; using System.Linq; using System.Text; using System.Windows.Forms; using System.Xml; using System.Xml.Serialization; using System.IO; namespace WindowsFormsApplication1 {
本地事务和全局事务Local Transaction and Global Transaction(JTA) darrenzhu java spring local global transaction
Configuring Spring and JTA without full Java EE http://spring.io/blog/2011/08/15/configuring-spring-and-jta-without-full-java-ee/ Spring doc -Transaction Management http://docs.spring.io/spri
Linux命令之alias - 设置命令的别名，让 Linux 命令更简练 dcj3sjt126com linux alias
用途说明设置命令的别名。在linux系统中如果命令太长又不符合用户的习惯，那么我们可以为它指定一个别名。虽然可以为命令建立“链接”解决长文件名的问题，但对于带命令行参数的命令，链接就无能为力了。而指定别名则可以解决此类所有问题【1】。常用别名来简化ssh登录【见示例三】，使长命令变短，使常用的长命令行变短，强制执行命令时询问等。常用参数格式：alias 格式：ali
yii2 restful web服务[格式响应] dcj3sjt126com PHP yii2
响应格式当处理一个 RESTful API 请求时，一个应用程序通常需要如下步骤来处理响应格式：确定可能影响响应格式的各种因素，例如媒介类型，语言，版本，等等。这个过程也被称为 content negotiation。资源对象转换为数组，如在 Resources 部分中所描述的。通过 [[yii\rest\Serializer]]
MongoDB索引调优（2）——[十] eksliang mongodb MongoDB索引优化
转载请出自出处：http://eksliang.iteye.com/blog/2178555 一、概述上一篇文档中也说明了，MongoDB的索引几乎与关系型数据库的索引一模一样，优化关系型数据库的技巧通用适合MongoDB，所有这里只讲MongoDB需要注意的地方二、索引内嵌文档可以在嵌套文档的键上建立索引，方式与正常
当滑动到顶部和底部时，实现Item的分离效果的ListView gundumw100 android
拉动ListView，Item之间的间距会变大，释放后恢复原样； package cn.tangdada.tangbang.widget; import android.annotation.TargetApi; import android.content.Context; import android.content.res.TypedArray; import andr
程序员用HTML5制作的爱心树表白动画 ini JavaScript jquery Web html5 css
体验效果：http://keleyi.com/keleyi/phtml/html5/31.htmHTML代码如下： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"><head><meta charset="UTF-8" > <ti
预装windows 8 系统GPT模式的ThinkPad T440改装64位 windows 7旗舰版 kakajw ThinkPad 预装改装 windows 7 windows 8
该教程具有普遍参考性，特别适用于联想的机器，其他品牌机器的处理过程也大同小异。该教程是个人多次尝试和总结的结果，实用性强，推荐给需要的人！缘由小弟最近入手笔记本ThinkPad T440，但是特别不能习惯笔记本出厂预装的Windows 8系统，而且厂商自作聪明地预装了一堆没用的应用软件，消耗不少的系统资源（本本的内存为4G，系统启动完成时，物理内存占用比
Nginx学习笔记 mcj8089 nginx
一、安装nginx 1、在nginx官方网站下载一个包，下载地址是： http://nginx.org/download/nginx-1.4.2.tar.gz 2、WinSCP(ftp上传工
mongodb 聚合查询每天论坛链接点击次数 qiaolevip 每天进步一点点学习永无止境 mongodb 纵观千象
/* 18 */ { "_id" : ObjectId("5596414cbe4d73a327e50274"), "msgType" : "text", "sendTime" : ISODate("2015-07-03T08:01:16.000Z"
java术语（PO/POJO/VO/BO/DAO/DTO） Luob. DAO POJO DTO po VO BO
PO(persistant object) 持久对象在o/r 映射的时候出现的概念,如果没有o/r映射,就没有这个概念存在了.通常对应数据模型(数据库),本身还有部分业务逻辑的处理.可以看成是与数据库中的表相映射的java对象.最简单的PO就是对应数据库中某个表中的一条记录,多个记录可以用PO的集合.PO中应该不包含任何对数据库的操作. VO(value object) 值对象通
算法复杂度 Wuaner Algorithm
Time Complexity & Big-O： http://stackoverflow.com/questions/487258/plain-english-explanation-of-big-o http://bigocheatsheet.com/ http://www.sitepoint.com/time-complexity-algorithms/