Minmax logic error fix. Parameters are per feature not row.

izzat5233 · Dec 19, 2023 · 03c3a7e · 03c3a7e
1 parent cf380c0
commit 03c3a7e
Show file tree

Hide file tree

Showing 3 changed files with 32 additions and 26 deletions.
diff --git a/nn/nn.h b/nn/nn.h
@@ -167,21 +167,19 @@ namespace nn {
          * Min-Max Normalization.
          * Normalizes the data using Min-Max scaling.
          * @param data Vector of data points
-         * @param minParam Minimum value parameter used in normalization.
-         * @param maxParam Minimum value parameter used in normalization.
+         * @param minMaxParams parameters used in normalization process.
          * @return Normalized data vector
          */
-        vd_t minmax(const vd_t &data, double minParam, double maxParam);
+        vd_t minmax(const vd_t &data, const vpd_t& minMaxParams);
 
         /**
          * Inverse Min-Max Normalization (De-normalization).
          * Reverts the normalized data back to its original scale.
          * @param data Vector of normalized data points
-         * @param originalMin The original minimum value of the data before normalization
-         * @param originalMax The original maximum value of the data before normalization
+         * @param minMaxParams parameters used in de-normalization process.
          * @return Denormalized data vector
          */
-        vd_t inverseMinmax(const vd_t &data, double originalMin, double originalMax);
+        vd_t inverseMinmax(const vd_t &data, const vpd_t& minMaxParams);
     }
 
     /**

diff --git a/nn/src/module.cpp b/nn/src/module.cpp
@@ -52,12 +52,15 @@ double Module::getLearningRate() const {
 }
 
 void Module::NormalizedData::set(const vvd_t &data) {
-    minMax.clear();
-    minMax.reserve(data.size());
-    for (const vd_t &line: data) {
-        double minVal = *std::min_element(line.begin(), line.end());
-        double maxVal = *std::max_element(line.begin(), line.end());
-        minMax.emplace_back(minVal, maxVal);
+    minMax.resize(data[0].size());
+    for (std::size_t i = 0; i < minMax.size(); ++i) {
+        double minParam = data[0][i];
+        double maxParam = data[0][i];
+        for (std::size_t j = 1; j < data.size(); ++j) {
+            minParam = std::min(minParam, data[j][i]);
+            maxParam = std::max(maxParam, data[j][i]);
+        }
+        minMax[i] = {minParam, maxParam};
     }
     normalized = normalize(data);
 }
@@ -74,7 +77,7 @@ vvd_t Module::NormalizedData::normalize(const nn::vvd_t &original) const {
     vvd_t norm;
     norm.reserve(original.size());
     for (std::size_t i = 0; i < original.size(); ++i) {
-        norm.push_back(process::minmax(original[i], minMax[i].first, minMax[i].second));
+        norm.push_back(process::minmax(original[i], minMax));
     }
     return norm;
 }
@@ -83,7 +86,7 @@ vvd_t Module::NormalizedData::denormalize(const vvd_t &processed) const {
     vvd_t original;
     original.reserve(processed.size());
     for (std::size_t i = 0; i < processed.size(); ++i) {
-        original.push_back(process::inverseMinmax(processed[i], minMax[i].first, minMax[i].second));
+        original.push_back(process::inverseMinmax(processed[i], minMax));
     }
     return original;
 }

diff --git a/nn/src/process.cpp b/nn/src/process.cpp
@@ -3,26 +3,31 @@
 //
 
 #include "nn.h"
-#include <algorithm>
+#include <cassert>
 
 using namespace nn;
 
-vd_t process::minmax(const vd_t &data, double minParam, double maxParam) {
-    if (data.size() == 1) { return {data[0]}; } // turn off for single outputs
-    if (minParam == maxParam) { return vd_t(data.size(), 0.5); }
+vd_t process::minmax(const vd_t &data, const vpd_t &minMaxParams) {
+    assert(data.size() == minMaxParams.size());
+    if (data.size() == 1) { return {data[0]}; } // turn off for single vectors
 
     vd_t normalized(data.size());
-    std::transform(data.begin(), data.end(), normalized.begin(), [minParam, maxParam](double x) {
-        return (x - minParam) / (maxParam - minParam);
-    });
+    for (std::size_t i = 0; i < data.size(); ++i) {
+        auto [minParam, maxParam] = minMaxParams[i];
+        if (minParam == maxParam) { normalized[i] = 0.5; }
+        else normalized[i] = (data[i] - minParam) / (maxParam - minParam);
+    }
     return normalized;
 }
 
-vd_t process::inverseMinmax(const vd_t &data, double originalMin, double originalMax) {
-    if (data.size() == 1) { return {data[0]}; } // turn off for single outputs
+vd_t process::inverseMinmax(const vd_t &data, const vpd_t &minMaxParams) {
+    assert(data.size() == minMaxParams.size());
+    if (data.size() == 1) { return {data[0]}; } // turn off for single vectors
+
     vd_t denormalized(data.size());
-    std::transform(data.begin(), data.end(), denormalized.begin(), [originalMin, originalMax](double x) {
-        return x * (originalMax - originalMin) + originalMin;
-    });
+    for (std::size_t i = 0; i < data.size(); ++i) {
+        auto [minParam, maxParam] = minMaxParams[i];
+        denormalized[i] = data[i] * (maxParam - minParam) + minParam;
+    }
     return denormalized;
 }