Address review findings

C++ correctness:
- Fix UB: MappedRowMajorMatrixXf used Eigen::Aligned over std::vector data
  which is not SIMD-aligned. Switch the typedef to const + Unaligned and
  drop the const_cast at every call site.
- IntegerLookup: replace abs(v) UB at INT64_MIN with a single-OOV-bucket
  assertion (Keras hashes OOV across multiple buckets via FarmHash, which
  fdeep does not currently replicate, so num_oov_indices > 1 is rejected).
- EinsumDense: assert rhs has at least 2 chars before slicing off the
  leading batch dim.
- GRU: replace silent zero-fallback for malformed bias with an explicit
  size assertion that respects reset_after.
- GroupedQueryAttention: assert num_key_value_heads > 0 before the modulo.
- AutoContrast removed from the passthrough dispatch — it transforms
  deterministically at inference and isn't actually a no-op.

Performance:
- EinsumDense: precompute summed_strides instead of recomputing the inner
  stride loop per output element.

Style:
- Make member fields const in newly-added layer classes for consistency
  with the rest of the codebase.
- show_bidirectional_layer: validate merge_mode and reject
  forward_layer.go_backwards explicitly.

Test coverage (added in get_test_model_recurrent):
- LSTM with return_state=True (h, c outputs) and unit_forget_bias=False.
- GroupedQueryAttention with num_query_heads == num_key_value_heads
  (= MultiHeadAttention) and with distinct K/V sequence lengths.
- ConvLSTM1D with dilation_rate, two ConvLSTM2D layers chained.
- GroupNormalization with groups=1 (= LayerNorm) and groups=n_features
  (= InstanceNorm).
- Discretization, Masking, RandomBrightness, RandomFlip, RandomCrop now
  exercised end-to-end.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Dobiasd

include/fdeep/common.hpp

@@ -80,7 +80,7 @@ namespace internal {
     using RowMajorMatrixXf = Eigen::Matrix<float_type, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
     using ArrayXf = Eigen::Array<float_type, Eigen::Dynamic, Eigen::Dynamic>;
     using ArrayXf1D = Eigen::Array<float_type, Eigen::Dynamic, 1>;
-    using MappedRowMajorMatrixXf = Eigen::Map<RowMajorMatrixXf, Eigen::Aligned>;
+    using MappedRowMajorMatrixXf = Eigen::Map<const RowMajorMatrixXf, Eigen::Unaligned>;
 
     inline float_type tanh_typed(float_type x)
     {

include/fdeep/import_model.hpp

@@ -1822,8 +1822,10 @@ namespace internal {
             { "RandomTranslation", create_identity_layer },
             { "RandomWidth", create_identity_layer },
             { "RandomZoom", create_identity_layer },
+            // AutoContrast is intentionally NOT registered as a passthrough:
+            // it applies a deterministic per-image min/max stretch even at
+            // inference. Supporting it would require a real implementation.
             { "AugMix", create_identity_layer },
-            { "AutoContrast", create_identity_layer },
             { "CutMix", create_identity_layer },
             { "Equalization", create_identity_layer },
             { "MaxNumBoundingBoxes", create_identity_layer },

include/fdeep/layers/adaptive_pooling_3d_layer.hpp

@@ -35,10 +35,10 @@ namespace internal {
         }
 
     protected:
-        std::size_t out_d4_;
-        std::size_t out_h_;
-        std::size_t out_w_;
-        adaptive_pooling_kind kind_;
+        const std::size_t out_d4_;
+        const std::size_t out_h_;
+        const std::size_t out_w_;
+        const adaptive_pooling_kind kind_;
 
         static std::size_t adapt_start(std::size_t i, std::size_t in_size, std::size_t out_size)
         {

include/fdeep/layers/conv_lstm_2d_layer.hpp

@@ -45,14 +45,14 @@ namespace internal {
         }
 
     protected:
-        std::size_t units_;
-        std::size_t rank_;
-        bool return_sequences_;
-        bool return_state_;
-        std::string activation_;
-        std::string recurrent_activation_;
-        conv_2d_layer input_conv_;
-        conv_2d_layer recurrent_conv_;
+        const std::size_t units_;
+        const std::size_t rank_;
+        const bool return_sequences_;
+        const bool return_state_;
+        const std::string activation_;
+        const std::string recurrent_activation_;
+        const conv_2d_layer input_conv_;
+        const conv_2d_layer recurrent_conv_;
 
         static tensor extract_timestep(const tensor& input, std::size_t t,
             std::size_t rank)

include/fdeep/layers/conv_lstm_3d_layer.hpp

@@ -43,13 +43,13 @@ namespace internal {
         }
 
     protected:
-        std::size_t units_;
-        bool return_sequences_;
-        bool return_state_;
-        std::string activation_;
-        std::string recurrent_activation_;
-        conv_3d_layer input_conv_;
-        conv_3d_layer recurrent_conv_;
+        const std::size_t units_;
+        const bool return_sequences_;
+        const bool return_state_;
+        const std::string activation_;
+        const std::string recurrent_activation_;
+        const conv_3d_layer input_conv_;
+        const conv_3d_layer recurrent_conv_;
 
         static tensor extract_timestep(const tensor& input, std::size_t t)
         {

include/fdeep/layers/discretization_layer.hpp

@@ -25,7 +25,7 @@ namespace internal {
         }
 
     protected:
-        std::vector<float_type> boundaries_;
+        const std::vector<float_type> boundaries_;
 
         tensors apply_impl(const tensors& inputs) const override
         {

include/fdeep/layers/einsum_dense_layer.hpp

@@ -37,16 +37,16 @@ namespace internal {
         }
 
     protected:
-        std::string equation_;
-        std::vector<int> full_output_shape_;
-        std::string bias_axes_;
-        tensor kernel_;
-        tensor bias_;
+        const std::string equation_;
+        const std::vector<int> full_output_shape_;
+        const std::string bias_axes_;
+        const tensor kernel_;
+        const tensor bias_;
 
-        std::string lhs_;
-        std::string rhs_kernel_;
-        std::string rhs_;
-        std::string summed_;
+        const std::string lhs_;
+        const std::string rhs_kernel_;
+        const std::string rhs_;
+        const std::string summed_;
 
         static std::string parse_lhs(const std::string& eq)
         {
@@ -157,6 +157,7 @@ namespace internal {
             const auto lhs_strides = compute_strides(lhs_sizes);
             const auto kernel_strides = compute_strides(kernel_sizes);
             const auto rhs_strides = compute_strides(rhs_sizes);
+            const auto summed_strides = compute_strides(summed_sizes);
 
             std::size_t out_volume = 1;
             for (auto sz : rhs_sizes)
@@ -189,11 +190,8 @@ namespace internal {
                     {
                         std::size_t rem = s_idx;
                         for (std::size_t i = 0; i < summed_.size(); ++i) {
-                            std::size_t stride = 1;
-                            for (std::size_t j = i + 1; j < summed_.size(); ++j)
-                                stride *= summed_sizes[j];
-                            pos[summed_[i]] = rem / stride;
-                            rem %= stride;
+                            pos[summed_[i]] = rem / summed_strides[i];
+                            rem %= summed_strides[i];
                         }
                     }
                     std::size_t lhs_offset = 0;
@@ -231,6 +229,8 @@ namespace internal {
 
             // Build the output tensor shape from rhs_sizes minus the leading
             // batch char (its size in fdeep is 1, dropped).
+            assertion(rhs_sizes.size() >= 2,
+                "EinsumDense output equation must have at least a batch char and one feature char.");
             std::vector<std::size_t> out_dims_no_batch(rhs_sizes.begin() + 1, rhs_sizes.end());
             return { tensor(create_tensor_shape_from_dims(out_dims_no_batch), std::move(out)) };
         }

include/fdeep/layers/group_normalization_layer.hpp

@@ -33,11 +33,11 @@ namespace internal {
         }
 
     protected:
-        std::size_t groups_;
-        int axis_;
-        float_type epsilon_;
-        float_vec beta_;
-        float_vec gamma_;
+        const std::size_t groups_;
+        const int axis_;
+        const float_type epsilon_;
+        const float_vec beta_;
+        const float_vec gamma_;
 
         tensors apply_impl(const tensors& inputs) const override
         {

include/fdeep/layers/group_query_attention_layer.hpp

@@ -29,17 +29,19 @@ namespace internal {
             , use_gate_(use_gate)
             , weights_(weights)
         {
+            assertion(num_kv_heads_ > 0,
+                "num_key_value_heads must be > 0.");
             assertion(num_query_heads_ % num_kv_heads_ == 0,
                 "num_query_heads must be divisible by num_key_value_heads.");
         }
 
     protected:
-        std::size_t head_dim_;
-        std::size_t num_query_heads_;
-        std::size_t num_kv_heads_;
-        bool use_bias_;
-        bool use_gate_;
-        std::vector<tensor> weights_;
+        const std::size_t head_dim_;
+        const std::size_t num_query_heads_;
+        const std::size_t num_kv_heads_;
+        const bool use_bias_;
+        const bool use_gate_;
+        const std::vector<tensor> weights_;
 
         // Weight order in Keras: Q, K, [Gate], V, Out, with bias right after each kernel.
         std::size_t weight_idx(std::size_t projection_idx) const

include/fdeep/layers/integer_lookup_layer.hpp

@@ -30,15 +30,20 @@ namespace internal {
             , vocab_offset_((has_mask_token ? 1 : 0) + num_oov_indices)
             , vocab_index_()
         {
+            // Keras hashes OOV inputs across multiple OOV buckets via FarmHash,
+            // which fdeep does not currently replicate. Restrict to a single
+            // OOV bucket (the common case) to keep behavior bit-identical.
+            assertion(num_oov_indices_ <= 1,
+                "IntegerLookup with num_oov_indices > 1 is not supported.");
             for (std::size_t i = 0; i < vocabulary.size(); ++i)
                 vocab_index_[vocabulary[i]] = i;
         }
 
     protected:
-        bool has_mask_token_;
-        std::int64_t mask_token_;
-        std::size_t num_oov_indices_;
-        std::size_t vocab_offset_;
+        const bool has_mask_token_;
+        const std::int64_t mask_token_;
+        const std::size_t num_oov_indices_;
+        const std::size_t vocab_offset_;
         std::unordered_map<std::int64_t, std::size_t> vocab_index_;
 
         tensors apply_impl(const tensors& inputs) const override
@@ -56,13 +61,9 @@ namespace internal {
                 if (it != vocab_index_.end()) {
                     out[i] = static_cast<float_type>(vocab_offset_ + it->second);
                 } else {
-                    // OOV bucket: floormod hash. With num_oov_indices=1, always 0
-                    // (offset by mask slot if present).
-                    const std::size_t oov_bucket = num_oov_indices_ == 0
-                        ? 0
-                        : (static_cast<std::size_t>(v < 0 ? -v : v) % num_oov_indices_);
-                    out[i] = static_cast<float_type>(
-                        (has_mask_token_ ? 1 : 0) + oov_bucket);
+                    // num_oov_indices_ <= 1 (asserted in ctor): OOV maps to 0,
+                    // shifted by 1 if a mask token occupies index 0.
+                    out[i] = static_cast<float_type>(has_mask_token_ ? 1 : 0);
                 }
             }
             return { tensor(input.shape(), std::move(out)) };