mv_machine_learning: code refactoring to GetClassificationResults function

Did code refactoring to GetClassificationResults member function of Inference class
for next code refactoring.

What this patch did are,
	 - drop code dependency of mPreProc from Inference class.
	 - drop code duplication of getting image classification result by
	   making same code to be used.
	 - and code sliding.

Change-Id: I721dc3081f730fcdb75dbe91ad743f906e076ea4
Signed-off-by: Inki Dae <inki.dae@samsung.com>

3 files changed, 57 insertions, 73 deletions

diff --git a/mv_machine_learning/mv_inference/inference/include/Inference.h b/mv_machine_learning/mv_inference/inference/include/Inference.h
index 969b5a28..cad69e9f 100644
--- a/mv_machine_learning/mv_inference/inference/include/Inference.h
+++ b/mv_machine_learning/mv_inference/inference/include/Inference.h
@@ -293,7 +293,7 @@ namespace inference
 		 * @since_tizen 5.5
 		 * @return @c true on success, otherwise a negative error value
 		 */
-		int GetClassficationResults(ImageClassificationResults *classificationResults);
+		int GetClassficationResults(ImageClassificationResults &classificationResults);
 
 		/**
 		 * @brief	Gets the ObjectDetectioResults
@@ -366,7 +366,6 @@ namespace inference
 
 		Metadata mMetadata;
 		PreProcess mPreProc;
-		PostProcess mPostProc;
 
 	private:
 		void CheckSupportedInferenceBackend();
diff --git a/mv_machine_learning/mv_inference/inference/src/Inference.cpp b/mv_machine_learning/mv_inference/inference/src/Inference.cpp
index f5d54884..756f0419 100755
--- a/mv_machine_learning/mv_inference/inference/src/Inference.cpp
+++ b/mv_machine_learning/mv_inference/inference/src/Inference.cpp
@@ -77,8 +77,7 @@ namespace inference
 			engine_config(),
 			mBackend(),
 			mMetadata(),
-			mPreProc(),
-			mPostProc()
+			mPreProc()
 	{
 		LOGI("ENTER");
 
@@ -1094,20 +1093,24 @@ namespace inference
 		return mSupportedInferenceBackend[backend];
 	}
 
-	int Inference::GetClassficationResults(
-			ImageClassificationResults *classificationResults)
+	int Inference::GetClassficationResults(ImageClassificationResults &results)
 	{
 		OutputMetadata& outputMeta = mMetadata.GetOutputMeta();
+		// Will contain top N results in ascending order.
+		std::vector<std::pair<float, int>> topScore;
+		auto threadHold = mConfig.mConfidenceThresHold;
+
+		results.number_of_classes = 0;
+
 		if (outputMeta.IsParsed()) {
-			std::vector<std::pair<float, int>> topScore;
-			float value = 0.0f;
 			auto& info = outputMeta.GetScore();
-
 			std::vector<int> indexes = info.GetDimInfo().GetValidIndexAll();
+
 			if (indexes.size() != 1) {
 				LOGE("Invalid dim size. It should be 1");
 				return MEDIA_VISION_ERROR_INVALID_OPERATION;
 			}
+
 			int classes = mOutputLayerProperty.layers[info.GetName()].shape[indexes[0]];
 
 			if (!mOutputTensorBuffers.exist(info.GetName())) {
@@ -1115,8 +1118,14 @@ namespace inference
 				return MEDIA_VISION_ERROR_INVALID_OPERATION;
 			}
 
-			mPostProc.ScoreClear(info.GetTopNumber());
+			PostProcess postProc;
+
+			postProc.ScoreClear(info.GetTopNumber());
+			threadHold = info.GetThresHold();
+
 			for (int cId = 0; cId < classes; ++cId) {
+				float value = 0.0f;
+
 				try {
 					value = mOutputTensorBuffers.getValue<float>(info.GetName(), cId);
 				} catch (const std::exception& e) {
@@ -1129,35 +1138,18 @@ namespace inference
 											info.GetDeQuant()->GetScale(),
 											info.GetDeQuant()->GetZeroPoint());
 				}
-				if (info.GetType() == INFERENCE_SCORE_TYPE_SIGMOID) {
+
+				if (info.GetType() == INFERENCE_SCORE_TYPE_SIGMOID)
 					value = PostProcess::sigmoid(value);
-				}
 
-				if (value < info.GetThresHold())
+				if (value < threadHold)
 					continue;
 
 				LOGI("id[%d]: %.3f", cId, value);
-				mPostProc.ScorePush(value, cId);
-			}
-			mPostProc.ScorePop(topScore);
-
-			ImageClassificationResults results;
-			results.number_of_classes = 0;
-			for (auto& value : topScore) {
-				LOGI("score: %.3f, threshold: %.3f", value.first, info.GetThresHold());
-				LOGI("idx:%d", value.second);
-				LOGI("classProb: %.3f", value.first);
-
-				results.indices.push_back(value.second);
-				results.confidences.push_back(value.first);
-				results.names.push_back(mUserListName[value.second]);
-				results.number_of_classes++;
+				postProc.ScorePush(value, cId);
 			}
 
-			*classificationResults = results;
-			LOGE("Inference: GetClassificationResults: %d\n",
-				results.number_of_classes);
-
+			postProc.ScorePop(topScore);
 		} else {
 			tensor_t outputData;
 
@@ -1168,56 +1160,52 @@ namespace inference
 				return ret;
 			}
 
-			// Will contain top N results in ascending order.
-			std::vector<std::pair<float, int> > top_results;
+			auto classes = outputData.dimInfo[0][1];
+			auto *prediction = reinterpret_cast<float *>(outputData.data[0]);
+
+			LOGI("class count: %d", classes);
+
 			std::priority_queue<std::pair<float, int>,
-								std::vector<std::pair<float, int> >,
-								std::greater<std::pair<float, int> > >
+								std::vector<std::pair<float, int>>,
+								std::greater<std::pair<float, int>>>
 					top_result_pq;
-			float value = 0.0f;
 
-			int count = outputData.dimInfo[0][1];
-			LOGI("count: %d", count);
-			float *prediction = reinterpret_cast<float *>(outputData.data[0]);
-			for (int i = 0; i < count; ++i) {
-				value = prediction[i];
+			for (int cId = 0; cId < classes; ++cId) {
+				auto value = prediction[cId];
+
+				if (value < threadHold)
+					continue;
 
 				// Only add it if it beats the threshold and has a chance at being in
 				// the top N.
-				top_result_pq.push(std::pair<float, int>(value, i));
+				top_result_pq.push(std::pair<float, int>(value, cId));
 
 				// If at capacity, kick the smallest value out.
-				if (top_result_pq.size() > static_cast<size_t>(mConfig.mMaxOutputNumbers)) {
+				if (top_result_pq.size() > static_cast<size_t>(mConfig.mMaxOutputNumbers))
 					top_result_pq.pop();
-				}
 			}
 
 			// Copy to output vector and reverse into descending order.
 			while (!top_result_pq.empty()) {
-				top_results.push_back(top_result_pq.top());
+				topScore.push_back(top_result_pq.top());
 				top_result_pq.pop();
 			}
-			std::reverse(top_results.begin(), top_results.end());
-
-			ImageClassificationResults results;
-			results.number_of_classes = 0;
-			for (auto& result : top_results) {
-				if (result.first < mThreshold)
-					continue;
 
-				LOGI("class Idx: %d, Prob: %.4f", result.second, result.first);
+			std::reverse(topScore.begin(), topScore.end());
+		}
 
-				results.indices.push_back(result.second);
-				results.confidences.push_back(result.first);
-				results.names.push_back(mUserListName[result.second]);
-				results.number_of_classes++;
-			}
+		for (auto& score : topScore) {
+			LOGI("score: %.3f, threshold: %.3f", score.first, threadHold);
+			LOGI("idx:%d", score.second);
+			LOGI("classProb: %.3f", score.first);
 
-			*classificationResults = results;
-			LOGE("Inference: GetClassificationResults: %d\n",
-				results.number_of_classes);
+			results.indices.push_back(score.second);
+			results.confidences.push_back(score.first);
+			results.names.push_back(mUserListName[score.second]);
+			results.number_of_classes++;
 		}
 
+		LOGE("Inference: GetClassificationResults: %d\n", results.number_of_classes);
 		return MEDIA_VISION_ERROR_NONE;
 	}
 
diff --git a/mv_machine_learning/mv_inference/inference/src/mv_inference_open.cpp b/mv_machine_learning/mv_inference/inference/src/mv_inference_open.cpp
index ed09bb06..41c62df1 100644
--- a/mv_machine_learning/mv_inference/inference/src/mv_inference_open.cpp
+++ b/mv_machine_learning/mv_inference/inference/src/mv_inference_open.cpp
@@ -638,33 +638,30 @@ int mv_inference_image_classify_open(
 
 	ImageClassificationResults classificationResults;
 
-	ret = pInfer->GetClassficationResults(&classificationResults);
+	ret = pInfer->GetClassficationResults(classificationResults);
 	if (ret != MEDIA_VISION_ERROR_NONE) {
 		LOGE("Fail to get inference results");
 		return ret;
 	}
 
 	int numberOfOutputs = classificationResults.number_of_classes;
-
 	static const int START_CLASS_NUMBER = 10;
 	static std::vector<const char *> names(START_CLASS_NUMBER);
 
 	if (numberOfOutputs > START_CLASS_NUMBER)
 		names.resize(numberOfOutputs);
 
-	LOGE("mv_inference_open: number_of_classes: %d\n",
-		 classificationResults.number_of_classes);
+	LOGE("mv_inference_open: number_of_classes: %d\n", numberOfOutputs);
 
-	for (int n = 0; n < numberOfOutputs; ++n) {
-		LOGE("names: %s", classificationResults.names[n].c_str());
-		names[n] = classificationResults.names[n].c_str();
+	for (int output_index = 0; output_index < numberOfOutputs; ++output_index) {
+		LOGE("names: %s", classificationResults.names[output_index].c_str());
+		names[output_index] = classificationResults.names[output_index].c_str();
 	}
 
-	int *indices = classificationResults.indices.data();
-	float *confidences = classificationResults.confidences.data();
+	auto *indices = classificationResults.indices.data();
+	auto *confidences = classificationResults.confidences.data();
 
-	classified_cb(source, numberOfOutputs, indices, names.data(), confidences,
-				  user_data);
+	classified_cb(source, numberOfOutputs, indices, names.data(), confidences, user_data);
 
 	return ret;
 }