Eliminate loop-level vector heap allocations in backpropagation

- Reuse rnn_grads_row, given_outputs_vec, current_target, and deltas vectors across batch/time iterations in FFLayer, FFOutputLayer, LSTMLayer, and ElmanRNNLayer.
- Use pointer-based set_rnn_gradients inside output gradient calculation to prevent vector move/deallocation and reuse underlying vector memory capacity.
- Add unit test case RnnGradientsReusesCapacity to verify GradientsAndOutputs capacity preservation.

Author: FFMG

include/neuralnetwork/layers/elmanrnnlayer.cpp

@@ -520,11 +520,12 @@ void ElmanRNNLayer::calculate_output_gradients(std::vector<GradientsAndOutputs>&
 {
   MYODDWEB_PROFILE_FUNCTION("ElmanRNNLayer");
   const size_t N_this = get_number_neurons();
+  std::vector<double> deltas;
   for (size_t b = 0; b < batch_size; ++b)
   {
     const auto& states = batch_hidden_states[b].at(get_layer_index());
     const size_t T = states.size();
-    std::vector<double> deltas(T * N_this);
+    deltas.resize(T * N_this);
     const std::vector<double>& targets = *(target_outputs_begin + b);
     for (size_t t = 0; t < T; ++t)
     {
@@ -544,7 +545,7 @@ void ElmanRNNLayer::calculate_output_gradients(std::vector<GradientsAndOutputs>&
     }
     double* dest_ptr = batch_gradients_and_outputs[b].get_gradients_raw(get_layer_index());
     std::copy(deltas.end() - N_this, deltas.end(), dest_ptr);
-    batch_gradients_and_outputs[b].set_rnn_gradients(get_layer_index(), std::move(deltas));
+    batch_gradients_and_outputs[b].set_rnn_gradients(get_layer_index(), deltas.data(), deltas.size());
   }
 }
 

include/neuralnetwork/layers/fflayer.cpp

@@ -818,6 +818,7 @@ void FFLayer::run_post_gemm_backward(
   MYODDWEB_PROFILE_FUNCTION("FFLayer");
 
   std::vector<double> deriv_buf(N_this);
+  std::vector<double> rnn_grads_row;
   for (size_t b = start; b < end; b++)
   {
     const auto& layer_states = batch_hidden_states[b].at(get_layer_index());
@@ -827,7 +828,7 @@ void FFLayer::run_post_gemm_backward(
       continue;
     }
 
-    std::vector<double> rnn_grads_row(num_time_steps * N_this, 0.0);
+    rnn_grads_row.assign(num_time_steps * N_this, 0.0);
 
     for (size_t t = 0; t < num_time_steps; ++t)
     {
@@ -859,7 +860,7 @@ void FFLayer::run_post_gemm_backward(
     {
       batch_gradients_and_outputs[b].set_gradients(get_layer_index(), rnn_grads_row.data() + rnn_grads_row.size() - N_this, N_this);
     }
-    batch_gradients_and_outputs[b].set_rnn_gradients(get_layer_index(), std::move(rnn_grads_row));
+    batch_gradients_and_outputs[b].set_rnn_gradients(get_layer_index(), rnn_grads_row.data(), rnn_grads_row.size());
   }
 }
 

include/neuralnetwork/layers/ffoutputlayer.cpp

@@ -269,36 +269,40 @@ void FFOutputLayer::run_output_gradients(
   const size_t num_time_steps = batch_hidden_states[0].at(get_layer_index()).size();
 
   std::vector<double> deriv_buf(num_neurons);
+  std::vector<double> rnn_grads_row;
+  std::vector<double> given_outputs_vec;
+  std::vector<double> current_target;
+  std::vector<double> deltas;
+
   for (size_t b = start; b < end; b++)
   {
     const auto& target_outputs = *(target_outputs_begin + b);
     const auto& layer_states = batch_hidden_states[b].at(get_layer_index());
-    std::vector<double> rnn_grads_row(num_time_steps * num_neurons, 0.0);
+    rnn_grads_row.assign(num_time_steps * num_neurons, 0.0);
 
     for (size_t t = 0; t < num_time_steps; ++t)
     {
       const auto& current_hidden_state = layer_states[t];
       const auto& given_outputs = current_hidden_state.get_hidden_state_values();
-      std::vector<double> given_outputs_vec(given_outputs.begin(), given_outputs.end());
+      given_outputs_vec.assign(given_outputs.begin(), given_outputs.end());
 
       // Determine target for this time step
-      std::vector<double> current_target;
       if (target_outputs.size() == num_time_steps * num_neurons)
       {
         current_target.assign(target_outputs.begin() + t * num_neurons, target_outputs.begin() + (t + 1) * num_neurons);
       }
       else if (t == num_time_steps - 1)
       {
         // Only one target provided, apply to the last step
-        current_target = target_outputs;
+        current_target.assign(target_outputs.begin(), target_outputs.end());
       }
       else
       {
         // No target for this step
         continue;
       }
 
-      std::vector<double> deltas(num_neurons, 0.0);
+      deltas.assign(num_neurons, 0.0);
       calculate_error_deltas(deltas, current_target, given_outputs_vec);
 
       const double* pre_act = current_hidden_state.get_pre_activation_sums().data();
@@ -346,7 +350,7 @@ void FFOutputLayer::run_output_gradients(
     {
       batch_gradients_and_outputs[b].set_gradients(get_layer_index(), rnn_grads_row.data() + rnn_grads_row.size() - num_neurons, num_neurons);
     }
-    batch_gradients_and_outputs[b].set_rnn_gradients(get_layer_index(), std::move(rnn_grads_row));
+    batch_gradients_and_outputs[b].set_rnn_gradients(get_layer_index(), rnn_grads_row.data(), rnn_grads_row.size());
   }
 }
 

include/neuralnetwork/layers/lstmlayer.cpp

@@ -668,25 +668,32 @@ void LSTMLayer::calculate_output_gradients(std::vector<GradientsAndOutputs>& bat
 {
   MYODDWEB_PROFILE_FUNCTION("LSTMLayer");
   const size_t N_this = get_number_neurons();
+  std::vector<double> deltas;
   for (size_t b = 0; b < batch_size; ++b)
   {
     const auto& states = batch_hidden_states[b].at(get_layer_index());
     const size_t T = states.size();
-    std::vector<double> deltas(T * N_this);
+    deltas.resize(T * N_this);
     const std::vector<double>& targets = *(target_outputs_begin + b);
     for (size_t t = 0; t < T; ++t)
     {
       const auto& given = states[t].get_hidden_state_values();
       for (size_t j = 0; j < N_this; ++j)
       {
         size_t idx = t * N_this + j;
-        if (idx < targets.size()) deltas[idx] = given[j] - targets[idx];
-        else deltas[idx] = 0.0;
+        if (idx < targets.size())
+        {
+          deltas[idx] = given[j] - targets[idx];
+        }
+        else
+        {
+          deltas[idx] = 0.0;
+        }
       }
     }
     double* dest_ptr = batch_gradients_and_outputs[b].get_gradients_raw(get_layer_index());
     std::copy(deltas.end() - N_this, deltas.end(), dest_ptr);
-    batch_gradients_and_outputs[b].set_rnn_gradients(get_layer_index(), std::move(deltas));
+    batch_gradients_and_outputs[b].set_rnn_gradients(get_layer_index(), deltas.data(), deltas.size());
   }
 }
 

tests/gradients_and_outputs_tests.cpp

@@ -192,3 +192,25 @@ TEST_F(GradientsAndOutputsTest, PointerOverloadsAndRawBuffers)
     gao.set_rnn_gate_gradients(2, rnn_gate_vals.data(), rnn_gate_vals.size());
     EXPECT_EQ(gao.get_rnn_gate_gradients(2), rnn_gate_vals);
 }
+
+TEST_F(GradientsAndOutputsTest, RnnGradientsReusesCapacity) {
+    GradientsAndOutputs gao(topology);
+    std::vector<double> rnn_grad_vals = {0.66, 0.77, 0.88, 0.99};
+    
+    // First assignment
+    gao.set_rnn_gradients(2, rnn_grad_vals.data(), rnn_grad_vals.size());
+    const auto& vec_ref = gao.get_rnn_gradients(2);
+    size_t initial_capacity = vec_ref.capacity();
+    EXPECT_GE(initial_capacity, 4);
+    
+    // Clear/zero
+    gao.zero();
+    EXPECT_TRUE(vec_ref.empty());
+    size_t capacity_after_clear = vec_ref.capacity();
+    EXPECT_EQ(capacity_after_clear, initial_capacity); // Capacity must be preserved by clear()
+    
+    // Re-assign (smaller size)
+    std::vector<double> new_vals = {1.1, 2.2};
+    gao.set_rnn_gradients(2, new_vals.data(), new_vals.size());
+    EXPECT_EQ(vec_ref.capacity(), capacity_after_clear); // Capacity must not change
+}