Wie BatchSize mit Tensorflow C++ API zu erhöhen?

Question

nahm ich den Code in https://gist.github.com/kyrs/9adf86366e9e4f04addb (die eine opencv cv nimmt :: Mat Bild als Eingabe und wandelt es in Tensor) und ich verwende es Bilder mit dem Modell inception_v3_2016_08_28_frozen.pb im Tensorflow Tutorial (https://www.tensorflow.org/tutorials/image_recognition#usage_with_the_c_api) angegeben beschriften. Alles funktionierte gut, wenn eine Chargengröße von 1 verwendet wurde. Wenn ich jedoch die Chargengröße auf 2 (oder mehr) erhöhe, ist die Größe finalOutput (die vom Typ std :: vector ist) gleich Null.

Hier ist der Code, um den Fehler zu reproduzieren:

// Only for VisualStudio 
#define COMPILER_MSVC 
#define NOMINMAX 

#include <string> 
#include <iostream> 
#include <fstream> 

#include <opencv2/opencv.hpp> 
#include <opencv2/imgproc/imgproc.hpp> 

#include "tensorflow/core/public/session.h" 
#include "tensorflow/core/platform/env.h" 
#include "tensorflow/core/framework/tensor.h" 

int batchSize = 2; 
int height = 299; 
int width = 299; 
int depth = 3; 

int mean = 0; 
int stdev = 255; 

// Set image paths 
cv::String pathFilenameImg1 = "D:/IMGS/grace_hopper.jpg"; 
cv::String pathFilenameImg2 = "D:/IMGS/lenna.jpg"; 

// Set model paths 
std::string graphFile = "D:/Tensorflow/models/inception_v3_2016_08_28_frozen.pb"; 
std::string labelfile = "D:/Tensorflow/models/imagenet_slim_labels.txt"; 
std::string InputName = "input"; 
std::string OutputName = "InceptionV3/Predictions/Reshape_1"; 


void read_prepare_image(cv::String pathImg, cv::Mat &imgPrepared) { 

     // Read Color image: 
     cv::Mat imgBGR = cv::imread(pathImg); 

     // Now we resize the image to fit Model's expected sizes: 
     cv::Size s(height, width); 
     cv::Mat imgResized; 
     cv::resize(imgBGR, imgResized, s, 0, 0, cv::INTER_CUBIC); 

     // Convert the image to float and normalize data: 
     imgResized.convertTo(imgPrepared, CV_32FC1); 
     imgPrepared = imgPrepared - mean; 
     imgPrepared = imgPrepared/stdev; 

} 

int main() 
{ 
     // Read and prepare images using OpenCV: 
     cv::Mat img1, img2; 
     read_prepare_image(pathFilenameImg1, img1); 
     read_prepare_image(pathFilenameImg2, img2); 

     // creating a Tensor for storing the data 
     tensorflow::Tensor input_tensor(tensorflow::DT_FLOAT, tensorflow::TensorShape({ batchSize, height, width, depth })); 
     auto input_tensor_mapped = input_tensor.tensor<float, 4>(); 

     // Copy images data into the tensor: 
     for (int b = 0; b < batchSize; ++b) { 

      const float * source_data; 

      if (b == 0) 
        source_data = (float*)img1.data; 
      else 
        source_data = (float*)img2.data; 

      for (int y = 0; y < height; ++y) { 

        const float* source_row = source_data + (y * width * depth); 
        for (int x = 0; x < width; ++x) { 

          const float* source_pixel = source_row + (x * depth); 
          const float* source_B = source_pixel + 0; 
          const float* source_G = source_pixel + 1; 
          const float* source_R = source_pixel + 2; 

          input_tensor_mapped(b, y, x, 0) = *source_R; 
          input_tensor_mapped(b, y, x, 1) = *source_G; 
          input_tensor_mapped(b, y, x, 2) = *source_B; 

        } 
      } 
     } 

     // Load the graph: 
     tensorflow::GraphDef graph_def; 
     ReadBinaryProto(tensorflow::Env::Default(), graphFile, &graph_def); 

     // create a session with the graph 
     std::unique_ptr<tensorflow::Session> session_inception(tensorflow::NewSession(tensorflow::SessionOptions())); 
     session_inception->Create(graph_def); 

     // run the loaded graph 
     std::vector<tensorflow::Tensor> finalOutput; 
     session_inception->Run({ { InputName,input_tensor } }, { OutputName }, {}, &finalOutput); 

     // Get Top 5 classes: 
     std::cerr << "final output size = " << finalOutput.size() << std::endl; 
     tensorflow::Tensor output = std::move(finalOutput.at(0)); 
     auto scores = output.flat<float>(); 
     std::cerr << "scores size=" << scores.size() << std::endl; 

     std::ifstream label(labelfile); 
     std::string line; 

     std::vector<std::pair<float, std::string>> sorted; 

     for (unsigned int i = 0; i <= 1000; ++i) { 
      std::getline(label, line); 
      sorted.emplace_back(scores(i), line); 
     } 

     std::sort(sorted.begin(), sorted.end()); 
     std::reverse(sorted.begin(), sorted.end()); 
     std::cout << "size of the sorted file is " << sorted.size() << std::endl; 
     for (unsigned int i = 0; i< 5; ++i) 
      std::cout << "The output of the current graph has category " << sorted[i].second << " with probability " << sorted[i].first << std::endl; 

} 

Habe ich etwas verpasst? Irgendwelche Ideen?

Vielen Dank im Voraus!

Answer 1

Ich hatte das gleiche Problem. Als ich zu dem Modell wechselte, das in https://github.com/tensorflow/tensorflow/tree/master/tensorflow/tools/benchmark (differente Version der Einleitung) verwendet wurde, funktionieren größere Losgrößen richtig.

Hinweis müssen Sie die Eingabegröße ändern, von 299,299,3 zu 224,224,3 und den Eingangs- und Ausgangsebenennamen: Eingang: 0 und Ausgang: 0