#include // NOLINT(build/include_alpha)
// Produce deprecation warnings (needs to come before arrayobject.h inclusion).
#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
#include
#include
#include
#include
#include
// these need to be included after boost on OS X
#include // NOLINT(build/include_order)
#include // NOLINT(build/include_order)
#include // NOLINT
#include "caffe/caffe.hpp"
#include "caffe/layers/memory_data_layer.hpp"
#include "caffe/layers/python_layer.hpp"
#include "caffe/sgd_solvers.hpp"
// Temporary solution for numpy < 1.7 versions: old macro, no promises.
// You're strongly advised to upgrade to >= 1.7.
#ifndef NPY_ARRAY_C_CONTIGUOUS
#define NPY_ARRAY_C_CONTIGUOUS NPY_C_CONTIGUOUS
#define PyArray_SetBaseObject(arr, x) (PyArray_BASE(arr) = (x))
#endif
/* Fix to avoid registration warnings in pycaffe (#3960) */
#define BP_REGISTER_SHARED_PTR_TO_PYTHON(PTR) do { \
const boost::python::type_info info = \
boost::python::type_id(); \
const boost::python::converter::registration* reg = \
boost::python::converter::registry::query(info); \
if (reg == NULL) { \
bp::register_ptr_to_python(); \
} else if ((*reg).m_to_python == NULL) { \
bp::register_ptr_to_python(); \
} \
} while (0)
namespace bp = boost::python;
namespace caffe {
// For Python, for now, we'll just always use float as the type.
typedef float Dtype;
const int NPY_DTYPE = NPY_FLOAT32;
// Selecting mode.
void set_mode_cpu() { Caffe::set_mode(Caffe::CPU); }
void set_mode_gpu() { Caffe::set_mode(Caffe::GPU); }
void InitLog(int level) {
FLAGS_logtostderr = 1;
FLAGS_minloglevel = level;
::google::InitGoogleLogging("");
::google::InstallFailureSignalHandler();
}
void InitLogInfo() {
InitLog(google::INFO);
}
void Log(const string& s) {
LOG(INFO) CopyTrainedLayersFrom(weights_file_str);
}
return net;
}
// Legacy Net construct-and-load convenience constructor
shared_ptr Net_Init_Load(
string param_file, string pretrained_param_file, int phase) {
LOG(WARNING) shape().begin(), blob->shape().end());
PyObject *arr_obj = PyArray_SimpleNewFromData(num_axes, dims.data(),
NPY_FLOAT32, data);
// SetBaseObject steals a ref, so we need to INCREF.
Py_INCREF(pyblob.ptr());
PyArray_SetBaseObject(reinterpret_cast(arr_obj),
pyblob.ptr());
return arr_obj;
}
};
bp::object Blob_Reshape(bp::tuple args, bp::dict kwargs) {
if (bp::len(kwargs) > 0) {
throw std::runtime_error("Blob.reshape takes no kwargs");
}
Blob* self = bp::extract(args[0]);
vector shape(bp::len(args) - 1);
for (int i = 1; i < bp::len(args); ++i) {
shape[i - 1] = bp::extract(args[i]);
}
self->Reshape(shape);
// We need to explicitly return None to use bp::raw_function.
return bp::object();
}
bp::object BlobVec_add_blob(bp::tuple args, bp::dict kwargs) {
if (bp::len(kwargs) > 0) {
throw std::runtime_error("BlobVec.add_blob takes no kwargs");
}
typedef vector BlobVec;
BlobVec* self = bp::extract(args[0]);
vector shape(bp::len(args) - 1);
for (int i = 1; i < bp::len(args); ++i) {
shape[i - 1] = bp::extract(args[i]);
}
self->push_back(shared_ptr(new Blob(shape)));
// We need to explicitly return None to use bp::raw_function.
return bp::object();
}
template
class SolverCallback: public Solver::Callback {
protected:
bp::object on_start_, on_gradients_ready_;
public:
SolverCallback(bp::object on_start, bp::object on_gradients_ready)
: on_start_(on_start), on_gradients_ready_(on_gradients_ready) { }
virtual void on_gradients_ready() {
on_gradients_ready_();
}
virtual void on_start() {
on_start_();
}
};
template
void Solver_add_callback(Solver * solver, bp::object on_start,
bp::object on_gradients_ready) {
solver->add_callback(new SolverCallback(on_start, on_gradients_ready));
}
// Seems boost cannot call the base method directly
void Solver_add_nccl(Solver* solver
#ifdef USE_NCCL
, NCCL* nccl
#endif
) {
#ifdef USE_NCCL
solver->add_callback(nccl);
#endif
}
template
class NetCallback: public Net::Callback {
public:
explicit NetCallback(bp::object run) : run_(run) {}
protected:
virtual void run(int layer) {
run_(layer);
}
bp::object run_;
};
void Net_before_forward(Net* net, bp::object run) {
net->add_before_forward(new NetCallback(run));
}
void Net_after_forward(Net* net, bp::object run) {
net->add_after_forward(new NetCallback(run));
}
void Net_before_backward(Net* net, bp::object run) {
net->add_before_backward(new NetCallback(run));
}
void Net_after_backward(Net* net, bp::object run) {
net->add_after_backward(new NetCallback(run));
}
void Net_add_nccl(Net* net
#ifdef USE_NCCL
, NCCL* nccl
#endif
) {
#ifdef USE_NCCL
net->add_after_backward(nccl);
#endif
}
#ifndef USE_NCCL
template
class NCCL {
public:
NCCL(shared_ptr solver, const string& uid) {}
};
#endif
BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(SolveOverloads, Solve, 0, 1);
BOOST_PYTHON_MODULE(_caffe) {
// below, we prepend an underscore to methods that will be replaced
// in Python
bp::scope().attr("__version__") = AS_STRING(CAFFE_VERSION);
// Caffe utility functions
bp::def("init_log", &InitLog);
bp::def("init_log", &InitLogInfo);
bp::def("log", &Log);
bp::def("set_mode_cpu", &set_mode_cpu);
bp::def("set_mode_gpu", &set_mode_gpu);
bp::def("set_random_seed", &set_random_seed);
bp::def("set_device", &Caffe::SetDevice);
bp::def("solver_count", &Caffe::solver_count);
bp::def("set_solver_count", &Caffe::set_solver_count);
bp::def("solver_rank", &Caffe::solver_rank);
bp::def("set_solver_rank", &Caffe::set_solver_rank);
bp::def("set_multiprocess", &Caffe::set_multiprocess);
bp::def("layer_type_list", &LayerRegistry::LayerTypeList);
bp::class_("Net",
bp::no_init)
// Constructor
.def("__init__", bp::make_constructor(&Net_Init,
bp::default_call_policies(), (bp::arg("network_file"), "phase",
bp::arg("level")=0, bp::arg("stages")=bp::object(),
bp::arg("weights")=bp::object())))
// Legacy constructor
.def("__init__", bp::make_constructor(&Net_Init_Load))
.def("_forward", &Net::ForwardFromTo)
.def("_backward", &Net::BackwardFromTo)
.def("reshape", &Net::Reshape)
.def("clear_param_diffs", &Net::ClearParamDiffs)
// The cast is to select a particular overload.
.def("copy_from", static_cast(
&Net::CopyTrainedLayersFrom))
.def("share_with", &Net::ShareTrainedLayersWith)
.add_property("_blob_loss_weights", bp::make_function(
&Net::blob_loss_weights, bp::return_internal_reference()))
.def("_bottom_ids", bp::make_function(&Net::bottom_ids,
bp::return_value_policy()))
.def("_top_ids", bp::make_function(&Net::top_ids,
bp::return_value_policy()))
.add_property("_blobs", bp::make_function(&Net::blobs,
bp::return_internal_reference()))
.add_property("layers", bp::make_function(&Net::layers,
bp::return_internal_reference()))
.add_property("_blob_names", bp::make_function(&Net::blob_names,
bp::return_value_policy()))
.add_property("_layer_names", bp::make_function(&Net::layer_names,
bp::return_value_policy()))
.add_property("_inputs", bp::make_function(&Net::input_blob_indices,
bp::return_value_policy()))
.add_property("_outputs",
bp::make_function(&Net::output_blob_indices,
bp::return_value_policy()))
.def("_set_input_arrays", &Net_SetInputArrays,
bp::with_custodian_and_ward())
.def("save", &Net_Save)
.def("save_hdf5", &Net_SaveHDF5)
.def("load_hdf5", &Net_LoadHDF5)
.def("before_forward", &Net_before_forward)
.def("after_forward", &Net_after_forward)
.def("before_backward", &Net_before_backward)
.def("after_backward", &Net_after_backward)
.def("after_backward", &Net_add_nccl);
BP_REGISTER_SHARED_PTR_TO_PYTHON(Net);
bp::class_(
"Blob", bp::no_init)
.add_property("shape",
bp::make_function(
static_cast(
&Blob::shape),
bp::return_value_policy()))
.add_property("num", &Blob::num)
.add_property("channels", &Blob::channels)
.add_property("height", &Blob::height)
.add_property("width", &Blob::width)
.add_property("count", static_cast(
&Blob::count))
.def("reshape", bp::raw_function(&Blob_Reshape))
.add_property("data", bp::make_function(&Blob::mutable_cpu_data,
NdarrayCallPolicies()))
.add_property("diff", bp::make_function(&Blob::mutable_cpu_diff,
NdarrayCallPolicies()));
BP_REGISTER_SHARED_PTR_TO_PYTHON(Blob);
bp::class_("Layer", bp::init())
.add_property("blobs", bp::make_function(&Layer::blobs,
bp::return_internal_reference()))
.def("setup", &Layer::LayerSetUp)
.def("reshape", &Layer::Reshape)
.add_property("type", bp::make_function(&Layer::type));
BP_REGISTER_SHARED_PTR_TO_PYTHON(Layer);
bp::class_("SolverParameter", bp::no_init)
.add_property("max_iter", &SolverParameter::max_iter)
.add_property("display", &SolverParameter::display)
.add_property("layer_wise_reduce", &SolverParameter::layer_wise_reduce);
bp::class_("LayerParameter", bp::no_init);
bp::class_(
"Solver", bp::no_init)
.add_property("net", &Solver::net)
.add_property("test_nets", bp::make_function(&Solver::test_nets,
bp::return_internal_reference()))
.add_property("iter", &Solver::iter)
.def("add_callback", &Solver_add_callback)
.def("add_callback", &Solver_add_nccl)
.def("solve", static_cast(
&Solver::Solve), SolveOverloads())
.def("step", &Solver::Step)
.def("restore", &Solver::Restore)
.def("snapshot", &Solver::Snapshot)
.add_property("param", bp::make_function(&Solver::param,
bp::return_value_policy()));
BP_REGISTER_SHARED_PTR_TO_PYTHON(Solver);
bp::class_(
"SGDSolver", bp::init());
bp::class_(
"NesterovSolver", bp::init());
bp::class_(
"AdaGradSolver", bp::init());
bp::class_(
"RMSPropSolver", bp::init());
bp::class_(
"AdaDeltaSolver", bp::init());
bp::class_(
"AdamSolver", bp::init());
bp::def("get_solver", &GetSolverFromFile,
bp::return_value_policy());
// vector wrappers for all the vector types we use
bp::class_("BlobVec")
.def(bp::vector_indexing_suite())
.def("add_blob", bp::raw_function(&BlobVec_add_blob));
bp::class_("RawBlobVec")
.def(bp::vector_indexing_suite());
bp::class_("LayerVec")
.def(bp::vector_indexing_suite());
bp::class_("StringVec")
.def(bp::vector_indexing_suite());
bp::class_("IntVec")
.def(bp::vector_indexing_suite());
bp::class_("DtypeVec")
.def(bp::vector_indexing_suite());
bp::class_("NetVec")
.def(bp::vector_indexing_suite());
bp::class_("BoolVec")
.def(bp::vector_indexing_suite());
bp::class_("NCCL",
bp::init())
#ifdef USE_NCCL
.def("new_uid", &NCCL::new_uid).staticmethod("new_uid")
.def("bcast", &NCCL::Broadcast)
#endif
/* NOLINT_NEXT_LINE(whitespace/semicolon) */
;
BP_REGISTER_SHARED_PTR_TO_PYTHON(NCCL);
bp::class_(
"Timer", bp::init())
.def("start", &Timer::Start)
.def("stop", &Timer::Stop)
.add_property("ms", &Timer::MilliSeconds);
BP_REGISTER_SHARED_PTR_TO_PYTHON(Timer);
// boost python expects a void (missing) return value, while import_array
// returns NULL for python3. import_array1() forces a void return value.
import_array1();
}
} // namespace caffe