Improve element-wise tensor operation performance (#454)

transform_tensor previously used fplus::transform_convert, which calls
reserve() and writes via a back_insert_iterator. Because push_back
updates the vector's internal end pointer on every write, the compiler
cannot auto-vectorize the loop.

Switching to resize() with a plain random-access iterator allows GCC to
emit SIMD instructions. Additionally, relu_layer now takes a fast path
for the common standard ReLU case, using a simpler single-expression
lambda that is easier to optimize than the general three-branch version.

Combined effect: ~5% faster forward pass on VGG19.

Author: Dobiasd

include/fdeep/layers/relu_layer.hpp

@@ -9,6 +9,7 @@
 #include "fdeep/layers/activation_layer.hpp"
 
 #include <algorithm>
+#include <limits>
 #include <string>
 
 namespace fdeep {
@@ -30,14 +31,20 @@ namespace internal {
     protected:
         tensor transform_input(const tensor& in_vol) const override
         {
-            auto activation_function = [&](float_type x) -> float_type {
+            if (negative_slope_ == static_cast<float_type>(0) && threshold_ == static_cast<float_type>(0) && max_value_ == std::numeric_limits<float_type>::max()) {
+                return transform_tensor([](float_type x) -> float_type {
+                    return std::max(static_cast<float_type>(0), x);
+                },
+                    in_vol);
+            }
+            return transform_tensor([&](float_type x) -> float_type {
                 if (x >= max_value_)
                     return max_value_;
                 if (threshold_ <= x && x < max_value_)
                     return x;
                 return negative_slope_ * (x - threshold_);
-            };
-            return transform_tensor(activation_function, in_vol);
+            },
+                in_vol);
         }
         float_type max_value_;
         float_type negative_slope_;

include/fdeep/tensor.hpp

@@ -190,7 +190,10 @@ namespace internal {
     template <typename F>
     tensor transform_tensor(F f, const tensor& m)
     {
-        return tensor(m.shape(), fplus::transform_convert<float_vec>(f, *m.as_vector()));
+        const auto& src = *m.as_vector();
+        float_vec result(src.size());
+        std::transform(src.begin(), src.end(), result.begin(), f);
+        return tensor(m.shape(), std::move(result));
     }
 
     inline std::vector<tensor> tensor_to_depth_slices(const tensor& m)