Fix Julia category mapping

HISTORY.md

@@ -1,5 +1,6 @@
 ### mlpack ?.?.?
 ###### ????-??-??
+  * Fix mapping of categorical data for Julia bindings (#3305).
 
 ### mlpack 4.0.0
 ###### 2022-10-23

src/mlpack/bindings/julia/julia_util.cpp

@@ -266,17 +266,14 @@ void SetParamMatWithInfo(void* params,
       hasCategoricals = true;
   }
 
-  arma::mat m(memptr, arma::uword(rows), arma::uword(cols), false, false);
+  arma::mat alias(memptr, arma::uword(rows), arma::uword(cols), false, false);
+  arma::mat m = pointsAreRows ? alias.t() : alias;
 
   // Do we need to find how many categories we have?
   if (hasCategoricals)
   {
     // Compute the maximum in each dimension.
-    arma::vec maxs;
-    if (pointsAreRows)
-      maxs = arma::max(m, 0).t();
-    else
-      maxs = arma::max(m, 1);
+    const arma::vec maxs = arma::max(m, 1);
 
     for (size_t i = 0; i < d.Dimensionality(); ++i)
     {
@@ -289,14 +286,19 @@ void SetParamMatWithInfo(void* params,
           oss << j;
           d.MapString<double>(oss.str(), i);
         }
+
+        // In Julia we specify the categorical value from 1 to the number of
+        // categories, but in C++ we expect 0 to the number of categories minus
+        // one.  (Just like the labels.)
+        m.row(i) -= 1.0;
       }
     }
   }
 
   std::get<0>(p->Get<std::tuple<data::DatasetInfo, arma::mat>>(
       paramName)) = std::move(d);
   std::get<1>(p->Get<std::tuple<data::DatasetInfo, arma::mat>>(
-      paramName)) = pointsAreRows ? m.t() : std::move(m);
+      paramName)) = std::move(m);
   p->SetPassed(paramName);
 }
 
@@ -683,8 +685,19 @@ double* GetParamMatWithInfoPtr(void* params, const char* paramName)
 
   // Are we using preallocated memory?  If so we have to handle this more
   // carefully.
+  data::DatasetInfo& di = std::get<0>(
+      p->Get<std::tuple<data::DatasetInfo, arma::mat>>(paramName));
   arma::mat& m = std::get<1>(
       p->Get<std::tuple<data::DatasetInfo, arma::mat>>(paramName));
+
+  // Add 1 to any categorical columns, to map them back to the 1-indexed values
+  // expected in Julia.
+  for (size_t d = 0; d < di.Dimensionality(); ++d)
+  {
+    if (di.Type(d) == data::Datatype::categorical)
+      m.row(d) += 1.0;
+  }
+
   if (m.n_elem <= arma::arma_config::mat_prealloc)
   {
     double* newMem = new double[m.n_elem];

src/mlpack/bindings/julia/tests/test_julia_binding_main.cpp

@@ -191,11 +191,15 @@ void BINDING_FUNCTION(util::Params& params, util::Timers& /* timers */)
         {
           if (ceil(m(i, c)) != m(i, c))
             throw std::invalid_argument("non-integer value in categorical!");
-          else if (m(i, c) <= 0)
-            throw std::invalid_argument("negative/zero value in categorical!");
-          else if (size_t(m(i, c)) > di.NumMappings(i))
+          else if (m(i, c) < 0)
+            throw std::invalid_argument("negative value in categorical!");
+          else if (size_t(m(i, c)) >= di.NumMappings(i))
             throw std::invalid_argument("value outside number of categories!");
         }
+
+        // Since this goes back to Julia as a regular matrix, we have to
+        // manually convert the categorical features to be one-indexed.
+        m.row(i) += 1.0;
       }
     }