Vitaliy Lyudvichenko
10 years ago
parent
a6963b4abb
commit
6e23d93b39
16 changed files with 4294 additions and 61 deletions
@ -0,0 +1,178 @@ |
||||
#pragma once |
||||
#include <opencv2/core.hpp> |
||||
|
||||
namespace cv |
||||
{ |
||||
namespace dnn |
||||
{ |
||||
|
||||
struct DictValue |
||||
{ |
||||
int type; |
||||
|
||||
union
|
||||
{ |
||||
int i; |
||||
unsigned u; |
||||
double d; |
||||
bool b; |
||||
String *s; |
||||
}; |
||||
|
||||
DictValue(const DictValue &r); |
||||
DictValue(int p = 0) : type(cv::Param::INT), i(p) {} |
||||
DictValue(unsigned p) : type(cv::Param::UNSIGNED_INT), u(p) {} |
||||
DictValue(double p) : type(cv::Param::REAL), d(p) {} |
||||
DictValue(bool p) : type(cv::Param::BOOLEAN), b(p) {} |
||||
DictValue(const String &p) : type(cv::Param::STRING), s(new String(p)) {} |
||||
|
||||
template<typename T> |
||||
T get() const; |
||||
|
||||
template<typename T> |
||||
const T &get() const; |
||||
|
||||
DictValue &operator=(const DictValue &r); |
||||
|
||||
~DictValue(); |
||||
|
||||
private: |
||||
void release(); |
||||
}; |
||||
|
||||
class Dict |
||||
{ |
||||
//TODO: maybe this mechanism was realized somewhere in OpenCV?
|
||||
typedef std::map<String, DictValue> _Dict; |
||||
_Dict dict; |
||||
|
||||
public: |
||||
|
||||
template <typename T> |
||||
const T &get(const String &name) const |
||||
{ |
||||
_Dict::const_iterator i = dict.find(name); |
||||
CV_Assert(i != dict.end()); |
||||
return i->second.get<T>(); |
||||
} |
||||
|
||||
template <typename T> |
||||
const T &get(const String &name, const T &default) const |
||||
{ |
||||
_Dict::const_iterator i = dict.find(name); |
||||
|
||||
if (i != dict.end()) |
||||
return i->second.get<T>(); |
||||
else |
||||
return default; |
||||
} |
||||
|
||||
template<typename T> |
||||
const T &set(const String &name, const T &value) |
||||
{ |
||||
_Dict::iterator i = dict.find(name); |
||||
|
||||
if (i != dict.end()) |
||||
i->second = DictValue(value); |
||||
else |
||||
dict.insert(std::make_pair(name, DictValue(value))); |
||||
|
||||
return value; |
||||
} |
||||
}; |
||||
|
||||
|
||||
template<> |
||||
inline int DictValue::get<int>() const |
||||
{ |
||||
CV_Assert(type == cv::ParamType<int>::type || type == cv::ParamType<unsigned>::type && (int)u >= 0); |
||||
return i; |
||||
} |
||||
|
||||
template<> |
||||
inline unsigned DictValue::get<unsigned>() const |
||||
{ |
||||
CV_Assert(type == cv::ParamType<unsigned>::type || type == cv::ParamType<int>::type && i >= 0); |
||||
return u; |
||||
} |
||||
|
||||
template<> |
||||
inline double DictValue::get<double>() const |
||||
{ |
||||
CV_Assert(type == cv::ParamType<double>::type); |
||||
return d; |
||||
} |
||||
|
||||
template<> |
||||
inline float DictValue::get<float>() const |
||||
{ |
||||
CV_Assert(type == cv::ParamType<double>::type); |
||||
return (float)d; |
||||
} |
||||
|
||||
template<> |
||||
inline bool DictValue::get<bool>() const |
||||
{ |
||||
if (type == cv::ParamType<bool>::type) |
||||
{ |
||||
return b; |
||||
} |
||||
else if (type == cv::ParamType<int>::type || type == cv::ParamType<unsigned>::type) |
||||
{ |
||||
return i; |
||||
} |
||||
else |
||||
{ |
||||
CV_Assert(type == cv::ParamType<bool>::type || type == cv::ParamType<int>::type || type == cv::ParamType<unsigned>::type); |
||||
return 0; |
||||
} |
||||
} |
||||
|
||||
template<> |
||||
inline const String &DictValue::get<String>() const |
||||
{ |
||||
CV_Assert(type == cv::ParamType<String>::type); |
||||
return *s; |
||||
} |
||||
|
||||
inline void DictValue::release() |
||||
{ |
||||
if (type == cv::Param::STRING && s != NULL) |
||||
{ |
||||
delete s; |
||||
s = NULL; |
||||
} |
||||
|
||||
} |
||||
|
||||
inline DictValue::~DictValue() |
||||
{ |
||||
release(); |
||||
} |
||||
|
||||
inline DictValue & DictValue::operator=(const DictValue &r) |
||||
{ |
||||
if (&r == this) |
||||
return *this; |
||||
|
||||
release(); |
||||
|
||||
//how to copy anonymous union without memcpy?
|
||||
for (size_t i = 0; i < sizeof(*this); i++) |
||||
((uchar*)this)[i] = ((uchar*)&r)[i]; |
||||
|
||||
if (r.type == cv::Param::STRING) |
||||
{ |
||||
s = new String(*r.s); |
||||
} |
||||
|
||||
return *this; |
||||
} |
||||
|
||||
inline DictValue::DictValue(const DictValue &r) |
||||
{ |
||||
*this = r; |
||||
} |
||||
|
||||
} |
||||
} |
||||
@ -0,0 +1,177 @@ |
||||
#ifndef CAFFE_COMMON_HPP_ |
||||
#define CAFFE_COMMON_HPP_ |
||||
|
||||
#include <opencv2/core.hpp> |
||||
#include <iostream> |
||||
#define CHECK CV_Assert |
||||
#define LOG(WHERE) std::cerr |
||||
|
||||
//#include <boost/shared_ptr.hpp>
|
||||
//#include <gflags/gflags.h>
|
||||
//#include <glog/logging.h>
|
||||
|
||||
#include <climits> |
||||
#include <cmath> |
||||
#include <fstream> // NOLINT(readability/streams) |
||||
#include <iostream> // NOLINT(readability/streams) |
||||
#include <map> |
||||
#include <set> |
||||
#include <sstream> |
||||
#include <string> |
||||
#include <utility> // pair |
||||
#include <vector> |
||||
|
||||
//#include "caffe/util/device_alternate.hpp"
|
||||
//
|
||||
//// gflags 2.1 issue: namespace google was changed to gflags without warning.
|
||||
//// Luckily we will be able to use GFLAGS_GFLAGS_H_ to detect if it is version
|
||||
//// 2.1. If yes, we will add a temporary solution to redirect the namespace.
|
||||
//// TODO(Yangqing): Once gflags solves the problem in a more elegant way, let's
|
||||
//// remove the following hack.
|
||||
//#ifndef GFLAGS_GFLAGS_H_
|
||||
//namespace gflags = google;
|
||||
//#endif // GFLAGS_GFLAGS_H_
|
||||
//
|
||||
//// Disable the copy and assignment operator for a class.
|
||||
//#define DISABLE_COPY_AND_ASSIGN(classname) \
|
||||
//private:\
|
||||
// classname(const classname&);\
|
||||
// classname& operator=(const classname&)
|
||||
//
|
||||
//// Instantiate a class with float and double specifications.
|
||||
//#define INSTANTIATE_CLASS(classname) \
|
||||
// char gInstantiationGuard##classname; \
|
||||
// template class classname<float>; \
|
||||
// template class classname<double>
|
||||
//
|
||||
//#define INSTANTIATE_LAYER_GPU_FORWARD(classname) \
|
||||
// template void classname<float>::Forward_gpu( \
|
||||
// const std::vector<Blob<float>*>& bottom, \
|
||||
// const std::vector<Blob<float>*>& top); \
|
||||
// template void classname<double>::Forward_gpu( \
|
||||
// const std::vector<Blob<double>*>& bottom, \
|
||||
// const std::vector<Blob<double>*>& top);
|
||||
//
|
||||
//#define INSTANTIATE_LAYER_GPU_BACKWARD(classname) \
|
||||
// template void classname<float>::Backward_gpu( \
|
||||
// const std::vector<Blob<float>*>& top, \
|
||||
// const std::vector<bool>& propagate_down, \
|
||||
// const std::vector<Blob<float>*>& bottom); \
|
||||
// template void classname<double>::Backward_gpu( \
|
||||
// const std::vector<Blob<double>*>& top, \
|
||||
// const std::vector<bool>& propagate_down, \
|
||||
// const std::vector<Blob<double>*>& bottom)
|
||||
//
|
||||
//#define INSTANTIATE_LAYER_GPU_FUNCS(classname) \
|
||||
// INSTANTIATE_LAYER_GPU_FORWARD(classname); \
|
||||
// INSTANTIATE_LAYER_GPU_BACKWARD(classname)
|
||||
//
|
||||
//// A simple macro to mark codes that are not implemented, so that when the code
|
||||
//// is executed we will see a fatal log.
|
||||
//#define NOT_IMPLEMENTED LOG(FATAL) << "Not Implemented Yet"
|
||||
//
|
||||
//// See PR #1236
|
||||
//namespace cv { class Mat; }
|
||||
//
|
||||
//namespace caffe {
|
||||
//
|
||||
//// We will use the boost shared_ptr instead of the new C++11 one mainly
|
||||
//// because cuda does not work (at least now) well with C++11 features.
|
||||
//using boost::shared_ptr;
|
||||
|
||||
// Common functions and classes from std that caffe often uses.
|
||||
using std::fstream; |
||||
using std::ios; |
||||
using std::isnan; |
||||
using std::isinf; |
||||
using std::iterator; |
||||
using std::make_pair; |
||||
using std::map; |
||||
using std::ostringstream; |
||||
using std::pair; |
||||
using std::set; |
||||
using std::string; |
||||
using std::stringstream; |
||||
using std::vector; |
||||
|
||||
//// A global initialization function that you should call in your main function.
|
||||
//// Currently it initializes google flags and google logging.
|
||||
//void GlobalInit(int* pargc, char*** pargv);
|
||||
//
|
||||
//// A singleton class to hold common caffe stuff, such as the handler that
|
||||
//// caffe is going to use for cublas, curand, etc.
|
||||
//class Caffe {
|
||||
// public:
|
||||
// ~Caffe();
|
||||
// inline static Caffe& Get() {
|
||||
// if (!singleton_.get()) {
|
||||
// singleton_.reset(new Caffe());
|
||||
// }
|
||||
// return *singleton_;
|
||||
// }
|
||||
// enum Brew { CPU, GPU };
|
||||
//
|
||||
// // This random number generator facade hides boost and CUDA rng
|
||||
// // implementation from one another (for cross-platform compatibility).
|
||||
// class RNG {
|
||||
// public:
|
||||
// RNG();
|
||||
// explicit RNG(unsigned int seed);
|
||||
// explicit RNG(const RNG&);
|
||||
// RNG& operator=(const RNG&);
|
||||
// void* generator();
|
||||
// private:
|
||||
// class Generator;
|
||||
// shared_ptr<Generator> generator_;
|
||||
// };
|
||||
//
|
||||
// // Getters for boost rng, curand, and cublas handles
|
||||
// inline static RNG& rng_stream() {
|
||||
// if (!Get().random_generator_) {
|
||||
// Get().random_generator_.reset(new RNG());
|
||||
// }
|
||||
// return *(Get().random_generator_);
|
||||
// }
|
||||
//#ifndef CPU_ONLY
|
||||
// inline static cublasHandle_t cublas_handle() { return Get().cublas_handle_; }
|
||||
// inline static curandGenerator_t curand_generator() {
|
||||
// return Get().curand_generator_;
|
||||
// }
|
||||
//#endif
|
||||
//
|
||||
// // Returns the mode: running on CPU or GPU.
|
||||
// inline static Brew mode() { return Get().mode_; }
|
||||
// // The setters for the variables
|
||||
// // Sets the mode. It is recommended that you don't change the mode halfway
|
||||
// // into the program since that may cause allocation of pinned memory being
|
||||
// // freed in a non-pinned way, which may cause problems - I haven't verified
|
||||
// // it personally but better to note it here in the header file.
|
||||
// inline static void set_mode(Brew mode) { Get().mode_ = mode; }
|
||||
// // Sets the random seed of both boost and curand
|
||||
// static void set_random_seed(const unsigned int seed);
|
||||
// // Sets the device. Since we have cublas and curand stuff, set device also
|
||||
// // requires us to reset those values.
|
||||
// static void SetDevice(const int device_id);
|
||||
// // Prints the current GPU status.
|
||||
// static void DeviceQuery();
|
||||
//
|
||||
// protected:
|
||||
//#ifndef CPU_ONLY
|
||||
// cublasHandle_t cublas_handle_;
|
||||
// curandGenerator_t curand_generator_;
|
||||
//#endif
|
||||
// shared_ptr<RNG> random_generator_;
|
||||
//
|
||||
// Brew mode_;
|
||||
// static shared_ptr<Caffe> singleton_;
|
||||
//
|
||||
// private:
|
||||
// // The private constructor to avoid duplicate instantiation.
|
||||
// Caffe();
|
||||
//
|
||||
// DISABLE_COPY_AND_ASSIGN(Caffe);
|
||||
//};
|
||||
//
|
||||
//} // namespace caffe
|
||||
//
|
||||
#endif // CAFFE_COMMON_HPP_
|
||||
@ -0,0 +1,232 @@ |
||||
//#include <fcntl.h>
|
||||
#include <google/protobuf/io/coded_stream.h> |
||||
#include <google/protobuf/io/zero_copy_stream_impl.h> |
||||
#include <google/protobuf/text_format.h> |
||||
#include <opencv2/core.hpp> |
||||
//#include <opencv2/highgui/highgui.hpp>
|
||||
//#include <opencv2/highgui/highgui_c.h>
|
||||
//#include <opencv2/imgproc/imgproc.hpp>
|
||||
//#include <stdint.h>
|
||||
//
|
||||
//#include <algorithm>
|
||||
#include <fstream> // NOLINT(readability/streams) |
||||
//#include <string>
|
||||
//#include <vector>
|
||||
//
|
||||
//#include "caffe/common.hpp"
|
||||
//#include "caffe.pb.h"
|
||||
//#include "caffe/util/io.hpp"
|
||||
//
|
||||
const int kProtoReadBytesLimit = INT_MAX; // Max size of 2 GB minus 1 byte.
|
||||
|
||||
namespace caffe { |
||||
|
||||
using google::protobuf::io::FileInputStream; |
||||
using google::protobuf::io::FileOutputStream; |
||||
using google::protobuf::io::ZeroCopyInputStream; |
||||
using google::protobuf::io::CodedInputStream; |
||||
using google::protobuf::io::ZeroCopyOutputStream; |
||||
using google::protobuf::io::CodedOutputStream; |
||||
using google::protobuf::io::IstreamInputStream; |
||||
using google::protobuf::Message; |
||||
|
||||
bool ReadProtoFromTextFile(const char* filename, Message* proto) { |
||||
std::ifstream fs(filename, std::ifstream::in); |
||||
CV_Assert(fs.is_open()); |
||||
IstreamInputStream input(&fs); |
||||
bool success = google::protobuf::TextFormat::Parse(&input, proto); |
||||
fs.close(); |
||||
return success; |
||||
} |
||||
|
||||
//
|
||||
//void WriteProtoToTextFile(const Message& proto, const char* filename) {
|
||||
// int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0644);
|
||||
// FileOutputStream* output = new FileOutputStream(fd);
|
||||
// CHECK(google::protobuf::TextFormat::Print(proto, output));
|
||||
// delete output;
|
||||
// close(fd);
|
||||
//}
|
||||
//
|
||||
bool ReadProtoFromBinaryFile(const char* filename, Message* proto) { |
||||
std::ifstream fs(filename, std::ifstream::in | std::ifstream::binary); |
||||
CV_Assert(fs.is_open()); |
||||
ZeroCopyInputStream* raw_input = new IstreamInputStream(&fs); |
||||
CodedInputStream* coded_input = new CodedInputStream(raw_input); |
||||
coded_input->SetTotalBytesLimit(kProtoReadBytesLimit, 536870912); |
||||
|
||||
bool success = proto->ParseFromCodedStream(coded_input); |
||||
|
||||
delete coded_input; |
||||
delete raw_input; |
||||
fs.close(); |
||||
return success; |
||||
} |
||||
//
|
||||
//void WriteProtoToBinaryFile(const Message& proto, const char* filename) {
|
||||
// fstream output(filename, ios::out | ios::trunc | ios::binary);
|
||||
// CHECK(proto.SerializeToOstream(&output));
|
||||
//}
|
||||
//
|
||||
//cv::Mat ReadImageToCVMat(const string& filename,
|
||||
// const int height, const int width, const bool is_color) {
|
||||
// cv::Mat cv_img;
|
||||
// int cv_read_flag = (is_color ? CV_LOAD_IMAGE_COLOR :
|
||||
// CV_LOAD_IMAGE_GRAYSCALE);
|
||||
// cv::Mat cv_img_origin = cv::imread(filename, cv_read_flag);
|
||||
// if (!cv_img_origin.data) {
|
||||
// LOG(ERROR) << "Could not open or find file " << filename;
|
||||
// return cv_img_origin;
|
||||
// }
|
||||
// if (height > 0 && width > 0) {
|
||||
// cv::resize(cv_img_origin, cv_img, cv::Size(width, height));
|
||||
// } else {
|
||||
// cv_img = cv_img_origin;
|
||||
// }
|
||||
// return cv_img;
|
||||
//}
|
||||
//
|
||||
//cv::Mat ReadImageToCVMat(const string& filename,
|
||||
// const int height, const int width) {
|
||||
// return ReadImageToCVMat(filename, height, width, true);
|
||||
//}
|
||||
//
|
||||
//cv::Mat ReadImageToCVMat(const string& filename,
|
||||
// const bool is_color) {
|
||||
// return ReadImageToCVMat(filename, 0, 0, is_color);
|
||||
//}
|
||||
//
|
||||
//cv::Mat ReadImageToCVMat(const string& filename) {
|
||||
// return ReadImageToCVMat(filename, 0, 0, true);
|
||||
//}
|
||||
//// Do the file extension and encoding match?
|
||||
//static bool matchExt(const std::string & fn,
|
||||
// std::string en) {
|
||||
// size_t p = fn.rfind('.');
|
||||
// std::string ext = p != fn.npos ? fn.substr(p) : fn;
|
||||
// std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
|
||||
// std::transform(en.begin(), en.end(), en.begin(), ::tolower);
|
||||
// if ( ext == en )
|
||||
// return true;
|
||||
// if ( en == "jpg" && ext == "jpeg" )
|
||||
// return true;
|
||||
// return false;
|
||||
//}
|
||||
//bool ReadImageToDatum(const string& filename, const int label,
|
||||
// const int height, const int width, const bool is_color,
|
||||
// const std::string & encoding, Datum* datum) {
|
||||
// cv::Mat cv_img = ReadImageToCVMat(filename, height, width, is_color);
|
||||
// if (cv_img.data) {
|
||||
// if (encoding.size()) {
|
||||
// if ( (cv_img.channels() == 3) == is_color && !height && !width &&
|
||||
// matchExt(filename, encoding) )
|
||||
// return ReadFileToDatum(filename, label, datum);
|
||||
// std::vector<uchar> buf;
|
||||
// cv::imencode("."+encoding, cv_img, buf);
|
||||
// datum->set_data(std::string(reinterpret_cast<char*>(&buf[0]),
|
||||
// buf.size()));
|
||||
// datum->set_label(label);
|
||||
// datum->set_encoded(true);
|
||||
// return true;
|
||||
// }
|
||||
// CVMatToDatum(cv_img, datum);
|
||||
// datum->set_label(label);
|
||||
// return true;
|
||||
// } else {
|
||||
// return false;
|
||||
// }
|
||||
//}
|
||||
//
|
||||
//bool ReadFileToDatum(const string& filename, const int label,
|
||||
// Datum* datum) {
|
||||
// std::streampos size;
|
||||
//
|
||||
// fstream file(filename.c_str(), ios::in|ios::binary|ios::ate);
|
||||
// if (file.is_open()) {
|
||||
// size = file.tellg();
|
||||
// std::string buffer(size, ' ');
|
||||
// file.seekg(0, ios::beg);
|
||||
// file.read(&buffer[0], size);
|
||||
// file.close();
|
||||
// datum->set_data(buffer);
|
||||
// datum->set_label(label);
|
||||
// datum->set_encoded(true);
|
||||
// return true;
|
||||
// } else {
|
||||
// return false;
|
||||
// }
|
||||
//}
|
||||
//
|
||||
//cv::Mat DecodeDatumToCVMatNative(const Datum& datum) {
|
||||
// cv::Mat cv_img;
|
||||
// CHECK(datum.encoded()) << "Datum not encoded";
|
||||
// const string& data = datum.data();
|
||||
// std::vector<char> vec_data(data.c_str(), data.c_str() + data.size());
|
||||
// cv_img = cv::imdecode(vec_data, -1);
|
||||
// if (!cv_img.data) {
|
||||
// LOG(ERROR) << "Could not decode datum ";
|
||||
// }
|
||||
// return cv_img;
|
||||
//}
|
||||
//cv::Mat DecodeDatumToCVMat(const Datum& datum, bool is_color) {
|
||||
// cv::Mat cv_img;
|
||||
// CHECK(datum.encoded()) << "Datum not encoded";
|
||||
// const string& data = datum.data();
|
||||
// std::vector<char> vec_data(data.c_str(), data.c_str() + data.size());
|
||||
// int cv_read_flag = (is_color ? CV_LOAD_IMAGE_COLOR :
|
||||
// CV_LOAD_IMAGE_GRAYSCALE);
|
||||
// cv_img = cv::imdecode(vec_data, cv_read_flag);
|
||||
// if (!cv_img.data) {
|
||||
// LOG(ERROR) << "Could not decode datum ";
|
||||
// }
|
||||
// return cv_img;
|
||||
//}
|
||||
//
|
||||
//// If Datum is encoded will decoded using DecodeDatumToCVMat and CVMatToDatum
|
||||
//// If Datum is not encoded will do nothing
|
||||
//bool DecodeDatumNative(Datum* datum) {
|
||||
// if (datum->encoded()) {
|
||||
// cv::Mat cv_img = DecodeDatumToCVMatNative((*datum));
|
||||
// CVMatToDatum(cv_img, datum);
|
||||
// return true;
|
||||
// } else {
|
||||
// return false;
|
||||
// }
|
||||
//}
|
||||
//bool DecodeDatum(Datum* datum, bool is_color) {
|
||||
// if (datum->encoded()) {
|
||||
// cv::Mat cv_img = DecodeDatumToCVMat((*datum), is_color);
|
||||
// CVMatToDatum(cv_img, datum);
|
||||
// return true;
|
||||
// } else {
|
||||
// return false;
|
||||
// }
|
||||
//}
|
||||
//
|
||||
//void CVMatToDatum(const cv::Mat& cv_img, Datum* datum) {
|
||||
// CHECK(cv_img.depth() == CV_8U) << "Image data type must be unsigned byte";
|
||||
// datum->set_channels(cv_img.channels());
|
||||
// datum->set_height(cv_img.rows);
|
||||
// datum->set_width(cv_img.cols);
|
||||
// datum->clear_data();
|
||||
// datum->clear_float_data();
|
||||
// datum->set_encoded(false);
|
||||
// int datum_channels = datum->channels();
|
||||
// int datum_height = datum->height();
|
||||
// int datum_width = datum->width();
|
||||
// int datum_size = datum_channels * datum_height * datum_width;
|
||||
// std::string buffer(datum_size, ' ');
|
||||
// for (int h = 0; h < datum_height; ++h) {
|
||||
// const uchar* ptr = cv_img.ptr<uchar>(h);
|
||||
// int img_index = 0;
|
||||
// for (int w = 0; w < datum_width; ++w) {
|
||||
// for (int c = 0; c < datum_channels; ++c) {
|
||||
// int datum_index = (c * datum_height + h) * datum_width + w;
|
||||
// buffer[datum_index] = static_cast<char>(ptr[img_index++]);
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// datum->set_data(buffer);
|
||||
//}
|
||||
|
||||
} // namespace caffe
|
||||
@ -0,0 +1,940 @@ |
||||
#include <google/protobuf/io/coded_stream.h> |
||||
#include <google/protobuf/io/zero_copy_stream_impl.h> |
||||
#include <google/protobuf/text_format.h> |
||||
|
||||
#include <map> |
||||
#include <string> |
||||
|
||||
#include "caffe/common.hpp" |
||||
#include "caffe.pb.h" |
||||
#include "caffe/util/io.hpp" |
||||
#include "caffe/util/upgrade_proto.hpp" |
||||
|
||||
namespace caffe { |
||||
|
||||
bool NetNeedsUpgrade(const NetParameter& net_param) { |
||||
return NetNeedsV0ToV1Upgrade(net_param) || NetNeedsV1ToV2Upgrade(net_param); |
||||
} |
||||
|
||||
bool NetNeedsV0ToV1Upgrade(const NetParameter& net_param) { |
||||
for (int i = 0; i < net_param.layers_size(); ++i) { |
||||
if (net_param.layers(i).has_layer()) { |
||||
return true; |
||||
} |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
bool NetNeedsV1ToV2Upgrade(const NetParameter& net_param) { |
||||
return net_param.layers_size() > 0; |
||||
} |
||||
|
||||
bool UpgradeV0Net(const NetParameter& v0_net_param_padding_layers, |
||||
NetParameter* net_param) { |
||||
// First upgrade padding layers to padded conv layers.
|
||||
NetParameter v0_net_param; |
||||
UpgradeV0PaddingLayers(v0_net_param_padding_layers, &v0_net_param); |
||||
// Now upgrade layer parameters.
|
||||
bool is_fully_compatible = true; |
||||
net_param->Clear(); |
||||
if (v0_net_param.has_name()) { |
||||
net_param->set_name(v0_net_param.name()); |
||||
} |
||||
for (int i = 0; i < v0_net_param.layers_size(); ++i) { |
||||
is_fully_compatible &= UpgradeV0LayerParameter(v0_net_param.layers(i), |
||||
net_param->add_layers()); |
||||
} |
||||
for (int i = 0; i < v0_net_param.input_size(); ++i) { |
||||
net_param->add_input(v0_net_param.input(i)); |
||||
} |
||||
for (int i = 0; i < v0_net_param.input_dim_size(); ++i) { |
||||
net_param->add_input_dim(v0_net_param.input_dim(i)); |
||||
} |
||||
if (v0_net_param.has_force_backward()) { |
||||
net_param->set_force_backward(v0_net_param.force_backward()); |
||||
} |
||||
return is_fully_compatible; |
||||
} |
||||
|
||||
void UpgradeV0PaddingLayers(const NetParameter& param, |
||||
NetParameter* param_upgraded_pad) { |
||||
// Copy everything other than the layers from the original param.
|
||||
param_upgraded_pad->Clear(); |
||||
param_upgraded_pad->CopyFrom(param); |
||||
param_upgraded_pad->clear_layers(); |
||||
// Figure out which layer each bottom blob comes from.
|
||||
map<string, int> blob_name_to_last_top_idx; |
||||
for (int i = 0; i < param.input_size(); ++i) { |
||||
const string& blob_name = param.input(i); |
||||
blob_name_to_last_top_idx[blob_name] = -1; |
||||
} |
||||
for (int i = 0; i < param.layers_size(); ++i) { |
||||
const V1LayerParameter& layer_connection = param.layers(i); |
||||
const V0LayerParameter& layer_param = layer_connection.layer(); |
||||
// Add the layer to the new net, unless it's a padding layer.
|
||||
if (layer_param.type() != "padding") { |
||||
param_upgraded_pad->add_layers()->CopyFrom(layer_connection); |
||||
} |
||||
for (int j = 0; j < layer_connection.bottom_size(); ++j) { |
||||
const string& blob_name = layer_connection.bottom(j); |
||||
if (blob_name_to_last_top_idx.find(blob_name) == |
||||
blob_name_to_last_top_idx.end()) { |
||||
LOG(FATAL) << "Unknown blob input " << blob_name << " to layer " << j; |
||||
} |
||||
const int top_idx = blob_name_to_last_top_idx[blob_name]; |
||||
if (top_idx == -1) { |
||||
continue; |
||||
} |
||||
const V1LayerParameter& source_layer = param.layers(top_idx); |
||||
if (source_layer.layer().type() == "padding") { |
||||
// This layer has a padding layer as input -- check that it is a conv
|
||||
// layer or a pooling layer and takes only one input. Also check that
|
||||
// the padding layer input has only one input and one output. Other
|
||||
// cases have undefined behavior in Caffe.
|
||||
CHECK((layer_param.type() == "conv") || (layer_param.type() == "pool")) |
||||
<< "Padding layer input to " |
||||
"non-convolutional / non-pooling layer type " |
||||
<< layer_param.type(); |
||||
CHECK_EQ(layer_connection.bottom_size(), 1) |
||||
<< "Conv Layer takes a single blob as input."; |
||||
CHECK_EQ(source_layer.bottom_size(), 1) |
||||
<< "Padding Layer takes a single blob as input."; |
||||
CHECK_EQ(source_layer.top_size(), 1) |
||||
<< "Padding Layer produces a single blob as output."; |
||||
int layer_index = param_upgraded_pad->layers_size() - 1; |
||||
param_upgraded_pad->mutable_layers(layer_index)->mutable_layer() |
||||
->set_pad(source_layer.layer().pad()); |
||||
param_upgraded_pad->mutable_layers(layer_index) |
||||
->set_bottom(j, source_layer.bottom(0)); |
||||
} |
||||
} |
||||
for (int j = 0; j < layer_connection.top_size(); ++j) { |
||||
const string& blob_name = layer_connection.top(j); |
||||
blob_name_to_last_top_idx[blob_name] = i; |
||||
} |
||||
} |
||||
} |
||||
|
||||
bool UpgradeV0LayerParameter(const V1LayerParameter& v0_layer_connection, |
||||
V1LayerParameter* layer_param) { |
||||
bool is_fully_compatible = true; |
||||
layer_param->Clear(); |
||||
for (int i = 0; i < v0_layer_connection.bottom_size(); ++i) { |
||||
layer_param->add_bottom(v0_layer_connection.bottom(i)); |
||||
} |
||||
for (int i = 0; i < v0_layer_connection.top_size(); ++i) { |
||||
layer_param->add_top(v0_layer_connection.top(i)); |
||||
} |
||||
if (v0_layer_connection.has_layer()) { |
||||
const V0LayerParameter& v0_layer_param = v0_layer_connection.layer(); |
||||
if (v0_layer_param.has_name()) { |
||||
layer_param->set_name(v0_layer_param.name()); |
||||
} |
||||
const string& type = v0_layer_param.type(); |
||||
if (v0_layer_param.has_type()) { |
||||
layer_param->set_type(UpgradeV0LayerType(type)); |
||||
} |
||||
for (int i = 0; i < v0_layer_param.blobs_size(); ++i) { |
||||
layer_param->add_blobs()->CopyFrom(v0_layer_param.blobs(i)); |
||||
} |
||||
for (int i = 0; i < v0_layer_param.blobs_lr_size(); ++i) { |
||||
layer_param->add_blobs_lr(v0_layer_param.blobs_lr(i)); |
||||
} |
||||
for (int i = 0; i < v0_layer_param.weight_decay_size(); ++i) { |
||||
layer_param->add_weight_decay(v0_layer_param.weight_decay(i)); |
||||
} |
||||
if (v0_layer_param.has_num_output()) { |
||||
if (type == "conv") { |
||||
layer_param->mutable_convolution_param()->set_num_output( |
||||
v0_layer_param.num_output()); |
||||
} else if (type == "innerproduct") { |
||||
layer_param->mutable_inner_product_param()->set_num_output( |
||||
v0_layer_param.num_output()); |
||||
} else { |
||||
LOG(ERROR) << "Unknown parameter num_output for layer type " << type; |
||||
is_fully_compatible = false; |
||||
} |
||||
} |
||||
if (v0_layer_param.has_biasterm()) { |
||||
if (type == "conv") { |
||||
layer_param->mutable_convolution_param()->set_bias_term( |
||||
v0_layer_param.biasterm()); |
||||
} else if (type == "innerproduct") { |
||||
layer_param->mutable_inner_product_param()->set_bias_term( |
||||
v0_layer_param.biasterm()); |
||||
} else { |
||||
LOG(ERROR) << "Unknown parameter biasterm for layer type " << type; |
||||
is_fully_compatible = false; |
||||
} |
||||
} |
||||
if (v0_layer_param.has_weight_filler()) { |
||||
if (type == "conv") { |
||||
layer_param->mutable_convolution_param()-> |
||||
mutable_weight_filler()->CopyFrom(v0_layer_param.weight_filler()); |
||||
} else if (type == "innerproduct") { |
||||
layer_param->mutable_inner_product_param()-> |
||||
mutable_weight_filler()->CopyFrom(v0_layer_param.weight_filler()); |
||||
} else { |
||||
LOG(ERROR) << "Unknown parameter weight_filler for layer type " << type; |
||||
is_fully_compatible = false; |
||||
} |
||||
} |
||||
if (v0_layer_param.has_bias_filler()) { |
||||
if (type == "conv") { |
||||
layer_param->mutable_convolution_param()-> |
||||
mutable_bias_filler()->CopyFrom(v0_layer_param.bias_filler()); |
||||
} else if (type == "innerproduct") { |
||||
layer_param->mutable_inner_product_param()-> |
||||
mutable_bias_filler()->CopyFrom(v0_layer_param.bias_filler()); |
||||
} else { |
||||
LOG(ERROR) << "Unknown parameter bias_filler for layer type " << type; |
||||
is_fully_compatible = false; |
||||
} |
||||
} |
||||
if (v0_layer_param.has_pad()) { |
||||
if (type == "conv") { |
||||
layer_param->mutable_convolution_param()->set_pad(v0_layer_param.pad()); |
||||
} else if (type == "pool") { |
||||
layer_param->mutable_pooling_param()->set_pad(v0_layer_param.pad()); |
||||
} else { |
||||
LOG(ERROR) << "Unknown parameter pad for layer type " << type; |
||||
is_fully_compatible = false; |
||||
} |
||||
} |
||||
if (v0_layer_param.has_kernelsize()) { |
||||
if (type == "conv") { |
||||
layer_param->mutable_convolution_param()->set_kernel_size( |
||||
v0_layer_param.kernelsize()); |
||||
} else if (type == "pool") { |
||||
layer_param->mutable_pooling_param()->set_kernel_size( |
||||
v0_layer_param.kernelsize()); |
||||
} else { |
||||
LOG(ERROR) << "Unknown parameter kernelsize for layer type " << type; |
||||
is_fully_compatible = false; |
||||
} |
||||
} |
||||
if (v0_layer_param.has_group()) { |
||||
if (type == "conv") { |
||||
layer_param->mutable_convolution_param()->set_group( |
||||
v0_layer_param.group()); |
||||
} else { |
||||
LOG(ERROR) << "Unknown parameter group for layer type " << type; |
||||
is_fully_compatible = false; |
||||
} |
||||
} |
||||
if (v0_layer_param.has_stride()) { |
||||
if (type == "conv") { |
||||
layer_param->mutable_convolution_param()->set_stride( |
||||
v0_layer_param.stride()); |
||||
} else if (type == "pool") { |
||||
layer_param->mutable_pooling_param()->set_stride( |
||||
v0_layer_param.stride()); |
||||
} else { |
||||
LOG(ERROR) << "Unknown parameter stride for layer type " << type; |
||||
is_fully_compatible = false; |
||||
} |
||||
} |
||||
if (v0_layer_param.has_pool()) { |
||||
if (type == "pool") { |
||||
V0LayerParameter_PoolMethod pool = v0_layer_param.pool(); |
||||
switch (pool) { |
||||
case V0LayerParameter_PoolMethod_MAX: |
||||
layer_param->mutable_pooling_param()->set_pool( |
||||
PoolingParameter_PoolMethod_MAX); |
||||
break; |
||||
case V0LayerParameter_PoolMethod_AVE: |
||||
layer_param->mutable_pooling_param()->set_pool( |
||||
PoolingParameter_PoolMethod_AVE); |
||||
break; |
||||
case V0LayerParameter_PoolMethod_STOCHASTIC: |
||||
layer_param->mutable_pooling_param()->set_pool( |
||||
PoolingParameter_PoolMethod_STOCHASTIC); |
||||
break; |
||||
default: |
||||
LOG(ERROR) << "Unknown pool method " << pool; |
||||
is_fully_compatible = false; |
||||
} |
||||
} else { |
||||
LOG(ERROR) << "Unknown parameter pool for layer type " << type; |
||||
is_fully_compatible = false; |
||||
} |
||||
} |
||||
if (v0_layer_param.has_dropout_ratio()) { |
||||
if (type == "dropout") { |
||||
layer_param->mutable_dropout_param()->set_dropout_ratio( |
||||
v0_layer_param.dropout_ratio()); |
||||
} else { |
||||
LOG(ERROR) << "Unknown parameter dropout_ratio for layer type " << type; |
||||
is_fully_compatible = false; |
||||
} |
||||
} |
||||
if (v0_layer_param.has_local_size()) { |
||||
if (type == "lrn") { |
||||
layer_param->mutable_lrn_param()->set_local_size( |
||||
v0_layer_param.local_size()); |
||||
} else { |
||||
LOG(ERROR) << "Unknown parameter local_size for layer type " << type; |
||||
is_fully_compatible = false; |
||||
} |
||||
} |
||||
if (v0_layer_param.has_alpha()) { |
||||
if (type == "lrn") { |
||||
layer_param->mutable_lrn_param()->set_alpha(v0_layer_param.alpha()); |
||||
} else { |
||||
LOG(ERROR) << "Unknown parameter alpha for layer type " << type; |
||||
is_fully_compatible = false; |
||||
} |
||||
} |
||||
if (v0_layer_param.has_beta()) { |
||||
if (type == "lrn") { |
||||
layer_param->mutable_lrn_param()->set_beta(v0_layer_param.beta()); |
||||
} else { |
||||
LOG(ERROR) << "Unknown parameter beta for layer type " << type; |
||||
is_fully_compatible = false; |
||||
} |
||||
} |
||||
if (v0_layer_param.has_k()) { |
||||
if (type == "lrn") { |
||||
layer_param->mutable_lrn_param()->set_k(v0_layer_param.k()); |
||||
} else { |
||||
LOG(ERROR) << "Unknown parameter k for layer type " << type; |
||||
is_fully_compatible = false; |
||||
} |
||||
} |
||||
if (v0_layer_param.has_source()) { |
||||
if (type == "data") { |
||||
layer_param->mutable_data_param()->set_source(v0_layer_param.source()); |
||||
} else if (type == "hdf5_data") { |
||||
layer_param->mutable_hdf5_data_param()->set_source( |
||||
v0_layer_param.source()); |
||||
} else if (type == "images") { |
||||
layer_param->mutable_image_data_param()->set_source( |
||||
v0_layer_param.source()); |
||||
} else if (type == "window_data") { |
||||
layer_param->mutable_window_data_param()->set_source( |
||||
v0_layer_param.source()); |
||||
} else if (type == "infogain_loss") { |
||||
layer_param->mutable_infogain_loss_param()->set_source( |
||||
v0_layer_param.source()); |
||||
} else { |
||||
LOG(ERROR) << "Unknown parameter source for layer type " << type; |
||||
is_fully_compatible = false; |
||||
} |
||||
} |
||||
if (v0_layer_param.has_scale()) { |
||||
layer_param->mutable_transform_param()-> |
||||
set_scale(v0_layer_param.scale()); |
||||
} |
||||
if (v0_layer_param.has_meanfile()) { |
||||
layer_param->mutable_transform_param()-> |
||||
set_mean_file(v0_layer_param.meanfile()); |
||||
} |
||||
if (v0_layer_param.has_batchsize()) { |
||||
if (type == "data") { |
||||
layer_param->mutable_data_param()->set_batch_size( |
||||
v0_layer_param.batchsize()); |
||||
} else if (type == "hdf5_data") { |
||||
layer_param->mutable_hdf5_data_param()->set_batch_size( |
||||
v0_layer_param.batchsize()); |
||||
} else if (type == "images") { |
||||
layer_param->mutable_image_data_param()->set_batch_size( |
||||
v0_layer_param.batchsize()); |
||||
} else if (type == "window_data") { |
||||
layer_param->mutable_window_data_param()->set_batch_size( |
||||
v0_layer_param.batchsize()); |
||||
} else { |
||||
LOG(ERROR) << "Unknown parameter batchsize for layer type " << type; |
||||
is_fully_compatible = false; |
||||
} |
||||
} |
||||
if (v0_layer_param.has_cropsize()) { |
||||
layer_param->mutable_transform_param()-> |
||||
set_crop_size(v0_layer_param.cropsize()); |
||||
} |
||||
if (v0_layer_param.has_mirror()) { |
||||
layer_param->mutable_transform_param()-> |
||||
set_mirror(v0_layer_param.mirror()); |
||||
} |
||||
if (v0_layer_param.has_rand_skip()) { |
||||
if (type == "data") { |
||||
layer_param->mutable_data_param()->set_rand_skip( |
||||
v0_layer_param.rand_skip()); |
||||
} else if (type == "images") { |
||||
layer_param->mutable_image_data_param()->set_rand_skip( |
||||
v0_layer_param.rand_skip()); |
||||
} else { |
||||
LOG(ERROR) << "Unknown parameter rand_skip for layer type " << type; |
||||
is_fully_compatible = false; |
||||
} |
||||
} |
||||
if (v0_layer_param.has_shuffle_images()) { |
||||
if (type == "images") { |
||||
layer_param->mutable_image_data_param()->set_shuffle( |
||||
v0_layer_param.shuffle_images()); |
||||
} else { |
||||
LOG(ERROR) << "Unknown parameter shuffle for layer type " << type; |
||||
is_fully_compatible = false; |
||||
} |
||||
} |
||||
if (v0_layer_param.has_new_height()) { |
||||
if (type == "images") { |
||||
layer_param->mutable_image_data_param()->set_new_height( |
||||
v0_layer_param.new_height()); |
||||
} else { |
||||
LOG(ERROR) << "Unknown parameter new_height for layer type " << type; |
||||
is_fully_compatible = false; |
||||
} |
||||
} |
||||
if (v0_layer_param.has_new_width()) { |
||||
if (type == "images") { |
||||
layer_param->mutable_image_data_param()->set_new_width( |
||||
v0_layer_param.new_width()); |
||||
} else { |
||||
LOG(ERROR) << "Unknown parameter new_width for layer type " << type; |
||||
is_fully_compatible = false; |
||||
} |
||||
} |
||||
if (v0_layer_param.has_concat_dim()) { |
||||
if (type == "concat") { |
||||
layer_param->mutable_concat_param()->set_concat_dim( |
||||
v0_layer_param.concat_dim()); |
||||
} else { |
||||
LOG(ERROR) << "Unknown parameter concat_dim for layer type " << type; |
||||
is_fully_compatible = false; |
||||
} |
||||
} |
||||
if (v0_layer_param.has_det_fg_threshold()) { |
||||
if (type == "window_data") { |
||||
layer_param->mutable_window_data_param()->set_fg_threshold( |
||||
v0_layer_param.det_fg_threshold()); |
||||
} else { |
||||
LOG(ERROR) << "Unknown parameter det_fg_threshold for layer type " |
||||
<< type; |
||||
is_fully_compatible = false; |
||||
} |
||||
} |
||||
if (v0_layer_param.has_det_bg_threshold()) { |
||||
if (type == "window_data") { |
||||
layer_param->mutable_window_data_param()->set_bg_threshold( |
||||
v0_layer_param.det_bg_threshold()); |
||||
} else { |
||||
LOG(ERROR) << "Unknown parameter det_bg_threshold for layer type " |
||||
<< type; |
||||
is_fully_compatible = false; |
||||
} |
||||
} |
||||
if (v0_layer_param.has_det_fg_fraction()) { |
||||
if (type == "window_data") { |
||||
layer_param->mutable_window_data_param()->set_fg_fraction( |
||||
v0_layer_param.det_fg_fraction()); |
||||
} else { |
||||
LOG(ERROR) << "Unknown parameter det_fg_fraction for layer type " |
||||
<< type; |
||||
is_fully_compatible = false; |
||||
} |
||||
} |
||||
if (v0_layer_param.has_det_context_pad()) { |
||||
if (type == "window_data") { |
||||
layer_param->mutable_window_data_param()->set_context_pad( |
||||
v0_layer_param.det_context_pad()); |
||||
} else { |
||||
LOG(ERROR) << "Unknown parameter det_context_pad for layer type " |
||||
<< type; |
||||
is_fully_compatible = false; |
||||
} |
||||
} |
||||
if (v0_layer_param.has_det_crop_mode()) { |
||||
if (type == "window_data") { |
||||
layer_param->mutable_window_data_param()->set_crop_mode( |
||||
v0_layer_param.det_crop_mode()); |
||||
} else { |
||||
LOG(ERROR) << "Unknown parameter det_crop_mode for layer type " |
||||
<< type; |
||||
is_fully_compatible = false; |
||||
} |
||||
} |
||||
if (v0_layer_param.has_hdf5_output_param()) { |
||||
if (type == "hdf5_output") { |
||||
layer_param->mutable_hdf5_output_param()->CopyFrom( |
||||
v0_layer_param.hdf5_output_param()); |
||||
} else { |
||||
LOG(ERROR) << "Unknown parameter hdf5_output_param for layer type " |
||||
<< type; |
||||
is_fully_compatible = false; |
||||
} |
||||
} |
||||
} |
||||
return is_fully_compatible; |
||||
} |
||||
|
||||
V1LayerParameter_LayerType UpgradeV0LayerType(const string& type) { |
||||
if (type == "accuracy") { |
||||
return V1LayerParameter_LayerType_ACCURACY; |
||||
} else if (type == "bnll") { |
||||
return V1LayerParameter_LayerType_BNLL; |
||||
} else if (type == "concat") { |
||||
return V1LayerParameter_LayerType_CONCAT; |
||||
} else if (type == "conv") { |
||||
return V1LayerParameter_LayerType_CONVOLUTION; |
||||
} else if (type == "data") { |
||||
return V1LayerParameter_LayerType_DATA; |
||||
} else if (type == "dropout") { |
||||
return V1LayerParameter_LayerType_DROPOUT; |
||||
} else if (type == "euclidean_loss") { |
||||
return V1LayerParameter_LayerType_EUCLIDEAN_LOSS; |
||||
} else if (type == "flatten") { |
||||
return V1LayerParameter_LayerType_FLATTEN; |
||||
} else if (type == "hdf5_data") { |
||||
return V1LayerParameter_LayerType_HDF5_DATA; |
||||
} else if (type == "hdf5_output") { |
||||
return V1LayerParameter_LayerType_HDF5_OUTPUT; |
||||
} else if (type == "im2col") { |
||||
return V1LayerParameter_LayerType_IM2COL; |
||||
} else if (type == "images") { |
||||
return V1LayerParameter_LayerType_IMAGE_DATA; |
||||
} else if (type == "infogain_loss") { |
||||
return V1LayerParameter_LayerType_INFOGAIN_LOSS; |
||||
} else if (type == "innerproduct") { |
||||
return V1LayerParameter_LayerType_INNER_PRODUCT; |
||||
} else if (type == "lrn") { |
||||
return V1LayerParameter_LayerType_LRN; |
||||
} else if (type == "multinomial_logistic_loss") { |
||||
return V1LayerParameter_LayerType_MULTINOMIAL_LOGISTIC_LOSS; |
||||
} else if (type == "pool") { |
||||
return V1LayerParameter_LayerType_POOLING; |
||||
} else if (type == "relu") { |
||||
return V1LayerParameter_LayerType_RELU; |
||||
} else if (type == "sigmoid") { |
||||
return V1LayerParameter_LayerType_SIGMOID; |
||||
} else if (type == "softmax") { |
||||
return V1LayerParameter_LayerType_SOFTMAX; |
||||
} else if (type == "softmax_loss") { |
||||
return V1LayerParameter_LayerType_SOFTMAX_LOSS; |
||||
} else if (type == "split") { |
||||
return V1LayerParameter_LayerType_SPLIT; |
||||
} else if (type == "tanh") { |
||||
return V1LayerParameter_LayerType_TANH; |
||||
} else if (type == "window_data") { |
||||
return V1LayerParameter_LayerType_WINDOW_DATA; |
||||
} else { |
||||
LOG(FATAL) << "Unknown layer name: " << type; |
||||
return V1LayerParameter_LayerType_NONE; |
||||
} |
||||
} |
||||
|
||||
bool NetNeedsDataUpgrade(const NetParameter& net_param) { |
||||
for (int i = 0; i < net_param.layers_size(); ++i) { |
||||
if (net_param.layers(i).type() == V1LayerParameter_LayerType_DATA) { |
||||
DataParameter layer_param = net_param.layers(i).data_param(); |
||||
if (layer_param.has_scale()) { return true; } |
||||
if (layer_param.has_mean_file()) { return true; } |
||||
if (layer_param.has_crop_size()) { return true; } |
||||
if (layer_param.has_mirror()) { return true; } |
||||
} |
||||
if (net_param.layers(i).type() == V1LayerParameter_LayerType_IMAGE_DATA) { |
||||
ImageDataParameter layer_param = net_param.layers(i).image_data_param(); |
||||
if (layer_param.has_scale()) { return true; } |
||||
if (layer_param.has_mean_file()) { return true; } |
||||
if (layer_param.has_crop_size()) { return true; } |
||||
if (layer_param.has_mirror()) { return true; } |
||||
} |
||||
if (net_param.layers(i).type() == V1LayerParameter_LayerType_WINDOW_DATA) { |
||||
WindowDataParameter layer_param = net_param.layers(i).window_data_param(); |
||||
if (layer_param.has_scale()) { return true; } |
||||
if (layer_param.has_mean_file()) { return true; } |
||||
if (layer_param.has_crop_size()) { return true; } |
||||
if (layer_param.has_mirror()) { return true; } |
||||
} |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
#define CONVERT_LAYER_TRANSFORM_PARAM(TYPE, Name, param_name) \ |
||||
do { \
|
||||
if (net_param->layers(i).type() == V1LayerParameter_LayerType_##TYPE) { \
|
||||
Name##Parameter* layer_param = \
|
||||
net_param->mutable_layers(i)->mutable_##param_name##_param(); \
|
||||
TransformationParameter* transform_param = \
|
||||
net_param->mutable_layers(i)->mutable_transform_param(); \
|
||||
if (layer_param->has_scale()) { \
|
||||
transform_param->set_scale(layer_param->scale()); \
|
||||
layer_param->clear_scale(); \
|
||||
} \
|
||||
if (layer_param->has_mean_file()) { \
|
||||
transform_param->set_mean_file(layer_param->mean_file()); \
|
||||
layer_param->clear_mean_file(); \
|
||||
} \
|
||||
if (layer_param->has_crop_size()) { \
|
||||
transform_param->set_crop_size(layer_param->crop_size()); \
|
||||
layer_param->clear_crop_size(); \
|
||||
} \
|
||||
if (layer_param->has_mirror()) { \
|
||||
transform_param->set_mirror(layer_param->mirror()); \
|
||||
layer_param->clear_mirror(); \
|
||||
} \
|
||||
} \
|
||||
} while (0) |
||||
|
||||
void UpgradeNetDataTransformation(NetParameter* net_param) { |
||||
for (int i = 0; i < net_param->layers_size(); ++i) { |
||||
CONVERT_LAYER_TRANSFORM_PARAM(DATA, Data, data); |
||||
CONVERT_LAYER_TRANSFORM_PARAM(IMAGE_DATA, ImageData, image_data); |
||||
CONVERT_LAYER_TRANSFORM_PARAM(WINDOW_DATA, WindowData, window_data); |
||||
} |
||||
} |
||||
|
||||
bool UpgradeNetAsNeeded(const string& param_file, NetParameter* param) { |
||||
bool success = true; |
||||
if (NetNeedsV0ToV1Upgrade(*param)) { |
||||
// NetParameter was specified using the old style (V0LayerParameter); try to
|
||||
// upgrade it.
|
||||
LOG(ERROR) << "Attempting to upgrade input file specified using deprecated " |
||||
<< "V0LayerParameter: " << param_file; |
||||
NetParameter original_param(*param); |
||||
if (!UpgradeV0Net(original_param, param)) { |
||||
success = false; |
||||
LOG(ERROR) << "Warning: had one or more problems upgrading " |
||||
<< "V0NetParameter to NetParameter (see above); continuing anyway."; |
||||
} else { |
||||
LOG(INFO) << "Successfully upgraded file specified using deprecated " |
||||
<< "V0LayerParameter"; |
||||
} |
||||
LOG(ERROR) << "Note that future Caffe releases will not support " |
||||
<< "V0NetParameter; use ./build/tools/upgrade_net_proto_text for " |
||||
<< "prototxt and ./build/tools/upgrade_net_proto_binary for model " |
||||
<< "weights upgrade this and any other net protos to the new format."; |
||||
} |
||||
// NetParameter uses old style data transformation fields; try to upgrade it.
|
||||
if (NetNeedsDataUpgrade(*param)) { |
||||
LOG(ERROR) << "Attempting to upgrade input file specified using deprecated " |
||||
<< "transformation parameters: " << param_file; |
||||
UpgradeNetDataTransformation(param); |
||||
LOG(INFO) << "Successfully upgraded file specified using deprecated " |
||||
<< "data transformation parameters."; |
||||
LOG(ERROR) << "Note that future Caffe releases will only support " |
||||
<< "transform_param messages for transformation fields."; |
||||
} |
||||
if (NetNeedsV1ToV2Upgrade(*param)) { |
||||
LOG(ERROR) << "Attempting to upgrade input file specified using deprecated " |
||||
<< "V1LayerParameter: " << param_file; |
||||
NetParameter original_param(*param); |
||||
if (!UpgradeV1Net(original_param, param)) { |
||||
success = false; |
||||
LOG(ERROR) << "Warning: had one or more problems upgrading " |
||||
<< "V1LayerParameter (see above); continuing anyway."; |
||||
} else { |
||||
LOG(INFO) << "Successfully upgraded file specified using deprecated " |
||||
<< "V1LayerParameter"; |
||||
} |
||||
} |
||||
return success; |
||||
} |
||||
|
||||
bool UpgradeV1Net(const NetParameter& v1_net_param, NetParameter* net_param) { |
||||
bool is_fully_compatible = true; |
||||
if (v1_net_param.layer_size() > 0) { |
||||
LOG(ERROR) << "Input NetParameter to be upgraded already specifies 'layer' " |
||||
<< "fields; these will be ignored for the upgrade."; |
||||
is_fully_compatible = false; |
||||
} |
||||
net_param->CopyFrom(v1_net_param); |
||||
net_param->clear_layers(); |
||||
net_param->clear_layer(); |
||||
for (int i = 0; i < v1_net_param.layers_size(); ++i) { |
||||
if (!UpgradeV1LayerParameter(v1_net_param.layers(i), |
||||
net_param->add_layer())) { |
||||
LOG(ERROR) << "Upgrade of input layer " << i << " failed."; |
||||
is_fully_compatible = false; |
||||
} |
||||
} |
||||
return is_fully_compatible; |
||||
} |
||||
|
||||
bool UpgradeV1LayerParameter(const V1LayerParameter& v1_layer_param, |
||||
LayerParameter* layer_param) { |
||||
layer_param->Clear(); |
||||
bool is_fully_compatible = true; |
||||
for (int i = 0; i < v1_layer_param.bottom_size(); ++i) { |
||||
layer_param->add_bottom(v1_layer_param.bottom(i)); |
||||
} |
||||
for (int i = 0; i < v1_layer_param.top_size(); ++i) { |
||||
layer_param->add_top(v1_layer_param.top(i)); |
||||
} |
||||
if (v1_layer_param.has_name()) { |
||||
layer_param->set_name(v1_layer_param.name()); |
||||
} |
||||
for (int i = 0; i < v1_layer_param.include_size(); ++i) { |
||||
layer_param->add_include()->CopyFrom(v1_layer_param.include(i)); |
||||
} |
||||
for (int i = 0; i < v1_layer_param.exclude_size(); ++i) { |
||||
layer_param->add_exclude()->CopyFrom(v1_layer_param.exclude(i)); |
||||
} |
||||
if (v1_layer_param.has_type()) { |
||||
layer_param->set_type(UpgradeV1LayerType(v1_layer_param.type())); |
||||
} |
||||
for (int i = 0; i < v1_layer_param.blobs_size(); ++i) { |
||||
layer_param->add_blobs()->CopyFrom(v1_layer_param.blobs(i)); |
||||
} |
||||
for (int i = 0; i < v1_layer_param.param_size(); ++i) { |
||||
while (layer_param->param_size() <= i) { layer_param->add_param(); } |
||||
layer_param->mutable_param(i)->set_name(v1_layer_param.param(i)); |
||||
} |
||||
ParamSpec_DimCheckMode mode; |
||||
for (int i = 0; i < v1_layer_param.blob_share_mode_size(); ++i) { |
||||
while (layer_param->param_size() <= i) { layer_param->add_param(); } |
||||
switch (v1_layer_param.blob_share_mode(i)) { |
||||
case V1LayerParameter_DimCheckMode_STRICT: |
||||
mode = ParamSpec_DimCheckMode_STRICT; |
||||
break; |
||||
case V1LayerParameter_DimCheckMode_PERMISSIVE: |
||||
mode = ParamSpec_DimCheckMode_PERMISSIVE; |
||||
break; |
||||
default: |
||||
LOG(FATAL) << "Unknown blob_share_mode: " |
||||
<< v1_layer_param.blob_share_mode(i); |
||||
break; |
||||
} |
||||
layer_param->mutable_param(i)->set_share_mode(mode); |
||||
} |
||||
for (int i = 0; i < v1_layer_param.blobs_lr_size(); ++i) { |
||||
while (layer_param->param_size() <= i) { layer_param->add_param(); } |
||||
layer_param->mutable_param(i)->set_lr_mult(v1_layer_param.blobs_lr(i)); |
||||
} |
||||
for (int i = 0; i < v1_layer_param.weight_decay_size(); ++i) { |
||||
while (layer_param->param_size() <= i) { layer_param->add_param(); } |
||||
layer_param->mutable_param(i)->set_decay_mult( |
||||
v1_layer_param.weight_decay(i)); |
||||
} |
||||
for (int i = 0; i < v1_layer_param.loss_weight_size(); ++i) { |
||||
layer_param->add_loss_weight(v1_layer_param.loss_weight(i)); |
||||
} |
||||
if (v1_layer_param.has_accuracy_param()) { |
||||
layer_param->mutable_accuracy_param()->CopyFrom( |
||||
v1_layer_param.accuracy_param()); |
||||
} |
||||
if (v1_layer_param.has_argmax_param()) { |
||||
layer_param->mutable_argmax_param()->CopyFrom( |
||||
v1_layer_param.argmax_param()); |
||||
} |
||||
if (v1_layer_param.has_concat_param()) { |
||||
layer_param->mutable_concat_param()->CopyFrom( |
||||
v1_layer_param.concat_param()); |
||||
} |
||||
if (v1_layer_param.has_contrastive_loss_param()) { |
||||
layer_param->mutable_contrastive_loss_param()->CopyFrom( |
||||
v1_layer_param.contrastive_loss_param()); |
||||
} |
||||
if (v1_layer_param.has_convolution_param()) { |
||||
layer_param->mutable_convolution_param()->CopyFrom( |
||||
v1_layer_param.convolution_param()); |
||||
} |
||||
if (v1_layer_param.has_data_param()) { |
||||
layer_param->mutable_data_param()->CopyFrom( |
||||
v1_layer_param.data_param()); |
||||
} |
||||
if (v1_layer_param.has_dropout_param()) { |
||||
layer_param->mutable_dropout_param()->CopyFrom( |
||||
v1_layer_param.dropout_param()); |
||||
} |
||||
if (v1_layer_param.has_dummy_data_param()) { |
||||
layer_param->mutable_dummy_data_param()->CopyFrom( |
||||
v1_layer_param.dummy_data_param()); |
||||
} |
||||
if (v1_layer_param.has_eltwise_param()) { |
||||
layer_param->mutable_eltwise_param()->CopyFrom( |
||||
v1_layer_param.eltwise_param()); |
||||
} |
||||
if (v1_layer_param.has_exp_param()) { |
||||
layer_param->mutable_exp_param()->CopyFrom( |
||||
v1_layer_param.exp_param()); |
||||
} |
||||
if (v1_layer_param.has_hdf5_data_param()) { |
||||
layer_param->mutable_hdf5_data_param()->CopyFrom( |
||||
v1_layer_param.hdf5_data_param()); |
||||
} |
||||
if (v1_layer_param.has_hdf5_output_param()) { |
||||
layer_param->mutable_hdf5_output_param()->CopyFrom( |
||||
v1_layer_param.hdf5_output_param()); |
||||
} |
||||
if (v1_layer_param.has_hinge_loss_param()) { |
||||
layer_param->mutable_hinge_loss_param()->CopyFrom( |
||||
v1_layer_param.hinge_loss_param()); |
||||
} |
||||
if (v1_layer_param.has_image_data_param()) { |
||||
layer_param->mutable_image_data_param()->CopyFrom( |
||||
v1_layer_param.image_data_param()); |
||||
} |
||||
if (v1_layer_param.has_infogain_loss_param()) { |
||||
layer_param->mutable_infogain_loss_param()->CopyFrom( |
||||
v1_layer_param.infogain_loss_param()); |
||||
} |
||||
if (v1_layer_param.has_inner_product_param()) { |
||||
layer_param->mutable_inner_product_param()->CopyFrom( |
||||
v1_layer_param.inner_product_param()); |
||||
} |
||||
if (v1_layer_param.has_lrn_param()) { |
||||
layer_param->mutable_lrn_param()->CopyFrom( |
||||
v1_layer_param.lrn_param()); |
||||
} |
||||
if (v1_layer_param.has_memory_data_param()) { |
||||
layer_param->mutable_memory_data_param()->CopyFrom( |
||||
v1_layer_param.memory_data_param()); |
||||
} |
||||
if (v1_layer_param.has_mvn_param()) { |
||||
layer_param->mutable_mvn_param()->CopyFrom( |
||||
v1_layer_param.mvn_param()); |
||||
} |
||||
if (v1_layer_param.has_pooling_param()) { |
||||
layer_param->mutable_pooling_param()->CopyFrom( |
||||
v1_layer_param.pooling_param()); |
||||
} |
||||
if (v1_layer_param.has_power_param()) { |
||||
layer_param->mutable_power_param()->CopyFrom( |
||||
v1_layer_param.power_param()); |
||||
} |
||||
if (v1_layer_param.has_relu_param()) { |
||||
layer_param->mutable_relu_param()->CopyFrom( |
||||
v1_layer_param.relu_param()); |
||||
} |
||||
if (v1_layer_param.has_sigmoid_param()) { |
||||
layer_param->mutable_sigmoid_param()->CopyFrom( |
||||
v1_layer_param.sigmoid_param()); |
||||
} |
||||
if (v1_layer_param.has_softmax_param()) { |
||||
layer_param->mutable_softmax_param()->CopyFrom( |
||||
v1_layer_param.softmax_param()); |
||||
} |
||||
if (v1_layer_param.has_slice_param()) { |
||||
layer_param->mutable_slice_param()->CopyFrom( |
||||
v1_layer_param.slice_param()); |
||||
} |
||||
if (v1_layer_param.has_tanh_param()) { |
||||
layer_param->mutable_tanh_param()->CopyFrom( |
||||
v1_layer_param.tanh_param()); |
||||
} |
||||
if (v1_layer_param.has_threshold_param()) { |
||||
layer_param->mutable_threshold_param()->CopyFrom( |
||||
v1_layer_param.threshold_param()); |
||||
} |
||||
if (v1_layer_param.has_window_data_param()) { |
||||
layer_param->mutable_window_data_param()->CopyFrom( |
||||
v1_layer_param.window_data_param()); |
||||
} |
||||
if (v1_layer_param.has_transform_param()) { |
||||
layer_param->mutable_transform_param()->CopyFrom( |
||||
v1_layer_param.transform_param()); |
||||
} |
||||
if (v1_layer_param.has_loss_param()) { |
||||
layer_param->mutable_loss_param()->CopyFrom( |
||||
v1_layer_param.loss_param()); |
||||
} |
||||
if (v1_layer_param.has_layer()) { |
||||
LOG(ERROR) << "Input NetParameter has V0 layer -- ignoring."; |
||||
is_fully_compatible = false; |
||||
} |
||||
return is_fully_compatible; |
||||
} |
||||
|
||||
const char* UpgradeV1LayerType(const V1LayerParameter_LayerType type) { |
||||
switch (type) { |
||||
case V1LayerParameter_LayerType_NONE: |
||||
return ""; |
||||
case V1LayerParameter_LayerType_ABSVAL: |
||||
return "AbsVal"; |
||||
case V1LayerParameter_LayerType_ACCURACY: |
||||
return "Accuracy"; |
||||
case V1LayerParameter_LayerType_ARGMAX: |
||||
return "ArgMax"; |
||||
case V1LayerParameter_LayerType_BNLL: |
||||
return "BNLL"; |
||||
case V1LayerParameter_LayerType_CONCAT: |
||||
return "Concat"; |
||||
case V1LayerParameter_LayerType_CONTRASTIVE_LOSS: |
||||
return "ContrastiveLoss"; |
||||
case V1LayerParameter_LayerType_CONVOLUTION: |
||||
return "Convolution"; |
||||
case V1LayerParameter_LayerType_DECONVOLUTION: |
||||
return "Deconvolution"; |
||||
case V1LayerParameter_LayerType_DATA: |
||||
return "Data"; |
||||
case V1LayerParameter_LayerType_DROPOUT: |
||||
return "Dropout"; |
||||
case V1LayerParameter_LayerType_DUMMY_DATA: |
||||
return "DummyData"; |
||||
case V1LayerParameter_LayerType_EUCLIDEAN_LOSS: |
||||
return "EuclideanLoss"; |
||||
case V1LayerParameter_LayerType_ELTWISE: |
||||
return "Eltwise"; |
||||
case V1LayerParameter_LayerType_EXP: |
||||
return "Exp"; |
||||
case V1LayerParameter_LayerType_FLATTEN: |
||||
return "Flatten"; |
||||
case V1LayerParameter_LayerType_HDF5_DATA: |
||||
return "HDF5Data"; |
||||
case V1LayerParameter_LayerType_HDF5_OUTPUT: |
||||
return "HDF5Output"; |
||||
case V1LayerParameter_LayerType_HINGE_LOSS: |
||||
return "HingeLoss"; |
||||
case V1LayerParameter_LayerType_IM2COL: |
||||
return "Im2col"; |
||||
case V1LayerParameter_LayerType_IMAGE_DATA: |
||||
return "ImageData"; |
||||
case V1LayerParameter_LayerType_INFOGAIN_LOSS: |
||||
return "InfogainLoss"; |
||||
case V1LayerParameter_LayerType_INNER_PRODUCT: |
||||
return "InnerProduct"; |
||||
case V1LayerParameter_LayerType_LRN: |
||||
return "LRN"; |
||||
case V1LayerParameter_LayerType_MEMORY_DATA: |
||||
return "MemoryData"; |
||||
case V1LayerParameter_LayerType_MULTINOMIAL_LOGISTIC_LOSS: |
||||
return "MultinomialLogisticLoss"; |
||||
case V1LayerParameter_LayerType_MVN: |
||||
return "MVN"; |
||||
case V1LayerParameter_LayerType_POOLING: |
||||
return "Pooling"; |
||||
case V1LayerParameter_LayerType_POWER: |
||||
return "Power"; |
||||
case V1LayerParameter_LayerType_RELU: |
||||
return "ReLU"; |
||||
case V1LayerParameter_LayerType_SIGMOID: |
||||
return "Sigmoid"; |
||||
case V1LayerParameter_LayerType_SIGMOID_CROSS_ENTROPY_LOSS: |
||||
return "SigmoidCrossEntropyLoss"; |
||||
case V1LayerParameter_LayerType_SILENCE: |
||||
return "Silence"; |
||||
case V1LayerParameter_LayerType_SOFTMAX: |
||||
return "Softmax"; |
||||
case V1LayerParameter_LayerType_SOFTMAX_LOSS: |
||||
return "SoftmaxWithLoss"; |
||||
case V1LayerParameter_LayerType_SPLIT: |
||||
return "Split"; |
||||
case V1LayerParameter_LayerType_SLICE: |
||||
return "Slice"; |
||||
case V1LayerParameter_LayerType_TANH: |
||||
return "TanH"; |
||||
case V1LayerParameter_LayerType_WINDOW_DATA: |
||||
return "WindowData"; |
||||
case V1LayerParameter_LayerType_THRESHOLD: |
||||
return "Threshold"; |
||||
default: |
||||
LOG(FATAL) << "Unknown V1LayerParameter layer type: " << type; |
||||
return ""; |
||||
} |
||||
} |
||||
|
||||
void ReadNetParamsFromTextFileOrDie(const string& param_file, |
||||
NetParameter* param) { |
||||
CHECK(ReadProtoFromTextFile(param_file, param)) |
||||
<< "Failed to parse NetParameter file: " << param_file; |
||||
UpgradeNetAsNeeded(param_file, param); |
||||
} |
||||
|
||||
void ReadNetParamsFromBinaryFileOrDie(const string& param_file, |
||||
NetParameter* param) { |
||||
CHECK(ReadProtoFromBinaryFile(param_file, param)) |
||||
<< "Failed to parse NetParameter file: " << param_file; |
||||
UpgradeNetAsNeeded(param_file, param); |
||||
} |
||||
|
||||
} // namespace caffe
|
||||
@ -0,0 +1,152 @@ |
||||
#ifndef CAFFE_UTIL_IO_H_ |
||||
#define CAFFE_UTIL_IO_H_ |
||||
|
||||
#include <opencv2/core.hpp> |
||||
#include <iostream> |
||||
#define CHECK(cond) if (!(cond)) std::cerr << #cond |
||||
#define CHECK_EQ(a, b) if (!((a) == (b))) std::cerr << #a << "!=" << #b |
||||
#define LOG(WHERE) std::cerr |
||||
|
||||
//#include <unistd.h>
|
||||
#include <string> |
||||
#include <stdio.h> |
||||
|
||||
#include <google/protobuf/message.h> |
||||
//#include "hdf5.h"
|
||||
//#include "hdf5_hl.h"
|
||||
|
||||
//#include "caffe/blob.hpp"
|
||||
#include "caffe/common.hpp" |
||||
#include "caffe.pb.h" |
||||
|
||||
#define HDF5_NUM_DIMS 4 |
||||
|
||||
namespace caffe { |
||||
|
||||
using ::google::protobuf::Message; |
||||
|
||||
//inline void MakeTempFilename(string* temp_filename) {
|
||||
// temp_filename->clear();
|
||||
// *temp_filename = "/tmp/caffe_test.XXXXXX";
|
||||
// char* temp_filename_cstr = new char[temp_filename->size() + 1];
|
||||
// // NOLINT_NEXT_LINE(runtime/printf)
|
||||
// strcpy(temp_filename_cstr, temp_filename->c_str());
|
||||
// int fd = mkstemp(temp_filename_cstr);
|
||||
// CHECK_GE(fd, 0) << "Failed to open a temporary file at: " << *temp_filename;
|
||||
// close(fd);
|
||||
// *temp_filename = temp_filename_cstr;
|
||||
// delete[] temp_filename_cstr;
|
||||
//}
|
||||
//
|
||||
//inline void MakeTempDir(string* temp_dirname) {
|
||||
// temp_dirname->clear();
|
||||
// *temp_dirname = "/tmp/caffe_test.XXXXXX";
|
||||
// char* temp_dirname_cstr = new char[temp_dirname->size() + 1];
|
||||
// // NOLINT_NEXT_LINE(runtime/printf)
|
||||
// strcpy(temp_dirname_cstr, temp_dirname->c_str());
|
||||
// char* mkdtemp_result = mkdtemp(temp_dirname_cstr);
|
||||
// CHECK(mkdtemp_result != NULL)
|
||||
// << "Failed to create a temporary directory at: " << *temp_dirname;
|
||||
// *temp_dirname = temp_dirname_cstr;
|
||||
// delete[] temp_dirname_cstr;
|
||||
//}
|
||||
|
||||
bool ReadProtoFromTextFile(const char* filename, Message* proto); |
||||
|
||||
inline bool ReadProtoFromTextFile(const string& filename, Message* proto) { |
||||
return ReadProtoFromTextFile(filename.c_str(), proto); |
||||
} |
||||
|
||||
inline void ReadProtoFromTextFileOrDie(const char* filename, Message* proto) { |
||||
CHECK(ReadProtoFromTextFile(filename, proto)); |
||||
} |
||||
|
||||
inline void ReadProtoFromTextFileOrDie(const string& filename, Message* proto) { |
||||
ReadProtoFromTextFileOrDie(filename.c_str(), proto); |
||||
} |
||||
|
||||
void WriteProtoToTextFile(const Message& proto, const char* filename); |
||||
inline void WriteProtoToTextFile(const Message& proto, const string& filename) { |
||||
WriteProtoToTextFile(proto, filename.c_str()); |
||||
} |
||||
|
||||
bool ReadProtoFromBinaryFile(const char* filename, Message* proto); |
||||
|
||||
inline bool ReadProtoFromBinaryFile(const string& filename, Message* proto) { |
||||
return ReadProtoFromBinaryFile(filename.c_str(), proto); |
||||
} |
||||
|
||||
inline void ReadProtoFromBinaryFileOrDie(const char* filename, Message* proto) { |
||||
CHECK(ReadProtoFromBinaryFile(filename, proto)); |
||||
} |
||||
|
||||
inline void ReadProtoFromBinaryFileOrDie(const string& filename, |
||||
Message* proto) { |
||||
ReadProtoFromBinaryFileOrDie(filename.c_str(), proto); |
||||
} |
||||
|
||||
|
||||
void WriteProtoToBinaryFile(const Message& proto, const char* filename); |
||||
inline void WriteProtoToBinaryFile( |
||||
const Message& proto, const string& filename) { |
||||
WriteProtoToBinaryFile(proto, filename.c_str()); |
||||
} |
||||
|
||||
bool ReadFileToDatum(const string& filename, const int label, Datum* datum); |
||||
|
||||
inline bool ReadFileToDatum(const string& filename, Datum* datum) { |
||||
return ReadFileToDatum(filename, -1, datum); |
||||
} |
||||
|
||||
bool ReadImageToDatum(const string& filename, const int label, |
||||
const int height, const int width, const bool is_color, |
||||
const std::string & encoding, Datum* datum); |
||||
|
||||
inline bool ReadImageToDatum(const string& filename, const int label, |
||||
const int height, const int width, const bool is_color, Datum* datum) { |
||||
return ReadImageToDatum(filename, label, height, width, is_color, |
||||
"", datum); |
||||
} |
||||
|
||||
inline bool ReadImageToDatum(const string& filename, const int label, |
||||
const int height, const int width, Datum* datum) { |
||||
return ReadImageToDatum(filename, label, height, width, true, datum); |
||||
} |
||||
|
||||
inline bool ReadImageToDatum(const string& filename, const int label, |
||||
const bool is_color, Datum* datum) { |
||||
return ReadImageToDatum(filename, label, 0, 0, is_color, datum); |
||||
} |
||||
|
||||
inline bool ReadImageToDatum(const string& filename, const int label, |
||||
Datum* datum) { |
||||
return ReadImageToDatum(filename, label, 0, 0, true, datum); |
||||
} |
||||
|
||||
inline bool ReadImageToDatum(const string& filename, const int label, |
||||
const std::string & encoding, Datum* datum) { |
||||
return ReadImageToDatum(filename, label, 0, 0, true, encoding, datum); |
||||
} |
||||
|
||||
bool DecodeDatumNative(Datum* datum); |
||||
bool DecodeDatum(Datum* datum, bool is_color); |
||||
|
||||
cv::Mat ReadImageToCVMat(const string& filename, |
||||
const int height, const int width, const bool is_color); |
||||
|
||||
cv::Mat ReadImageToCVMat(const string& filename, |
||||
const int height, const int width); |
||||
|
||||
cv::Mat ReadImageToCVMat(const string& filename, |
||||
const bool is_color); |
||||
|
||||
cv::Mat ReadImageToCVMat(const string& filename); |
||||
|
||||
cv::Mat DecodeDatumToCVMatNative(const Datum& datum); |
||||
cv::Mat DecodeDatumToCVMat(const Datum& datum, bool is_color); |
||||
|
||||
void CVMatToDatum(const cv::Mat& cv_img, Datum* datum); |
||||
|
||||
} // namespace caffe
|
||||
|
||||
#endif // CAFFE_UTIL_IO_H_
|
||||
@ -0,0 +1,64 @@ |
||||
#ifndef CAFFE_UTIL_UPGRADE_PROTO_H_ |
||||
#define CAFFE_UTIL_UPGRADE_PROTO_H_ |
||||
|
||||
#include <string> |
||||
#include "caffe/common.hpp" |
||||
#include "caffe.pb.h" |
||||
|
||||
namespace caffe { |
||||
|
||||
// Return true iff the net is not the current version.
|
||||
bool NetNeedsUpgrade(const NetParameter& net_param); |
||||
|
||||
// Return true iff any layer contains parameters specified using
|
||||
// deprecated V0LayerParameter.
|
||||
bool NetNeedsV0ToV1Upgrade(const NetParameter& net_param); |
||||
|
||||
// Perform all necessary transformations to upgrade a V0NetParameter into a
|
||||
// NetParameter (including upgrading padding layers and LayerParameters).
|
||||
bool UpgradeV0Net(const NetParameter& v0_net_param, NetParameter* net_param); |
||||
|
||||
// Upgrade NetParameter with padding layers to pad-aware conv layers.
|
||||
// For any padding layer, remove it and put its pad parameter in any layers
|
||||
// taking its top blob as input.
|
||||
// Error if any of these above layers are not-conv layers.
|
||||
void UpgradeV0PaddingLayers(const NetParameter& param, |
||||
NetParameter* param_upgraded_pad); |
||||
|
||||
// Upgrade a single V0LayerConnection to the V1LayerParameter format.
|
||||
bool UpgradeV0LayerParameter(const V1LayerParameter& v0_layer_connection, |
||||
V1LayerParameter* layer_param); |
||||
|
||||
V1LayerParameter_LayerType UpgradeV0LayerType(const string& type); |
||||
|
||||
// Return true iff any layer contains deprecated data transformation parameters.
|
||||
bool NetNeedsDataUpgrade(const NetParameter& net_param); |
||||
|
||||
// Perform all necessary transformations to upgrade old transformation fields
|
||||
// into a TransformationParameter.
|
||||
void UpgradeNetDataTransformation(NetParameter* net_param); |
||||
|
||||
// Return true iff the Net contains any layers specified as V1LayerParameters.
|
||||
bool NetNeedsV1ToV2Upgrade(const NetParameter& net_param); |
||||
|
||||
// Perform all necessary transformations to upgrade a NetParameter with
|
||||
// deprecated V1LayerParameters.
|
||||
bool UpgradeV1Net(const NetParameter& v1_net_param, NetParameter* net_param); |
||||
|
||||
bool UpgradeV1LayerParameter(const V1LayerParameter& v1_layer_param, |
||||
LayerParameter* layer_param); |
||||
|
||||
const char* UpgradeV1LayerType(const V1LayerParameter_LayerType type); |
||||
|
||||
// Check for deprecations and upgrade the NetParameter as needed.
|
||||
bool UpgradeNetAsNeeded(const string& param_file, NetParameter* param); |
||||
|
||||
// Read parameters from a file into a NetParameter proto message.
|
||||
void ReadNetParamsFromTextFileOrDie(const string& param_file, |
||||
NetParameter* param); |
||||
void ReadNetParamsFromBinaryFileOrDie(const string& param_file, |
||||
NetParameter* param); |
||||
|
||||
} // namespace caffe
|
||||
|
||||
#endif // CAFFE_UTIL_UPGRADE_PROTO_H_
|
||||
@ -0,0 +1,2 @@ |
||||
#include <opencv2/core.hpp> |
||||
#include <opencv2/dnn.hpp> |
||||
@ -0,0 +1,31 @@ |
||||
#include "test_precomp.hpp" |
||||
|
||||
namespace cvtest |
||||
{ |
||||
|
||||
using namespace std; |
||||
using namespace std::tr1; |
||||
using namespace testing; |
||||
using namespace cv; |
||||
using namespace cv::dnn; |
||||
|
||||
static std::string getOpenCVExtraDir() |
||||
{ |
||||
return cvtest::TS::ptr()->get_data_path(); |
||||
} |
||||
|
||||
TEST(ReadCaffePrototxt_gtsrb, Accuracy) |
||||
{ |
||||
Ptr<Importer> importer = createCaffeImporter(getOpenCVExtraDir() + "/dnn/gtsrb.prototxt", ""); |
||||
Ptr<NetConfiguration> config = NetConfiguration::create(); |
||||
importer->populateNetConfiguration(config); |
||||
} |
||||
|
||||
TEST(ReadCaffePrototxt_GoogleNet, Accuracy) |
||||
{ |
||||
Ptr<Importer> importer = createCaffeImporter(getOpenCVExtraDir() + "/dnn/googlenet_deploy.prototxt", ""); |
||||
Ptr<NetConfiguration> config = NetConfiguration::create(); |
||||
importer->populateNetConfiguration(config); |
||||
} |
||||
|
||||
} |
||||
@ -0,0 +1,3 @@ |
||||
#include "test_precomp.hpp" |
||||
|
||||
CV_TEST_MAIN("") |
||||
@ -0,0 +1,19 @@ |
||||
#ifdef __GNUC__ |
||||
# pragma GCC diagnostic ignored "-Wmissing-declarations" |
||||
# if defined __clang__ || defined __APPLE__ |
||||
# pragma GCC diagnostic ignored "-Wmissing-prototypes" |
||||
# pragma GCC diagnostic ignored "-Wextra" |
||||
# endif |
||||
#endif |
||||
|
||||
#ifndef __OPENCV_TEST_PRECOMP_HPP__ |
||||
#define __OPENCV_TEST_PRECOMP_HPP__ |
||||
|
||||
#include "opencv2/core.hpp" |
||||
#include "opencv2/dnn.hpp" |
||||
#include "opencv2/highgui.hpp" |
||||
#include "opencv2/ts.hpp" |
||||
#include <opencv2/ts/ts_perf.hpp> |
||||
#include <opencv2/core/utility.hpp> |
||||
|
||||
#endif |
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,167 @@ |
||||
name: "gtsrb" |
||||
input: "data" |
||||
input_dim: 1 |
||||
input_dim: 3 |
||||
input_dim: 48 |
||||
input_dim: 48 |
||||
|
||||
|
||||
layers { |
||||
bottom: "data" |
||||
top: "layer1" |
||||
name: "layer1" |
||||
type: CONVOLUTION |
||||
blobs_lr: 1 |
||||
blobs_lr: 2 |
||||
convolution_param { |
||||
num_output: 100 |
||||
kernel_size: 7 |
||||
stride: 1 |
||||
weight_filler { |
||||
type: "xavier" |
||||
} |
||||
bias_filler { |
||||
type: "constant" |
||||
} |
||||
} |
||||
} |
||||
layers { |
||||
name: "tanh1" |
||||
bottom: "layer1" |
||||
top: "layer1" |
||||
type: TANH |
||||
} |
||||
layers { |
||||
bottom: "layer1" |
||||
top: "layer2" |
||||
name: "layer2" |
||||
type: POOLING |
||||
pooling_param { |
||||
pool: MAX |
||||
kernel_size: 2 |
||||
stride: 2 |
||||
} |
||||
} |
||||
|
||||
layers { |
||||
bottom: "layer2" |
||||
top: "layer3" |
||||
name: "layer3" |
||||
type: CONVOLUTION |
||||
blobs_lr: 1 |
||||
blobs_lr: 2 |
||||
convolution_param { |
||||
num_output: 150 |
||||
kernel_size: 4 |
||||
stride: 1 |
||||
weight_filler { |
||||
type: "xavier" |
||||
} |
||||
bias_filler { |
||||
type: "constant" |
||||
} |
||||
} |
||||
} |
||||
layers { |
||||
name: "tanh3" |
||||
bottom: "layer3" |
||||
top: "layer3" |
||||
type: TANH |
||||
} |
||||
layers { |
||||
bottom: "layer3" |
||||
top: "layer4" |
||||
name: "layer4" |
||||
type: POOLING |
||||
pooling_param { |
||||
pool: MAX |
||||
kernel_size: 2 |
||||
stride: 2 |
||||
} |
||||
} |
||||
|
||||
layers { |
||||
bottom: "layer4" |
||||
top: "layer5" |
||||
name: "layer5" |
||||
type: CONVOLUTION |
||||
blobs_lr: 1 |
||||
blobs_lr: 2 |
||||
convolution_param { |
||||
num_output: 250 |
||||
kernel_size: 4 |
||||
stride: 1 |
||||
weight_filler { |
||||
type: "xavier" |
||||
} |
||||
bias_filler { |
||||
type: "constant" |
||||
} |
||||
} |
||||
} |
||||
layers { |
||||
name: "tanh5" |
||||
bottom: "layer5" |
||||
top: "layer5" |
||||
type: TANH |
||||
} |
||||
layers { |
||||
bottom: "layer5" |
||||
top: "layer6" |
||||
name: "layer6" |
||||
type: POOLING |
||||
pooling_param { |
||||
pool: MAX |
||||
kernel_size: 2 |
||||
stride: 2 |
||||
} |
||||
} |
||||
|
||||
layers { |
||||
bottom: "layer6" |
||||
top: "layer7" |
||||
name: "layer7" |
||||
type: INNER_PRODUCT |
||||
blobs_lr: 1 |
||||
blobs_lr: 2 |
||||
inner_product_param { |
||||
num_output: 300 |
||||
weight_filler { |
||||
type: "xavier" |
||||
} |
||||
bias_filler { |
||||
type: "constant" |
||||
} |
||||
} |
||||
} |
||||
layers { |
||||
name: "tanh7" |
||||
bottom: "layer7" |
||||
top: "layer7" |
||||
type: TANH |
||||
} |
||||
|
||||
layers { |
||||
bottom: "layer7" |
||||
top: "layer8" |
||||
name: "layer8" |
||||
type: INNER_PRODUCT |
||||
blobs_lr: 1 |
||||
blobs_lr: 2 |
||||
inner_product_param { |
||||
num_output: 43 |
||||
weight_filler { |
||||
type: "xavier" |
||||
} |
||||
bias_filler { |
||||
type: "constant" |
||||
} |
||||
} |
||||
} |
||||
|
||||
layers { |
||||
name: "loss" |
||||
top: "loss" |
||||
bottom: "layer8" |
||||
type: SOFTMAX |
||||
} |
||||
Loading…
Reference in new issue