All tests are now passing

setup.py

@@ -63,6 +63,7 @@ setup(
         ),
       Extension("xbob.learn.mlp._library",
         [
+          "xbob/learn/mlp/rprop.cpp",
           "xbob/learn/mlp/backprop.cpp",
           "xbob/learn/mlp/trainer.cpp",
           "xbob/learn/mlp/cxx/machine.cpp",

xbob/learn/mlp/backprop.cpp

@@ -470,15 +470,14 @@ static PyObject* PyBobLearnMLPBackProp_train
 
 }
 
-/**
-PyDoc_STRVAR(s_set_derivative_str, "set_derivative");
-PyDoc_STRVAR(s_set_derivative_doc,
-    "Sets the cost derivative w.r.t. the **weights** for a given layer.");
+PyDoc_STRVAR(s_set_previous_derivative_str, "set_previous_derivative");
+PyDoc_STRVAR(s_set_previous_derivative_doc,
+    "Sets the previous cost derivative for a given weight layer (index).");
 
-static PyObject* PyBobLearnMLPBackProp_setDerivativeOnLayer
-(PyBobLearnMLPBackPropObject* self, PyObject* args, PyObject* kwds) {
+static PyObject* PyBobLearnMLPRProp_setPreviousDerivativeOnLayer
+(PyBobLearnMLPRPropObject* self, PyObject* args, PyObject* kwds) {
 
-  /* Parses input arguments in a single shot *\/
+  /* Parses input arguments in a single shot */
   static const char* const_kwlist[] = {"array", "layer", 0};
   static char** kwlist = const_cast<char**>(const_kwlist);
 
@@ -489,19 +488,20 @@ static PyObject* PyBobLearnMLPBackProp_setDerivativeOnLayer
         &PyBlitzArray_Converter, &array, &layer)) return 0;
 
   if (array->type_num != NPY_FLOAT64 || array->ndim != 2) {
-    PyErr_Format(PyExc_TypeError, "`%s.%s' only supports 2D 64-bit float arrays for argument `array' (or any other object coercible to that), but you provided an object with %" PY_FORMAT_SIZE_T "d dimensions and with type `%s' which is not compatible - check your input", Py_TYPE(self)->tp_name, s_set_derivative_str, array->ndim, PyBlitzArray_TypenumAsString(array->type_num));
+    PyErr_Format(PyExc_TypeError, "`%s.%s' only supports 2D 64-bit float arrays for argument `array' (or any other object coercible to that), but you provided an object with %" PY_FORMAT_SIZE_T "d dimensions and with type `%s' which is not compatible - check your input", Py_TYPE(self)->tp_name, s_set_previous_derivative_str, array->ndim, PyBlitzArray_TypenumAsString(array->type_num));
     return 0;
   }
 
   try {
-    self->cxx->setDerivative(*PyBlitzArrayCxx_AsBlitz<double,2>(array), layer);
+    self->cxx->setPreviousDerivative(*PyBlitzArrayCxx_AsBlitz<double,2>(array),
+        layer);
   }
   catch (std::exception& ex) {
     PyErr_SetString(PyExc_RuntimeError, ex.what());
     return 0;
   }
   catch (...) {
-    PyErr_Format(PyExc_RuntimeError, "cannot set derivative at layer %" PY_FORMAT_SIZE_T "d for `%s': unknown exception caught", layer, Py_TYPE(self)->tp_name);
+    PyErr_Format(PyExc_RuntimeError, "cannot set previous derivative at layer %" PY_FORMAT_SIZE_T "d for `%s': unknown exception caught", layer, Py_TYPE(self)->tp_name);
     return 0;
   }
 
@@ -509,14 +509,14 @@ static PyObject* PyBobLearnMLPBackProp_setDerivativeOnLayer
 
 }
 
-PyDoc_STRVAR(s_set_bias_derivative_str, "set_bias_derivative");
-PyDoc_STRVAR(s_set_bias_derivative_doc,
-    "Sets the cost derivative w.r.t. the **biases** for a given layer.");
+PyDoc_STRVAR(s_set_previous_bias_derivative_str, "set_previous_bias_derivative");
+PyDoc_STRVAR(s_set_previous_bias_derivative_doc,
+    "Sets the cost bias derivative for a given bias layer (index).");
 
-static PyObject* PyBobLearnMLPBackProp_setBiasDerivativeOnLayer
-(PyBobLearnMLPBackPropObject* self, PyObject* args, PyObject* kwds) {
+static PyObject* PyBobLearnMLPRProp_setPreviousBiasDerivativeOnLayer
+(PyBobLearnMLPRPropObject* self, PyObject* args, PyObject* kwds) {
 
-  /* Parses input arguments in a single shot *\/
+  /* Parses input arguments in a single shot */
   static const char* const_kwlist[] = {"array", "layer", 0};
   static char** kwlist = const_cast<char**>(const_kwlist);
 
@@ -527,26 +527,25 @@ static PyObject* PyBobLearnMLPBackProp_setBiasDerivativeOnLayer
         &PyBlitzArray_Converter, &array, &layer)) return 0;
 
   if (array->type_num != NPY_FLOAT64 || array->ndim != 1) {
-    PyErr_Format(PyExc_TypeError, "`%s.%s' only supports 1D 64-bit float arrays for argument `array' (or any other object coercible to that), but you provided an object with %" PY_FORMAT_SIZE_T "d dimensions and with type `%s' which is not compatible - check your input", Py_TYPE(self)->tp_name, s_set_bias_derivative_str, array->ndim, PyBlitzArray_TypenumAsString(array->type_num));
+    PyErr_Format(PyExc_TypeError, "`%s.%s' only supports 1D 64-bit float arrays for argument `array' (or any other object coercible to that), but you provided an object with %" PY_FORMAT_SIZE_T "d dimensions and with type `%s' which is not compatible - check your input", Py_TYPE(self)->tp_name, s_set_previous_bias_derivative_str, array->ndim, PyBlitzArray_TypenumAsString(array->type_num));
     return 0;
   }
 
   try {
-    self->cxx->setBiasDerivative(*PyBlitzArrayCxx_AsBlitz<double,1>(array), layer);
+    self->cxx->setPreviousBiasDerivative(*PyBlitzArrayCxx_AsBlitz<double,1>(array), layer);
   }
   catch (std::exception& ex) {
     PyErr_SetString(PyExc_RuntimeError, ex.what());
     return 0;
   }
   catch (...) {
-    PyErr_Format(PyExc_RuntimeError, "cannot set bias derivative at layer %" PY_FORMAT_SIZE_T "d for `%s': unknown exception caught", layer, Py_TYPE(self)->tp_name);
+    PyErr_Format(PyExc_RuntimeError, "cannot set previous bias derivative at layer %" PY_FORMAT_SIZE_T "d for `%s': unknown exception caught", layer, Py_TYPE(self)->tp_name);
     return 0;
   }
 
   Py_RETURN_NONE;
 
 }
-**/
 
 static PyMethodDef PyBobLearnMLPBackProp_methods[] = {
   {
@@ -561,20 +560,18 @@ static PyMethodDef PyBobLearnMLPBackProp_methods[] = {
     METH_VARARGS|METH_KEYWORDS,
     s_train_doc,
   },
-  /**
   {
-    s_set_derivative_str,
-    (PyCFunction)PyBobLearnMLPBackProp_setDerivativeOnLayer,
+    s_set_previous_derivative_str,
+    (PyCFunction)PyBobLearnMLPRProp_setPreviousDerivativeOnLayer,
     METH_VARARGS|METH_KEYWORDS,
-    s_set_derivative_doc,
+    s_set_previous_derivative_doc,
   },
   {
-    s_set_bias_derivative_str,
-    (PyCFunction)PyBobLearnMLPBackProp_setBiasDerivativeOnLayer,
+    s_set_previous_bias_derivative_str,
+    (PyCFunction)PyBobLearnMLPRProp_setPreviousBiasDerivativeOnLayer,
     METH_VARARGS|METH_KEYWORDS,
-    s_set_bias_derivative_doc,
+    s_set_previous_bias_derivative_doc,
   },
-  **/
   {0} /* Sentinel */
 };
 

xbob/learn/mlp/include/xbob.learn.mlp/api.h

@@ -17,6 +17,7 @@
 #include "shuffler.h"
 #include "trainer.h"
 #include "backprop.h"
+#include "rprop.h"
 
 #define XBOB_LEARN_MLP_MODULE_PREFIX xbob.learn.mlp
 #define XBOB_LEARN_MLP_MODULE_NAME _library
@@ -45,6 +46,8 @@ enum _PyBobLearnMLP_ENUM {
   PyBobLearnMLPTrainer_Check_NUM,
   PyBobLearnMLPBackProp_Type_NUM,
   PyBobLearnMLPBackProp_Check_NUM,
+  PyBobLearnMLPRProp_Type_NUM,
+  PyBobLearnMLPRProp_Check_NUM,
   // Total number of C API pointers
   PyXbobLearnMLP_API_pointers
 };
@@ -130,6 +133,16 @@ typedef struct {
 #define PyBobLearnMLPBackProp_Check_RET int
 #define PyBobLearnMLPBackProp_Check_PROTO (PyObject* o)
 
+typedef struct {
+  PyBobLearnMLPTrainerObject parent;
+  bob::learn::mlp::RProp* cxx;
+} PyBobLearnMLPRPropObject;
+
+#define PyBobLearnMLPRProp_Type_TYPE PyTypeObject
+
+#define PyBobLearnMLPRProp_Check_RET int
+#define PyBobLearnMLPRProp_Check_PROTO (PyObject* o)
+
 #ifdef XBOB_LEARN_MLP_MODULE
 
   /* This section is used when compiling `xbob.learn.mlp' itself */
@@ -182,6 +195,10 @@ typedef struct {
 
   PyBobLearnMLPBackProp_Check_RET PyBobLearnMLPBackProp_Check PyBobLearnMLPBackProp_Check_PROTO;
 
+  extern PyBobLearnMLPRProp_Type_TYPE PyBobLearnMLPRProp_Type;
+
+  PyBobLearnMLPRProp_Check_RET PyBobLearnMLPRProp_Check PyBobLearnMLPRProp_Check_PROTO;
+
 #else
 
   /* This section is used in modules that use `xbob.learn.mlp's' C-API */
@@ -256,6 +273,10 @@ typedef struct {
 
 # define PyBobLearnMLPBackProp_Check (*(PyBobLearnMLPBackProp_Check_RET (*)PyBobLearnMLPBackProp_Check_PROTO) PyXbobLearnMLP_API[PyBobLearnMLPBackProp_Check_NUM])
 
+# define PyBobLearnMLPRProp_Type (*(PyBobLearnMLPRProp_Type_TYPE *)PyXbobLearnMLP_API[PyBobLearnMLPRProp_Type_NUM])
+
+# define PyBobLearnMLPRProp_Check (*(PyBobLearnMLPRProp_Check_RET (*)PyBobLearnMLPRProp_Check_PROTO) PyXbobLearnMLP_API[PyBobLearnMLPRProp_Check_NUM])
+
 # if !defined(NO_IMPORT_ARRAY)
 
   /**

xbob/learn/mlp/main.cpp

@@ -59,6 +59,9 @@ static PyObject* create_module (void) {
   PyBobLearnMLPBackProp_Type.tp_base = &PyBobLearnMLPTrainer_Type;
   if (PyType_Ready(&PyBobLearnMLPBackProp_Type) < 0) return 0;
 
+  PyBobLearnMLPRProp_Type.tp_base = &PyBobLearnMLPTrainer_Type;
+  if (PyType_Ready(&PyBobLearnMLPRProp_Type) < 0) return 0;
+
 # if PY_VERSION_HEX >= 0x03000000
   PyObject* m = PyModule_Create(&module_definition);
 # else
@@ -93,6 +96,9 @@ static PyObject* create_module (void) {
   Py_INCREF(&PyBobLearnMLPBackProp_Type);
   if (PyModule_AddObject(m, "BackProp", (PyObject *)&PyBobLearnMLPBackProp_Type) < 0) return 0;
 
+  Py_INCREF(&PyBobLearnMLPRProp_Type);
+  if (PyModule_AddObject(m, "RProp", (PyObject *)&PyBobLearnMLPRProp_Type) < 0) return 0;
+
   static void* PyXbobLearnMLP_API[PyXbobLearnMLP_API_pointers];
 
   /* exhaustive list of C APIs */
@@ -141,6 +147,14 @@ static PyObject* create_module (void) {
 
   PyXbobLearnMLP_API[PyBobLearnMLPTrainer_Check_NUM] = (void *)&PyBobLearnMLPTrainer_Check;
 
+  PyXbobLearnMLP_API[PyBobLearnMLPBackProp_Type_NUM] = (void *)&PyBobLearnMLPBackProp_Type;
+
+  PyXbobLearnMLP_API[PyBobLearnMLPBackProp_Check_NUM] = (void *)&PyBobLearnMLPBackProp_Check;
+
+  PyXbobLearnMLP_API[PyBobLearnMLPRProp_Type_NUM] = (void *)&PyBobLearnMLPRProp_Type;
+
+  PyXbobLearnMLP_API[PyBobLearnMLPRProp_Check_NUM] = (void *)&PyBobLearnMLPRProp_Check;
+
 #if PY_VERSION_HEX >= 0x02070000
 
   /* defines the PyCapsule */