refactor(network): replace overloaded Predict with distinct functions and optimize memory handling

Cpp/neural.cpp

@@ -30,13 +30,14 @@ double sigmoid_prim(double f) { return f * (1.0 - f); }
 /* network */
 
 Vector Network::Predict(const Vector &input) const {
-  Vector y_hidden = Vector(hiddenCount);
-  Vector y_output = Vector(outputCount);
-  return Predict(input, y_hidden, y_output);
+  Vector y_hidden(hiddenCount);
+  Vector y_output(outputCount);
+  Predict(input, y_hidden, y_output);
+  return y_output;
 }
 
-Vector Network::Predict(const Vector &input, Vector &hidden,
-                        Vector &output) const {
+void Network::Predict(const Vector &input, Vector &hidden,
+                      Vector &output) const {
   for (std::size_t c = 0; c < hiddenCount; c++) {
     double sum = 0.0;
     for (size_t r = 0; r < input.size(); r++) {
@@ -54,55 +55,54 @@ Vector Network::Predict(const Vector &input, Vector &hidden,
 
     output[c] = sigmoid(sum + biasesOutput[c]);
   }
-
-  return output;
 }
 
 /* trainer */
 
-Trainer Trainer::Create(Neural::Network &&network, size_t hiddenCount,
-                        size_t outputCount) {
-  Vector hidden = Vector(hiddenCount);
-  Vector output = Vector(outputCount);
-  Vector gradHidden = Vector(hiddenCount);
-  Vector gradOutput = Vector(outputCount);
-  return Trainer{.network = network,
-                 .hidden = hidden,
-                 .output = output,
-                 .gradHidden = gradHidden,
-                 .gradOutput = gradOutput};
+Trainer Trainer::Create(Neural::Network network) {
+  Vector hidden(network.hiddenCount);
+  Vector output(network.outputCount);
+  Vector gradHidden(network.hiddenCount);
+  Vector gradOutput(network.outputCount);
+  return Trainer{.network = std::move(network),
+                 .hidden = std::move(hidden),
+                 .output = std::move(output),
+                 .gradHidden = std::move(gradHidden),
+                 .gradOutput = std::move(gradOutput)};
 }
 
 Trainer Trainer::Create(size_t inputCount, size_t hiddenCount,
-                        size_t outputCount, std::function<double()> rand) {
-  Vector hidden = Vector(hiddenCount);
-  Vector output = Vector(outputCount);
-  Vector gradHidden = Vector(hiddenCount);
-  Vector gradOutput = Vector(outputCount);
-  Vector weightsHidden = Vector();
+                        size_t outputCount, RandFcn rand) {
+  Vector hidden(hiddenCount);
+  Vector output(outputCount);
+  Vector gradHidden(hiddenCount);
+  Vector gradOutput(outputCount);
+  Vector weightsHidden;
+  weightsHidden.reserve(inputCount * hiddenCount);
   for (size_t i = 0; i < inputCount * hiddenCount; i++) {
     weightsHidden.push_back(rand() - 0.5);
   }
 
-  Vector biasesHidden = Vector(hiddenCount);
-  Vector weightsOutput = Vector();
+  Vector biasesHidden(hiddenCount);
+  Vector weightsOutput;
+  weightsOutput.reserve(hiddenCount * outputCount);
   for (size_t i = 0; i < hiddenCount * outputCount; i++) {
     weightsOutput.push_back(rand() - 0.5);
   }
 
-  Vector biasesOutput = Vector(outputCount);
+  Vector biasesOutput(outputCount);
   Neural::Network network = {.inputCount = inputCount,
                              .hiddenCount = hiddenCount,
                              .outputCount = outputCount,
                              .weightsHidden = std::move(weightsHidden),
                              .biasesHidden = std::move(biasesHidden),
                              .weightsOutput = std::move(weightsOutput),
                              .biasesOutput = std::move(biasesOutput)};
-  return Trainer{.network = network,
-                 .hidden = hidden,
-                 .output = output,
-                 .gradHidden = gradHidden,
-                 .gradOutput = gradOutput};
+  return Trainer{.network = std::move(network),
+                 .hidden = std::move(hidden),
+                 .output = std::move(output),
+                 .gradHidden = std::move(gradHidden),
+                 .gradOutput = std::move(gradOutput)};
 }
 
 void Trainer::Train(const Vector &input, const Vector &y, double lr) {

Cpp/neural.h

@@ -24,30 +24,32 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include <vector>
 
 namespace Neural {
-    typedef std::vector<double> Vector;
-    typedef std::vector<Vector> Matrix;
-    struct Network {
-        size_t inputCount;
-        size_t hiddenCount;
-        size_t outputCount;
-        Vector weightsHidden;
-        Vector biasesHidden;
-        Vector weightsOutput;
-        Vector biasesOutput;
-        Vector Predict(const Vector& input) const;
-        Vector Predict(const Vector& input, Vector& hidden, Vector& output) const;
-    };
+typedef std::vector<double> Vector;
+typedef std::vector<Vector> Matrix;
+typedef std::function<double()> RandFcn;
+struct Network {
+  size_t inputCount;
+  size_t hiddenCount;
+  size_t outputCount;
+  Vector weightsHidden;
+  Vector biasesHidden;
+  Vector weightsOutput;
+  Vector biasesOutput;
+  Vector Predict(const Vector &input) const;
+  void Predict(const Vector &input, Vector &hidden, Vector &output) const;
+};
 
-    struct Trainer {
-        Network network;
-        Vector hidden;
-        Vector output;
-        Vector gradHidden;
-        Vector gradOutput;
-        static Trainer Create(Neural::Network&& network, size_t hiddenCount, size_t outputCount);
-        static Trainer Create(size_t inputCount, size_t hiddenCount, size_t outputCount, std::function<double()> rand);
-        void Train(const Vector& input, const Vector& output, double lr);
-    };
-}
+struct Trainer {
+  Network network;
+  Vector hidden;
+  Vector output;
+  Vector gradHidden;
+  Vector gradOutput;
+  static Trainer Create(Neural::Network network);
+  static Trainer Create(size_t inputCount, size_t hiddenCount,
+                        size_t outputCount, RandFcn rand);
+  void Train(const Vector &input, const Vector &output, double lr);
+};
+} // namespace Neural
 
 #endif