mlpack 4.6.1__cp38-cp38-win_amd64.whl → 4.7.0__cp38-cp38-win_amd64.whl

mlpack/include/mlpack/core/cv/metrics/f1_impl.hpp

@@ -88,7 +88,7 @@ double F1<AS, PC>::Evaluate(MLAlgorithm& model,
         2.0 * precision * recall / (precision + recall);
   }
 
-  return arma::mean(f1s);
+  return mean(f1s);
 }
 
 } // namespace mlpack

mlpack/include/mlpack/core/cv/metrics/facilities.hpp

@@ -28,7 +28,8 @@ template<typename DataType, typename DistanceType>
 DataType PairwiseDistances(const DataType& data,
                            const DistanceType& distance)
 {
-  DataType distances = DataType(data.n_cols, data.n_cols, arma::fill::none);
+  DataType distances = DataType(data.n_cols, data.n_cols,
+      GetFillType<DataType>::none);
   for (size_t i = 0; i < data.n_cols; i++)
   {
     for (size_t j = 0; j < i; j++)

mlpack/include/mlpack/core/cv/metrics/precision_impl.hpp

@@ -77,7 +77,7 @@ double Precision<AS, PC>::Evaluate(MLAlgorithm& model,
     precisions(c) = double(tp) / numberOfPositivePredictions;
   }
 
-  return arma::mean(precisions);
+  return mean(precisions);
 }
 
 } // namespace mlpack

mlpack/include/mlpack/core/cv/metrics/r2_score_impl.hpp

@@ -27,7 +27,7 @@ double R2Score<AdjustedR2>::Evaluate(MLAlgorithm& model,
   // Taking Predicted Output from the model.
   model.Predict(data, predictedResponses);
   // Mean value of response.
-  double meanResponses = arma::mean(responses);
+  double meanResponses = mean(responses);
 
   // Calculate the numerator i.e. residual sum of squares.
   double residualSumSquared = accu(arma::square(responses -

mlpack/include/mlpack/core/cv/metrics/silhouette_score_impl.hpp

@@ -22,7 +22,7 @@ double SilhouetteScore::Overall(const DataType& X,
                                 const Metric& metric)
 {
   util::CheckSameSizes(X, labels, "SilhouetteScore::Overall()");
-  return arma::mean(SamplesScore(X, labels, metric));
+  return mean(SamplesScore(X, labels, metric));
 }
 
 template<typename DataType>

mlpack/include/mlpack/core/cv/simple_cv.hpp

@@ -105,7 +105,7 @@ class SimpleCV
 
   /**
    * This constructor can be used for multiclass classification algorithms that
-   * can take a data::DatasetInfo parameter.
+   * can take a DatasetInfo parameter.
    *
    * @param validationSize A proportion (between 0 and 1) of data used as a
    *     validation set.
@@ -120,7 +120,7 @@ class SimpleCV
   template<typename MatInType, typename PredictionsInType>
   SimpleCV(const double validationSize,
            MatInType&& xs,
-           const data::DatasetInfo& datasetInfo,
+           const DatasetInfo& datasetInfo,
            PredictionsInType&& ys,
            const size_t numClasses);
 
@@ -173,7 +173,7 @@ class SimpleCV
 
   /**
    * This constructor can be used for multiclass classification algorithms that
-   * can take a data::DatasetInfo parameter and support weighted learning.
+   * can take a DatasetInfo parameter and support weighted learning.
    *
    * @param validationSize A proportion (between 0 and 1) of data used as a
    *     validation set.
@@ -192,7 +192,7 @@ class SimpleCV
            typename WeightsInType>
   SimpleCV(const double validationSize,
            MatInType&& xs,
-           const data::DatasetInfo& datasetInfo,
+           const DatasetInfo& datasetInfo,
            PredictionsInType&& ys,
            const size_t numClasses,
            WeightsInType&& weights);

mlpack/include/mlpack/core/cv/simple_cv_impl.hpp

@@ -61,7 +61,7 @@ SimpleCV<MLAlgorithm,
          PredictionsType,
          WeightsType>::SimpleCV(const double validationSize,
                                 MIT&& xs,
-                                const data::DatasetInfo& datasetInfo,
+                                const DatasetInfo& datasetInfo,
                                 PIT&& ys,
                                 const size_t numClasses) :
     SimpleCV(Base(datasetInfo, numClasses), validationSize,
@@ -117,7 +117,7 @@ SimpleCV<MLAlgorithm,
          PredictionsType,
          WeightsType>::SimpleCV(const double validationSize,
                                 MIT&& xs,
-                                const data::DatasetInfo& datasetInfo,
+                                const DatasetInfo& datasetInfo,
                                 PIT&& ys,
                                 const size_t numClasses,
                                 WIT&& weights) :

mlpack/include/mlpack/core/data/binarize.hpp

@@ -16,7 +16,6 @@
 #include <mlpack/prereqs.hpp>
 
 namespace mlpack {
-namespace data {
 
 /**
  * Given an input dataset and threshold, set values greater than threshold to
@@ -86,7 +85,6 @@ void Binarize(const arma::Mat<T>& input,
     output(dimension, i) = input(dimension, i) > threshold;
 }
 
-} // namespace data
 } // namespace mlpack
 
 #endif

mlpack/include/mlpack/core/data/check_categorical_param.hpp

@@ -17,7 +17,6 @@
 #include <mlpack/core/util/params.hpp>
 
 namespace mlpack {
-namespace data {
 
 inline void CheckCategoricalParam(util::Params& params,
                                   const std::string& paramName)
@@ -35,7 +34,6 @@ inline void CheckCategoricalParam(util::Params& params,
     Log::Fatal << errMsg2 << std::endl;
 }
 
-} // namespace data
 } // namespace mlpack
 
 #endif

mlpack/include/mlpack/core/data/combine_options.hpp

@@ -0,0 +1,151 @@
+/**
+ * @file combine_options.hpp
+ * @author Ryan Curtin
+ * @author Omar Shrit
+ *
+ * Definition of operator+() for DataOptions types.
+ *
+ * mlpack is free software; you may redistribute it and/or modify it under the
+ * terms of the 3-clause BSD license.  You should have received a copy of the
+ * 3-clause BSD license along with mlpack.  If not, see
+ * http://www.opensource.org/licenses/BSD-3-Clause for more information.
+ */
+#ifndef MLPACK_CORE_DATA_COMBINE_OPTIONS_HPP
+#define MLPACK_CORE_DATA_COMBINE_OPTIONS_HPP
+
+#include <mlpack/prereqs.hpp>
+
+#include "data_options.hpp"
+#include "matrix_options.hpp"
+#include "text_options.hpp"
+
+namespace mlpack {
+
+// This template metaprogram encodes what the result of combining two different
+// DataOptions types are.  For now it exhaustively considers every possibility,
+// but, in the future, perhaps it will be possible to come up with something
+// that scales a little better.
+
+template<typename DataOptionsType1, typename DataOptionsType2>
+struct GetCombinedDataOptionsType
+{
+  typedef void result; // unknown result
+};
+
+template<typename T>
+struct MostDerivedType
+{
+  typedef void result;
+};
+
+template<typename Derived>
+struct MostDerivedType<DataOptionsBase<Derived>>
+{
+  typedef Derived result;
+};
+
+template<>
+struct MostDerivedType<DataOptionsBase<PlainDataOptions>>
+{
+  typedef DataOptions result;
+};
+
+template<>
+struct MostDerivedType<DataOptionsBase<MatrixOptionsBase<PlainMatrixOptions>>>
+{
+  typedef MatrixOptions result;
+};
+
+template<>
+struct MostDerivedType<DataOptionsBase<MatrixOptionsBase<TextOptions>>>
+{
+  typedef TextOptions result;
+};
+
+// When both types are the same, we return that type.
+template<typename Derived>
+struct GetCombinedDataOptionsType<DataOptionsBase<Derived>,
+                                  DataOptionsBase<Derived>>
+{
+  typedef typename MostDerivedType<DataOptionsBase<Derived>>::result result;
+};
+
+// When both types are different, the result is hardcoded.
+template<>
+struct GetCombinedDataOptionsType<DataOptionsBase<PlainDataOptions>,
+    DataOptionsBase<MatrixOptionsBase<PlainMatrixOptions>>>
+{
+  typedef MatrixOptions result;
+};
+
+template<>
+struct GetCombinedDataOptionsType<DataOptionsBase<
+    MatrixOptionsBase<PlainMatrixOptions>>,
+    DataOptionsBase<PlainDataOptions>>
+{
+  typedef MatrixOptions result;
+};
+
+template<>
+struct GetCombinedDataOptionsType<DataOptionsBase<
+    MatrixOptionsBase<TextOptions>>, DataOptionsBase<PlainDataOptions>>
+{
+  typedef TextOptions result;
+};
+
+template<>
+struct GetCombinedDataOptionsType<DataOptionsBase<PlainDataOptions>,
+    DataOptionsBase<MatrixOptionsBase<TextOptions>>>
+{
+  typedef TextOptions result;
+};
+
+template<>
+struct GetCombinedDataOptionsType<
+    DataOptionsBase<MatrixOptionsBase<PlainMatrixOptions>>,
+    DataOptionsBase<MatrixOptionsBase<TextOptions>>>
+{
+  typedef TextOptions result;
+};
+
+template<>
+struct GetCombinedDataOptionsType<
+    DataOptionsBase<MatrixOptionsBase<TextOptions>>,
+    DataOptionsBase<MatrixOptionsBase<PlainMatrixOptions>>>
+{
+  typedef TextOptions result;
+};
+
+// Using the template metaprogram above, return a combined DataOptions.
+
+template<typename Derived1, typename Derived2>
+typename GetCombinedDataOptionsType<DataOptionsBase<Derived1>,
+                                    DataOptionsBase<Derived2>>::result
+operator+(const DataOptionsBase<Derived1>& a,
+          const DataOptionsBase<Derived2>& b)
+{
+  using ReturnType = typename GetCombinedDataOptionsType<
+      DataOptionsBase<Derived1>, DataOptionsBase<Derived2>>::result;
+
+  if (std::is_same_v<Derived1, Derived2>)
+  {
+    // This is the easy case!  They are the same.
+    ReturnType output(a);
+    output += b;
+    return output;
+  }
+  else
+  {
+    // Here's the hard part, where the types are different.
+    // In this case, we can keep only the options from both sides that will be
+    // used in the result.  If members of a or b can't be represented in
+    // ReturnType, then a warning will be printed.
+    ReturnType convertedA(a);
+    ReturnType convertedB(b);
+    return convertedA + convertedB;
+  }
+}
+
+} // namespace mlpack
+
+#endif

mlpack/include/mlpack/core/data/confusion_matrix.hpp

@@ -16,7 +16,6 @@
 #include <mlpack/prereqs.hpp>
 
 namespace mlpack {
-namespace data {
 
 /**
  * A confusion matrix is a summary of prediction results on a classification
@@ -56,7 +55,6 @@ void ConfusionMatrix(const arma::Row<size_t> predictors,
                      arma::Mat<eT>& output,
                      const size_t numClasses);
 
-} // namespace data
 } // namespace mlpack
 
 // Include implementation.

mlpack/include/mlpack/core/data/confusion_matrix_impl.hpp

@@ -17,7 +17,6 @@
 #include "confusion_matrix.hpp"
 
 namespace mlpack {
-namespace data {
 
 /**
  * A confusion matrix is a summary of prediction results on a classification
@@ -60,7 +59,6 @@ void ConfusionMatrix(const arma::Row<size_t> predictors,
   }
 }
 
-} // namespace data
 } // namespace mlpack
 
 #endif

mlpack/include/mlpack/core/data/data.hpp

@@ -13,7 +13,6 @@
 #define MLPACK_CORE_DATA_DATA_HPP
 
 #include "extension.hpp"
-#include "format.hpp"
 #include "has_serialize.hpp"
 
 #include "load.hpp"
@@ -31,8 +30,11 @@
 #include "dataset_mapper.hpp"
 #include "data_options.hpp"
 #include "detect_file_type.hpp"
-#include "image_info.hpp"
+#include "image_layout.hpp"
+#include "image_options.hpp"
 #include "image_resize_crop.hpp"
+#include "image_letterbox.hpp"
+#include "image_bounding_box.hpp"
 #include "imputer.hpp"
 #include "is_naninf.hpp"
 #include "matrix_options.hpp"
@@ -41,7 +43,7 @@
 #include "split_data.hpp"
 #include "string_algorithms.hpp"
 #include "text_options.hpp"
-#include "types.hpp"
-#include "utilities.hpp"
+
+#include "combine_options.hpp"
 
 #endif