mlpack 4.6.2__cp313-cp313-win_amd64.whl → 4.7.0__cp313-cp313-win_amd64.whl

mlpack/include/mlpack/methods/reinforcement_learning/ddpg_impl.hpp

@@ -34,28 +34,28 @@ DDPG<
   NoiseType,
   UpdaterType,
   ReplayType
->::DDPG(TrainingConfig& config,
-       QNetworkType& learningQNetwork,
-       PolicyNetworkType& policyNetwork,
-       NoiseType& noise,
-       ReplayType& replayMethod,
-       UpdaterType qNetworkUpdater,
-       UpdaterType policyNetworkUpdater,
-       EnvironmentType environment):
-  config(config),
-  learningQNetwork(learningQNetwork),
-  policyNetwork(policyNetwork),
-  noise(noise),
-  replayMethod(replayMethod),
-  qNetworkUpdater(std::move(qNetworkUpdater)),
+>::DDPG(TrainingConfig& configIn,
+       QNetworkType& learningQNetworkIn,
+       PolicyNetworkType& policyNetworkIn,
+       NoiseType& noiseIn,
+       ReplayType& replayMethodIn,
+       UpdaterType qNetworkUpdaterIn,
+       UpdaterType policyNetworkUpdaterIn,
+       EnvironmentType environmentIn):
+  config(configIn),
+  learningQNetwork(learningQNetworkIn),
+  policyNetwork(policyNetworkIn),
+  noise(noiseIn),
+  replayMethod(replayMethodIn),
+  qNetworkUpdater(std::move(qNetworkUpdaterIn)),
   #if ENS_VERSION_MAJOR >= 2
   qNetworkUpdatePolicy(NULL),
   #endif
-  policyNetworkUpdater(std::move(policyNetworkUpdater)),
+  policyNetworkUpdater(std::move(policyNetworkUpdaterIn)),
   #if ENS_VERSION_MAJOR >= 2
   policyNetworkUpdatePolicy(NULL),
   #endif
-  environment(std::move(environment)),
+  environment(std::move(environmentIn)),
   totalSteps(0),
   deterministic(false)
 {

mlpack/include/mlpack/methods/reinforcement_learning/environment/acrobot.hpp

@@ -121,7 +121,7 @@ class Acrobot
   Acrobot(const size_t maxSteps = 500,
           const double gravity = 9.81,
           const double linkLength1 = 1.0,
-          const double linkLength2 = 1.0,
+          const double /* linkLength2 */ = 1.0,
           const double linkMass1 = 1.0,
           const double linkMass2 = 1.0,
           const double linkCom1 = 0.5,
@@ -134,7 +134,7 @@ class Acrobot
       maxSteps(maxSteps),
       gravity(gravity),
       linkLength1(linkLength1),
-      linkLength2(linkLength2),
+      //linkLength2(linkLength2),
       linkMass1(linkMass1),
       linkMass2(linkMass2),
       linkCom1(linkCom1),
@@ -360,8 +360,8 @@ class Acrobot
   //! Locally-stored length of link 1.
   double linkLength1;
 
-  //! Locally-stored length of link 2.
-  double linkLength2;
+  //! Locally-stored length of link 2.  (NOTE: not currently used)
+  //double linkLength2;
 
   //! Locally-stored mass of link 1.
   double linkMass1;

mlpack/include/mlpack/methods/reinforcement_learning/environment/cart_pole.hpp

@@ -125,7 +125,7 @@ class CartPole
            const double doneReward = 1.0) :
       maxSteps(maxSteps),
       gravity(gravity),
-      massCart(massCart),
+      //massCart(massCart),
       massPole(massPole),
       totalMass(massCart + massPole),
       length(length),
@@ -247,8 +247,8 @@ class CartPole
   //! Locally-stored gravity.
   double gravity;
 
-  //! Locally-stored mass of the cart.
-  double massCart;
+  //! Locally-stored mass of the cart.  NOTE: not currently used.
+  //double massCart;
 
   //! Locally-stored mass of the pole.
   double massPole;

mlpack/include/mlpack/methods/reinforcement_learning/environment/cont_double_pole_cart.hpp

@@ -104,7 +104,8 @@ class ContinuousDoublePoleCart
    * @param l2 The length of the second pole.
    * @param gravity The gravity constant.
    * @param massCart The mass of the cart.
-   * @param forceMag The magnitude of the applied force.
+   * @param forceMag The magnitude of the applied force.  NOTE: not currently
+   *      used.
    * @param tau The time interval.
    * @param thetaThresholdRadians The maximum angle.
    * @param xThreshold The maximum position.
@@ -118,7 +119,7 @@ class ContinuousDoublePoleCart
                            const double l2 = 0.05,
                            const double gravity = 9.8,
                            const double massCart = 1.0,
-                           const double forceMag = 10.0,
+                           const double /* forceMag */ = 10.0,
                            const double tau = 0.02,
                            const double thetaThresholdRadians = 36 * 2 *
                               3.1416 / 360,
@@ -131,7 +132,7 @@ class ContinuousDoublePoleCart
       l2(l2),
       gravity(gravity),
       massCart(massCart),
-      forceMag(forceMag),
+      //forceMag(forceMag),
       tau(tau),
       thetaThresholdRadians(thetaThresholdRadians),
       xThreshold(xThreshold),
@@ -340,8 +341,8 @@ class ContinuousDoublePoleCart
   //! Locally-stored mass of the cart.
   double massCart;
 
-  //! Locally-stored magnitude of the applied force.
-  double forceMag;
+  //! Locally-stored magnitude of the applied force.  NOTE: not currently used.
+  //double forceMag;
 
   //! Locally-stored time interval.
   double tau;

mlpack/include/mlpack/methods/reinforcement_learning/environment/pendulum.hpp

@@ -111,18 +111,19 @@ class Pendulum
    * @param maxAngularVelocity Maximum angular velocity.
    * @param maxTorque Maximum torque.
    * @param dt The differential value.
-   * @param doneReward The reward recieved by the agent on success.
+   * @param doneReward The reward recieved by the agent on success.  NOTE: not
+   *      currently used.
    */
   Pendulum(const size_t maxSteps = 200,
            const double maxAngularVelocity = 8,
            const double maxTorque = 2.0,
            const double dt = 0.05,
-           const double doneReward = 0.0) :
+           const double /* doneReward */ = 0.0) :
       maxSteps(maxSteps),
       maxAngularVelocity(maxAngularVelocity),
       maxTorque(maxTorque),
       dt(dt),
-      doneReward(doneReward),
+      //doneReward(doneReward),
       stepsPerformed(0)
   { /* Nothing to do here */ }
 
@@ -254,8 +255,8 @@ class Pendulum
   //! Locally-stored dt.
   double dt;
 
-  //! Locally-stored done reward.
-  double doneReward;
+  //! Locally-stored done reward.  NOTE: not currently used.
+  //double doneReward;
 
   //! Locally-stored number of steps performed.
   size_t stepsPerformed;

mlpack/include/mlpack/methods/reinforcement_learning/policy/aggregated_policy.hpp

@@ -35,9 +35,9 @@ class AggregatedPolicy
    *     User should make sure its size is same as the number of policies
    *     and the sum of its element is equal to 1.
    */
-  AggregatedPolicy(std::vector<PolicyType> policies,
+  AggregatedPolicy(std::vector<PolicyType> policiesIn,
                    const arma::colvec& distribution) :
-      policies(std::move(policies)),
+      policies(std::move(policiesIn)),
       sampler({distribution})
   { /* Nothing to do here. */ };
 

mlpack/include/mlpack/methods/reinforcement_learning/q_learning_impl.hpp

@@ -29,21 +29,21 @@ QLearning<
   UpdaterType,
   PolicyType,
   ReplayType
->::QLearning(TrainingConfig& config,
+>::QLearning(TrainingConfig& configIn,
              NetworkType& network,
-             PolicyType& policy,
-             ReplayType& replayMethod,
-             UpdaterType updater,
-             EnvironmentType environment):
-    config(config),
+             PolicyType& policyIn,
+             ReplayType& replayMethodIn,
+             UpdaterType updaterIn,
+             EnvironmentType environmentIn):
+    config(configIn),
     learningNetwork(network),
-    policy(policy),
-    replayMethod(replayMethod),
-    updater(std::move(updater)),
+    policy(policyIn),
+    replayMethod(replayMethodIn),
+    updater(std::move(updaterIn)),
     #if ENS_VERSION_MAJOR >= 2
     updatePolicy(NULL),
     #endif
-    environment(std::move(environment)),
+    environment(std::move(environmentIn)),
     totalSteps(0),
     deterministic(false)
 {

mlpack/include/mlpack/methods/reinforcement_learning/q_networks/categorical_dqn.hpp

@@ -78,21 +78,23 @@ class CategoricalDQN
       vMax(config.VMax()),
       isNoisy(isNoisy)
   {
-    network.Add(new Linear(h1));
-    network.Add(new ReLU());
+    network.template Add<Linear>(h1);
+    network.template Add<ReLU>();
     if (isNoisy)
     {
-      noisyLayerIndex.push_back(network.Network().size());
-      network.Add(new NoisyLinear(h2));
-      network.Add(new ReLU());
-      noisyLayerIndex.push_back(network.Network().size());
-      network.Add(new NoisyLinear(outputDim * atomSize));
+      network.template Add<NoisyLinear>(h2);
+      noisyLayers.push_back(
+          dynamic_cast<NoisyLinear<>*>(network.Network().back()));
+      network.template Add<ReLU>();
+      network.template Add<NoisyLinear>(outputDim * atomSize);
+      noisyLayers.push_back(
+          dynamic_cast<NoisyLinear<>*>(network.Network().back()));
     }
     else
     {
-      network.Add(new Linear(h2));
-      network.Add(new ReLU());
-      network.Add(new Linear(outputDim * atomSize));
+      network.template Add<Linear>(h2);
+      network.template Add<ReLU>();
+      network.template Add<Linear>(outputDim * atomSize);
     }
   }
 
@@ -104,16 +106,19 @@ class CategoricalDQN
    * @param config Hyper-parameters for categorical dqn.
    * @param isNoisy Specifies whether the network needs to be of type noisy.
    */
-  CategoricalDQN(NetworkType& network,
+  CategoricalDQN(NetworkType& networkIn,
                  TrainingConfig config,
                  const bool isNoisy = false):
-      network(std::move(network)),
+      network(std::move(networkIn)),
       atomSize(config.AtomSize()),
       vMin(config.VMin()),
       vMax(config.VMax()),
       isNoisy(isNoisy)
   { /* Nothing to do here. */ }
 
+  // TODO: implement copy constructor and operator
+  CategoricalDQN(const CategoricalDQN& other) = delete;
+
   /**
    * Predict the responses to a given set of predictors. The responses will
    * reflect the output of the given output layer as returned by the
@@ -176,10 +181,9 @@ class CategoricalDQN
    */
   void ResetNoise()
   {
-    for (size_t i = 0; i < noisyLayerIndex.size(); ++i)
+    for (size_t i = 0; i < noisyLayers.size(); ++i)
     {
-      dynamic_cast<NoisyLinear*>(
-          (network.Network()[noisyLayerIndex[i]]))->ResetNoise();
+      noisyLayers[i]->ResetNoise();
     }
   }
 
@@ -228,10 +232,10 @@ class CategoricalDQN
   bool isNoisy;
 
   //! Locally-stored indexes of noisy layers in the network.
-  std::vector<size_t> noisyLayerIndex;
+  std::vector<NoisyLinear<>*> noisyLayers;
 
   //! Locally-stored softmax activation function.
-  Softmax softMax;
+  Softmax<> softMax;
 
   //! Locally-stored activations from softMax.
   arma::mat activations;

mlpack/include/mlpack/methods/reinforcement_learning/q_networks/dueling_dqn.hpp

@@ -56,17 +56,15 @@ class DuelingDQN
   //! Default constructor.
   DuelingDQN() : isNoisy(false)
   {
-    // TODO: this really ought to use a DAG network, but that's not implemented
-    // yet.
-    featureNetwork = new MultiLayer<arma::mat>();
-    valueNetwork = new MultiLayer<arma::mat>();
-    advantageNetwork = new MultiLayer<arma::mat>();
-    concat = new Concat();
+    MultiLayer<arma::mat> featureNetwork;
+    MultiLayer<arma::mat> valueNetwork;
+    MultiLayer<arma::mat> advantageNetwork;
+    Concat concat;
 
-    concat->Add(valueNetwork);
-    concat->Add(advantageNetwork);
+    concat.Add(std::move(valueNetwork));
+    concat.Add(std::move(advantageNetwork));
     completeNetwork.Add(featureNetwork);
-    completeNetwork.Add(concat);
+    completeNetwork.Add(std::move(concat));
   }
 
   /**
@@ -88,43 +86,52 @@ class DuelingDQN
       completeNetwork(outputLayer, init),
       isNoisy(isNoisy)
   {
-    featureNetwork = new MultiLayer<arma::mat>();
-    featureNetwork->Add(new Linear(h1));
-    featureNetwork->Add(new ReLU());
+    // TODO: this really ought to use a DAG network, but that's not implemented
+    // yet.
+    MultiLayer<arma::mat> featureNetwork;
+    featureNetwork.template Add<Linear>(h1);
+    featureNetwork.template Add<ReLU<>>();
 
-    valueNetwork = new MultiLayer<arma::mat>();
-    advantageNetwork = new MultiLayer<arma::mat>();
+    MultiLayer<arma::mat> valueNetwork;
+    MultiLayer<arma::mat> advantageNetwork;
 
     if (isNoisy)
     {
-      noisyLayerIndex.push_back(valueNetwork->Network().size());
-      valueNetwork->Add(new NoisyLinear(h2));
-      advantageNetwork->Add(new NoisyLinear(h2));
-
-      valueNetwork->Add(new ReLU());
-      advantageNetwork->Add(new ReLU());
-
-      noisyLayerIndex.push_back(valueNetwork->Network().size());
-      valueNetwork->Add(new NoisyLinear(1));
-      advantageNetwork->Add(new NoisyLinear(outputDim));
+      valueNetwork.Add<NoisyLinear>(h2);
+      noisyLayers.push_back(dynamic_cast<NoisyLinear<>*>(
+          valueNetwork.Network().back()));
+
+      advantageNetwork.Add<NoisyLinear>(h2);
+      noisyLayers.push_back(dynamic_cast<NoisyLinear<>*>(
+          advantageNetwork.Network().back()));
+
+      valueNetwork.template Add<ReLU>();
+      advantageNetwork.template Add<ReLU>();
+
+      valueNetwork.template Add<NoisyLinear>(1);
+      noisyLayers.push_back(dynamic_cast<NoisyLinear<>*>(
+          valueNetwork.Network().back()));
+      advantageNetwork.template Add<NoisyLinear>(outputDim);
+      noisyLayers.push_back(dynamic_cast<NoisyLinear<>*>(
+          advantageNetwork.Network().back()));
     }
     else
     {
-      valueNetwork->Add(new Linear(h2));
-      valueNetwork->Add(new ReLU());
-      valueNetwork->Add(new Linear(1));
+      valueNetwork.template Add<Linear>(h2);
+      valueNetwork.template Add<ReLU>();
+      valueNetwork.template Add<Linear>(1);
 
-      advantageNetwork->Add(new Linear(h2));
-      advantageNetwork->Add(new ReLU());
-      advantageNetwork->Add(new Linear(outputDim));
+      advantageNetwork.template Add<Linear>(h2);
+      advantageNetwork.template Add<ReLU>();
+      advantageNetwork.template Add<Linear>(outputDim);
     }
 
-    concat = new Concat();
-    concat->Add(valueNetwork);
-    concat->Add(advantageNetwork);
+    Concat concat;
+    concat.Add(std::move(valueNetwork));
+    concat.Add(std::move(advantageNetwork));
 
-    completeNetwork.Add(featureNetwork);
-    completeNetwork.Add(concat);
+    completeNetwork.Add(std::move(featureNetwork));
+    completeNetwork.Add(std::move(concat));
   }
 
   /**
@@ -135,35 +142,35 @@ class DuelingDQN
    * @param valueNetwork The value network to be used by DuelingDQN class.
    * @param isNoisy Specifies whether the network needs to be of type noisy.
    */
-  DuelingDQN(FeatureNetworkType& featureNetwork,
-             AdvantageNetworkType& advantageNetwork,
-             ValueNetworkType& valueNetwork,
+  DuelingDQN(FeatureNetworkType&& featureNetwork,
+             AdvantageNetworkType&& advantageNetwork,
+             ValueNetworkType&& valueNetwork,
              const bool isNoisy = false):
-      featureNetwork(featureNetwork),
-      advantageNetwork(advantageNetwork),
-      valueNetwork(valueNetwork),
       isNoisy(isNoisy)
   {
-    concat = new Concat();
-    concat->Add(valueNetwork);
-    concat->Add(advantageNetwork);
-    completeNetwork.Add(featureNetwork);
-    completeNetwork.Add(concat);
+    Concat concat;
+    concat.Add(std::move(valueNetwork));
+    concat.Add(std::move(advantageNetwork));
+    completeNetwork.Add(std::move(featureNetwork));
+    completeNetwork.Add(std::move(concat));
   }
 
-  //! Copy constructor.
-  DuelingDQN(const DuelingDQN& /* model */) : isNoisy(false)
-  { /* Nothing to do here. */ }
+  // Copy constructor.
+  //DuelingDQN(const DuelingDQN& model) : isNoisy(false)
+//  {
+//    // Use copy operator.
+//    *this = model;
+//  }
 
-  //! Copy assignment operator.
-  void operator = (const DuelingDQN& model)
-  {
-    *valueNetwork = *model.valueNetwork;
-    *advantageNetwork = *model.advantageNetwork;
-    *featureNetwork = *model.featureNetwork;
-    isNoisy = model.isNoisy;
-    noisyLayerIndex = model.noisyLayerIndex;
-  }
+  // Copy assignment operator.
+//  void operator=(const DuelingDQN& model)
+//  {
+//    completeNetwork = model.completeNetwork;
+
+//    isNoisy = model.isNoisy;
+//  }
+
+  DuelingDQN(const DuelingDQN& model) = delete;
 
   /**
    * Predict the responses to a given set of predictors. The responses will
@@ -234,12 +241,9 @@ class DuelingDQN
    */
   void ResetNoise()
   {
-    for (size_t i = 0; i < noisyLayerIndex.size(); i++)
+    for (size_t i = 0; i < noisyLayers.size(); i++)
     {
-      dynamic_cast<NoisyLinear*>(
-          (valueNetwork->Network()[noisyLayerIndex[i]]))->ResetNoise();
-      dynamic_cast<NoisyLinear*>(
-          (advantageNetwork->Network()[noisyLayerIndex[i]]))->ResetNoise();
+      noisyLayers[i]->ResetNoise();
     }
   }
 
@@ -252,24 +256,12 @@ class DuelingDQN
   //! Locally-stored complete network.
   CompleteNetworkType completeNetwork;
 
-  //! Locally-stored concat network.
-  Concat* concat;
-
-  //! Locally-stored feature network.
-  FeatureNetworkType* featureNetwork;
-
-  //! Locally-stored advantage network.
-  AdvantageNetworkType* advantageNetwork;
-
-  //! Locally-stored value network.
-  ValueNetworkType* valueNetwork;
+  // Pointers to noisy layers.
+  std::vector<NoisyLinear<>*> noisyLayers;
 
   //! Locally-stored check for noisy network.
   bool isNoisy;
 
-  //! Locally-stored indexes of noisy layers in the network.
-  std::vector<size_t> noisyLayerIndex;
-
   //! Locally-stored actionValues of the network.
   arma::mat actionValues;
 

mlpack/include/mlpack/methods/reinforcement_learning/q_networks/simple_dqn.hpp

@@ -58,21 +58,21 @@ class SimpleDQN
       network(outputLayer, init),
       isNoisy(isNoisy)
   {
-    network.Add(new Linear(h1));
-    network.Add(new ReLU());
+    network.template Add<Linear>(h1);
+    network.template Add<ReLU>();
     if (isNoisy)
     {
       noisyLayerIndex.push_back(network.Network().size());
-      network.Add(new NoisyLinear(h2));
-      network.Add(new ReLU());
+      network.template Add<NoisyLinear>(h2);
+      network.template Add<ReLU>();
       noisyLayerIndex.push_back(network.Network().size());
-      network.Add(new NoisyLinear(outputDim));
+      network.template Add<NoisyLinear>(outputDim);
     }
     else
     {
-      network.Add(new Linear(h2));
-      network.Add(new ReLU());
-      network.Add(new Linear(outputDim));
+      network.template Add<Linear>(h2);
+      network.template Add<ReLU>();
+      network.template Add<Linear>(outputDim);
     }
   }
 
@@ -129,7 +129,7 @@ class SimpleDQN
   {
     for (size_t i = 0; i < noisyLayerIndex.size(); i++)
     {
-      dynamic_cast<NoisyLinear*>(
+      dynamic_cast<NoisyLinear<>*>(
           network.Network()[noisyLayerIndex[i]])->ResetNoise();
     }
   }

mlpack/include/mlpack/methods/reinforcement_learning/sac_impl.hpp

@@ -32,26 +32,26 @@ SAC<
   PolicyNetworkType,
   UpdaterType,
   ReplayType
->::SAC(TrainingConfig& config,
-       QNetworkType& learningQ1Network,
-       PolicyNetworkType& policyNetwork,
-       ReplayType& replayMethod,
-       UpdaterType qNetworkUpdater,
-       UpdaterType policyNetworkUpdater,
-       EnvironmentType environment):
-  config(config),
-  learningQ1Network(learningQ1Network),
-  policyNetwork(policyNetwork),
-  replayMethod(replayMethod),
-  qNetworkUpdater(std::move(qNetworkUpdater)),
+>::SAC(TrainingConfig& configIn,
+       QNetworkType& learningQ1NetworkIn,
+       PolicyNetworkType& policyNetworkIn,
+       ReplayType& replayMethodIn,
+       UpdaterType qNetworkUpdaterIn,
+       UpdaterType policyNetworkUpdaterIn,
+       EnvironmentType environmentIn):
+  config(configIn),
+  learningQ1Network(learningQ1NetworkIn),
+  policyNetwork(policyNetworkIn),
+  replayMethod(replayMethodIn),
+  qNetworkUpdater(std::move(qNetworkUpdaterIn)),
   #if ENS_VERSION_MAJOR >= 2
   qNetworkUpdatePolicy(NULL),
   #endif
-  policyNetworkUpdater(std::move(policyNetworkUpdater)),
+  policyNetworkUpdater(std::move(policyNetworkUpdaterIn)),
   #if ENS_VERSION_MAJOR >= 2
   policyNetworkUpdatePolicy(NULL),
   #endif
-  environment(std::move(environment)),
+  environment(std::move(environmentIn)),
   totalSteps(0),
   deterministic(false)
 {

mlpack/include/mlpack/methods/reinforcement_learning/td3_impl.hpp

@@ -32,26 +32,26 @@ TD3<
   PolicyNetworkType,
   UpdaterType,
   ReplayType
->::TD3(TrainingConfig& config,
-       QNetworkType& learningQ1Network,
-       PolicyNetworkType& policyNetwork,
-       ReplayType& replayMethod,
-       UpdaterType qNetworkUpdater,
-       UpdaterType policyNetworkUpdater,
-       EnvironmentType environment):
-  config(config),
-  learningQ1Network(learningQ1Network),
-  policyNetwork(policyNetwork),
-  replayMethod(replayMethod),
-  qNetworkUpdater(std::move(qNetworkUpdater)),
+>::TD3(TrainingConfig& configIn,
+       QNetworkType& learningQ1NetworkIn,
+       PolicyNetworkType& policyNetworkIn,
+       ReplayType& replayMethodIn,
+       UpdaterType qNetworkUpdaterIn,
+       UpdaterType policyNetworkUpdaterIn,
+       EnvironmentType environmentIn):
+  config(configIn),
+  learningQ1Network(learningQ1NetworkIn),
+  policyNetwork(policyNetworkIn),
+  replayMethod(replayMethodIn),
+  qNetworkUpdater(std::move(qNetworkUpdaterIn)),
   #if ENS_VERSION_MAJOR >= 2
   qNetworkUpdatePolicy(NULL),
   #endif
-  policyNetworkUpdater(std::move(policyNetworkUpdater)),
+  policyNetworkUpdater(std::move(policyNetworkUpdaterIn)),
   #if ENS_VERSION_MAJOR >= 2
   policyNetworkUpdatePolicy(NULL),
   #endif
-  environment(std::move(environment)),
+  environment(std::move(environmentIn)),
   totalSteps(0),
   deterministic(false)
 {

mlpack/include/mlpack/methods/softmax_regression/softmax_regression_function_impl.hpp

@@ -335,7 +335,7 @@ inline void SoftmaxRegressionFunction<MatType>::PartialGradient(
     const size_t j,
     GradType& gradient) const
 {
-  gradient.zeros(arma::size(parameters));
+  gradient.zeros(size(parameters));
 
   DenseMatType probabilities;
   GetProbabilitiesMatrix(parameters, probabilities, 0, data.n_cols);

mlpack/include/mlpack/methods/svdplusplus/svdplusplus_function_impl.hpp

@@ -451,7 +451,7 @@ inline double ParallelSGD<ExponentialBackoff>::Optimize(
     // Get the stepsize for this iteration
     double stepSize = decayPolicy.StepSize(i);
 
-    if (shuffle) // Determine order of visitation.
+    if (Shuffle()) // Determine order of visitation.
       std::shuffle(visitationOrder.begin(), visitationOrder.end(),
           mlpack::RandGen());
 

mlpack/include/mlpack/namespace_compat.hpp

@@ -31,6 +31,7 @@ namespace adaboost { using namespace mlpack; }
 namespace amf { using namespace mlpack; }
 namespace ann { using namespace mlpack; }
 namespace cf { using namespace mlpack; }
+namespace data { using namespace mlpack; }
 namespace dbscan { using namespace mlpack; }
 namespace det { using namespace mlpack; }
 namespace emst { using namespace mlpack; }

mlpack/include/mlpack/prereqs.hpp

@@ -32,6 +32,7 @@
 #include <mlpack/core/cereal/pointer_vector_wrapper.hpp>
 #include <mlpack/core/cereal/pointer_wrapper.hpp>
 #include <mlpack/core/cereal/template_class_version.hpp>
+#include <mlpack/core/cereal/low_precision.hpp>
 #include <mlpack/core/data/has_serialize.hpp>
 
 // Include ready to use utility function to check sizes of datasets.