#include "inference_engine_common_impl.h"
#include "Inference.h"
#include "image_classification_type.h"
+#include "MetaParser.h"
#include "ImageClassificationParser.h"
+#include "image_classification_config.h"
#include "machine_learning_preprocess.h"
#include "async_manager.h"
protected:
std::unique_ptr<mediavision::inference::Inference> _inference;
- std::unique_ptr<MediaVision::Common::EngineConfig> _config;
- std::unique_ptr<MetaParser> _parser;
+ std::shared_ptr<ImageClassificationConfig> _config;
Preprocess _preprocess;
- std::string _modelFilePath;
- std::string _modelMetaFilePath;
- std::string _modelLabelFilePath;
std::vector<std::string> _labels;
std::vector<std::string> _valid_backends;
std::vector<std::string> _valid_devices;
- int _backendType {};
- int _targetDeviceType {};
void getOutputNames(std::vector<std::string> &names);
void getOutpuTensor(std::string &target_name, std::vector<float> &tensor);
- void parseMetaFile(const std::string &meta_file_name);
template<typename T> void inference(std::vector<std::vector<T> > &inputVectors);
virtual ImageClassificationResult &result() = 0;
public:
- ImageClassification();
+ explicit ImageClassification(std::shared_ptr<ImageClassificationConfig> config);
virtual ~ImageClassification() = default;
void preDestroy();
- void setUserModel(std::string model_file, std::string meta_file, std::string label_file);
- void setEngineInfo(std::string engine_type, std::string device_type);
+ void setEngineInfo(std::string engine_type_name, std::string device_type_name);
void getNumberOfEngines(unsigned int *number_of_engines);
void getEngineType(unsigned int engine_index, char **engine_type);
void getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices);
void getDeviceType(const char *engine_type, const unsigned int device_index, char **device_type);
- void configure(const std::string &configFile);
+ void configure();
void prepare();
void perform(mv_source_h &mv_src);
void performAsync(ImageClassificationInput &input);
#include "EngineConfig.h"
#include "itask.h"
+#include "image_classification_config.h"
#include "image_classification_default.h"
namespace mediavision
{
private:
std::unique_ptr<ImageClassification> _image_classification;
+ std::shared_ptr<ImageClassificationConfig> _config;
T _source;
+ const std::string _config_file_name = "image_classification.json";
+
+ void create();
public:
ImageClassificationAdapter();
--- /dev/null
+/**
+ * Copyright (c) 2023 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __IMAGE_CLASSIFICATION_CONFIG_H__
+#define __IMAGE_CLASSIFICATION_CONFIG_H__
+
+#include <mv_common.h>
+#include "mv_private.h"
+#include "EngineConfig.h"
+
+#include "MetaParser.h"
+#include "image_classification_type.h"
+
+namespace mediavision
+{
+namespace machine_learning
+{
+class ImageClassificationConfig
+{
+private:
+ std::unique_ptr<MetaParser> _parser;
+ std::string _modelFilePath;
+ std::string _modelMetaFilePath;
+ std::string _modelDefaultPath;
+ std::string _modelLabelFilePath;
+ int _backendType {};
+ int _targetDeviceType {};
+
+public:
+ ImageClassificationConfig();
+ virtual ~ImageClassificationConfig() = default;
+
+ void setUserModel(const std::string &model_file, const std::string &meta_file, const std::string &label_file);
+ void parseConfigFile(const std::string &configFilePath);
+ void parseMetaFile();
+ void setBackendType(int backend_type);
+ void setTargetDeviceType(int device_type);
+ const std::string &getModelFilePath() const;
+ const std::string &getLabelFilePath() const;
+ MetaMap &getInputMetaMap() const;
+ MetaMap &getOutputMetaMap() const;
+ int getBackendType() const;
+ int getTargetDeviceType() const;
+ void loadMetaFile();
+};
+
+} // machine_learning
+} // mediavision
+
+#endif
\ No newline at end of file
ImageClassificationResult _result;
public:
- ImageClassificationDefault();
+ ImageClassificationDefault(std::shared_ptr<ImageClassificationConfig> config);
~ImageClassificationDefault();
ImageClassificationResult &result() override;
{
namespace machine_learning
{
-ImageClassification::ImageClassification()
- : _backendType(MV_INFERENCE_BACKEND_NONE), _targetDeviceType(MV_INFERENCE_TARGET_DEVICE_NONE)
+ImageClassification::ImageClassification(shared_ptr<ImageClassificationConfig> config) : _config(config)
{
_inference = make_unique<Inference>();
- _parser = make_unique<ImageClassificationParser>();
+ loadLabel();
}
void ImageClassification::preDestroy()
_async_manager->stop();
}
-void ImageClassification::configure(const string &configFile)
+void ImageClassification::configure()
{
- parseMetaFile(configFile);
-
- int ret = _inference->bind(_backendType, _targetDeviceType);
+ int ret = _inference->bind(_config->getBackendType(), _config->getTargetDeviceType());
if (ret != MEDIA_VISION_ERROR_NONE)
throw InvalidOperation("Fail to bind a backend engine.");
}
-static bool IsJsonFile(const string &fileName)
-{
- return (!fileName.substr(fileName.find_last_of(".") + 1).compare("json"));
-}
-
void ImageClassification::loadLabel()
{
+ if (_config->getLabelFilePath().empty())
+ return;
+
ifstream readFile;
_labels.clear();
- readFile.open(_modelLabelFilePath.c_str());
+ readFile.open(_config->getLabelFilePath().c_str());
if (readFile.fail())
- throw InvalidOperation("Fail to open " + _modelLabelFilePath + " file.");
+ throw InvalidOperation("Fail to open " + _config->getLabelFilePath() + " file.");
string line;
_valid_devices.push_back("gpu");
}
-void ImageClassification::setUserModel(string model_file, string meta_file, string label_file)
-{
- _modelFilePath = model_file;
- _modelMetaFilePath = meta_file;
- _modelLabelFilePath = label_file;
-}
-
-void ImageClassification::setEngineInfo(std::string engine_type, std::string device_type)
+void ImageClassification::setEngineInfo(std::string engine_type_name, std::string device_type_name)
{
- if (engine_type.empty() || device_type.empty())
+ if (engine_type_name.empty() || device_type_name.empty())
throw InvalidParameter("Invalid engine info.");
- transform(engine_type.begin(), engine_type.end(), engine_type.begin(), ::toupper);
- transform(device_type.begin(), device_type.end(), device_type.begin(), ::toupper);
+ transform(engine_type_name.begin(), engine_type_name.end(), engine_type_name.begin(), ::toupper);
+ transform(device_type_name.begin(), device_type_name.end(), device_type_name.begin(), ::toupper);
- _backendType = GetBackendType(engine_type);
- _targetDeviceType = GetDeviceType(device_type);
+ int engine_type = GetBackendType(engine_type_name);
+ int device_type = GetDeviceType(device_type_name);
- LOGI("Engine type : %s => %d, Device type : %s => %d", engine_type.c_str(), GetBackendType(engine_type),
- device_type.c_str(), GetDeviceType(device_type));
-
- if (_backendType == MEDIA_VISION_ERROR_INVALID_PARAMETER ||
- _targetDeviceType == MEDIA_VISION_ERROR_INVALID_PARAMETER)
+ if (engine_type == MEDIA_VISION_ERROR_INVALID_PARAMETER || device_type == MEDIA_VISION_ERROR_INVALID_PARAMETER)
throw InvalidParameter("backend or target device type not found.");
+
+ _config->setBackendType(engine_type);
+ _config->setTargetDeviceType(device_type);
+
+ LOGI("Engine type : %s => %d, Device type : %s => %d", engine_type_name.c_str(), engine_type,
+ device_type_name.c_str(), device_type);
}
void ImageClassification::getNumberOfEngines(unsigned int *number_of_engines)
*device_type = const_cast<char *>(_valid_devices[device_index].data());
}
-void ImageClassification::parseMetaFile(const string &meta_file_name)
-{
- int ret = MEDIA_VISION_ERROR_NONE;
-
- _config = make_unique<EngineConfig>(string(MV_CONFIG_PATH) + meta_file_name);
-
- if (_backendType == MV_INFERENCE_BACKEND_NONE) {
- ret = _config->getIntegerAttribute(string(MV_IMAGE_CLASSIFICATION_BACKEND_TYPE), &_backendType);
- if (ret != MEDIA_VISION_ERROR_NONE)
- throw InvalidOperation("Fail to get backend engine type.");
- }
-
- if (_targetDeviceType == MV_INFERENCE_TARGET_DEVICE_NONE) {
- ret = _config->getIntegerAttribute(string(MV_IMAGE_CLASSIFICATION_TARGET_DEVICE_TYPE), &_targetDeviceType);
- if (ret != MEDIA_VISION_ERROR_NONE)
- throw InvalidOperation("Fail to get target device type.");
- }
-
- string modelDefaultPath;
-
- ret = _config->getStringAttribute(MV_IMAGE_CLASSIFICATION_MODEL_DEFAULT_PATH, &modelDefaultPath);
- if (ret != MEDIA_VISION_ERROR_NONE)
- throw InvalidOperation("Fail to get model default path");
-
- if (_modelFilePath.empty()) {
- ret = _config->getStringAttribute(MV_IMAGE_CLASSIFICATION_MODEL_FILE_NAME, &_modelFilePath);
- if (ret != MEDIA_VISION_ERROR_NONE)
- throw InvalidOperation("Fail to get model file path");
- }
-
- _modelFilePath = modelDefaultPath + _modelFilePath;
- LOGI("model file path = %s", _modelFilePath.c_str());
-
- if (_modelMetaFilePath.empty()) {
- ret = _config->getStringAttribute(MV_IMAGE_CLASSIFICATION_MODEL_META_FILE_NAME, &_modelMetaFilePath);
- if (ret != MEDIA_VISION_ERROR_NONE)
- throw InvalidOperation("Fail to get model meta file path");
-
- if (_modelMetaFilePath.empty())
- throw InvalidOperation("Model meta file doesn't exist.");
-
- if (!IsJsonFile(_modelMetaFilePath))
- throw InvalidOperation("Model meta file should be json.");
- }
-
- _modelMetaFilePath = modelDefaultPath + _modelMetaFilePath;
- LOGI("meta file path = %s", _modelMetaFilePath.c_str());
-
- if (_modelLabelFilePath.empty()) {
- ret = _config->getStringAttribute(MV_IMAGE_CLASSIFICATION_MODEL_LABEL_FILE_NAME, &_modelLabelFilePath);
- if (ret != MEDIA_VISION_ERROR_NONE)
- throw InvalidOperation("Fail to get model label file path");
-
- if (_modelLabelFilePath.empty())
- throw InvalidOperation("Model label file doesn't exist.");
- }
-
- _modelLabelFilePath = modelDefaultPath + _modelLabelFilePath;
- LOGI("label file path = %s", _modelLabelFilePath.c_str());
-
- loadLabel();
- _parser->load(_modelMetaFilePath);
-}
-
void ImageClassification::prepare()
{
- int ret = _inference->configureInputMetaInfo(_parser->getInputMetaMap());
+ int ret = _inference->configureInputMetaInfo(_config->getInputMetaMap());
if (ret != MEDIA_VISION_ERROR_NONE)
throw InvalidOperation("Fail to configure input tensor info from meta file.");
- ret = _inference->configureOutputMetaInfo(_parser->getOutputMetaMap());
+ ret = _inference->configureOutputMetaInfo(_config->getOutputMetaMap());
if (ret != MEDIA_VISION_ERROR_NONE)
throw InvalidOperation("Fail to configure output tensor info from meta file.");
- _inference->configureModelFiles("", _modelFilePath, "");
+ _inference->configureModelFiles("", _config->getModelFilePath(), "");
// Request to load model files to a backend engine.
ret = _inference->load();
auto tensor_buffer_iter = tensor_info_map.begin();
// Get the meta information corresponding to a given input tensor name.
- return _parser->getInputMetaMap()[tensor_buffer_iter->first];
+ return _config->getInputMetaMap()[tensor_buffer_iter->first];
}
template<typename T>
{
template<typename T, typename V> ImageClassificationAdapter<T, V>::ImageClassificationAdapter() : _source()
{
- _image_classification = make_unique<ImageClassificationDefault>();
+ _config = make_shared<ImageClassificationConfig>();
+ _config->parseConfigFile(_config_file_name);
+
+ create();
}
template<typename T, typename V> ImageClassificationAdapter<T, V>::~ImageClassificationAdapter()
_image_classification->preDestroy();
}
+template<typename T, typename V> void ImageClassificationAdapter<T, V>::create()
+{
+ // reallocate the parser and load the meta file
+ _config->loadMetaFile();
+
+ _image_classification = make_unique<ImageClassificationDefault>(_config);
+}
+
template<typename T, typename V>
void ImageClassificationAdapter<T, V>::setModelInfo(const char *model_file, const char *meta_file,
const char *label_file, const char *model_name)
{
- _image_classification->setUserModel(string(model_file), string(meta_file), string(label_file));
+ _config->setUserModel(model_file, meta_file, label_file);
+ create();
+
+ if (!model_file && !meta_file) {
+ LOGW("Given model info is invalid so default model info will be used instead.");
+ return;
+ }
}
template<typename T, typename V>
template<typename T, typename V> void ImageClassificationAdapter<T, V>::configure()
{
- _image_classification->configure("image_classification.json");
+ _image_classification->configure();
}
template<typename T, typename V>
--- /dev/null
+/**
+ * Copyright (c) 2023 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "machine_learning_exception.h"
+#include "mv_image_classification_config.h"
+#include "ImageClassificationParser.h"
+#include "image_classification_config.h"
+
+using namespace std;
+using namespace MediaVision::Common;
+using namespace mediavision::machine_learning;
+using namespace mediavision::machine_learning::exception;
+
+namespace mediavision
+{
+namespace machine_learning
+{
+ImageClassificationConfig::ImageClassificationConfig()
+{}
+
+void ImageClassificationConfig::setBackendType(int backend_type)
+{
+ _backendType = backend_type;
+}
+
+void ImageClassificationConfig::setTargetDeviceType(int device_type)
+{
+ _targetDeviceType = device_type;
+}
+
+const std::string &ImageClassificationConfig::getModelFilePath() const
+{
+ return _modelFilePath;
+}
+
+const std::string &ImageClassificationConfig::getLabelFilePath() const
+{
+ return _modelLabelFilePath;
+}
+
+MetaMap &ImageClassificationConfig::getInputMetaMap() const
+{
+ return _parser->getInputMetaMap();
+}
+
+MetaMap &ImageClassificationConfig::getOutputMetaMap() const
+{
+ return _parser->getOutputMetaMap();
+}
+
+int ImageClassificationConfig::getBackendType() const
+{
+ return _backendType;
+}
+
+int ImageClassificationConfig::getTargetDeviceType() const
+{
+ return _targetDeviceType;
+}
+
+void ImageClassificationConfig::setUserModel(const string &model_file, const string &meta_file,
+ const string &label_file)
+{
+ if (!model_file.empty())
+ _modelFilePath = _modelDefaultPath + model_file;
+ if (!meta_file.empty())
+ _modelMetaFilePath = _modelDefaultPath + meta_file;
+ if (!label_file.empty())
+ _modelLabelFilePath = _modelDefaultPath + label_file;
+}
+
+static bool IsJsonFile(const string &fileName)
+{
+ return (!fileName.substr(fileName.find_last_of(".") + 1).compare("json"));
+}
+
+void ImageClassificationConfig::parseConfigFile(const std::string &configFilePath)
+{
+ auto config = make_unique<EngineConfig>(MV_CONFIG_PATH + configFilePath);
+
+ int ret = MEDIA_VISION_ERROR_NONE;
+
+ if (_backendType == MV_INFERENCE_BACKEND_NONE) {
+ ret = config->getIntegerAttribute(MV_IMAGE_CLASSIFICATION_BACKEND_TYPE, &_backendType);
+ if (ret != MEDIA_VISION_ERROR_NONE)
+ throw InvalidOperation("Fail to get backend engine type.");
+ }
+
+ if (_targetDeviceType == MV_INFERENCE_TARGET_DEVICE_NONE) {
+ ret = config->getIntegerAttribute(MV_IMAGE_CLASSIFICATION_TARGET_DEVICE_TYPE, &_targetDeviceType);
+ if (ret != MEDIA_VISION_ERROR_NONE)
+ throw InvalidOperation("Fail to get target device type.");
+ }
+
+ ret = config->getStringAttribute(MV_IMAGE_CLASSIFICATION_MODEL_DEFAULT_PATH, &_modelDefaultPath);
+ if (ret != MEDIA_VISION_ERROR_NONE)
+ throw InvalidOperation("Fail to get model default path");
+
+ ret = config->getStringAttribute(MV_IMAGE_CLASSIFICATION_MODEL_FILE_NAME, &_modelFilePath);
+ if (ret != MEDIA_VISION_ERROR_NONE)
+ throw InvalidOperation("Fail to get model file path");
+
+ _modelFilePath = _modelDefaultPath + _modelFilePath;
+ LOGI("model file path = %s", _modelFilePath.c_str());
+
+ ret = config->getStringAttribute(MV_IMAGE_CLASSIFICATION_MODEL_META_FILE_NAME, &_modelMetaFilePath);
+ if (ret != MEDIA_VISION_ERROR_NONE)
+ throw InvalidOperation("Fail to get model meta file path");
+
+ if (_modelMetaFilePath.empty())
+ throw InvalidOperation("Model meta file doesn't exist.");
+
+ if (!IsJsonFile(_modelMetaFilePath))
+ throw InvalidOperation("Model meta file should be json");
+
+ _modelMetaFilePath = _modelDefaultPath + _modelMetaFilePath;
+ LOGI("meta file path = %s", _modelMetaFilePath.c_str());
+
+ ret = config->getStringAttribute(MV_IMAGE_CLASSIFICATION_MODEL_LABEL_FILE_NAME, &_modelLabelFilePath);
+ if (ret != MEDIA_VISION_ERROR_NONE)
+ throw InvalidOperation("Fail to get label file path");
+
+ if (_modelLabelFilePath.empty()) {
+ LOGW("Label doesn't exist.");
+ return;
+ }
+
+ _modelLabelFilePath = _modelDefaultPath + _modelLabelFilePath;
+ LOGI("label file path = %s", _modelLabelFilePath.c_str());
+}
+
+void ImageClassificationConfig::loadMetaFile()
+{
+ _parser = make_unique<ImageClassificationParser>();
+ _parser->load(_modelMetaFilePath);
+}
+
+}
+}
{
namespace machine_learning
{
-ImageClassificationDefault::ImageClassificationDefault() : _result()
+ImageClassificationDefault::ImageClassificationDefault(shared_ptr<ImageClassificationConfig> config)
+ : ImageClassification(config), _result()
{}
ImageClassificationDefault::~ImageClassificationDefault()
// In case of image classification model, only one output tensor is used.
ImageClassification::getOutpuTensor(names[0], output_vec);
- auto metaInfo = _parser->getOutputMetaMap().at(names[0]);
+ auto metaInfo = _config->getOutputMetaMap().at(names[0]);
auto decodingScore = static_pointer_cast<DecodingScore>(metaInfo->decodingTypeMap.at(DecodingType::SCORE));
if (decodingScore->type == ScoreType::SIGMOID) {
projects / platform / core / api / mediavision.git / commitdiff