Rename shapeN_concrete back to shapeN

Author: Dobiasd

README.md

@@ -144,7 +144,7 @@ int main()
 {
     const auto model = fdeep::load_model("fdeep_model.json");
     const auto result = model.predict(
-        {fdeep::tensor3(fdeep::shape3_concrete(4, 1, 1), {1, 2, 3, 4})});
+        {fdeep::tensor3(fdeep::shape3(4, 1, 1), {1, 2, 3, 4})});
     std::cout << fdeep::show_tensor3s(result) << std::endl;
 }
 ```

include/fdeep/convolution.hpp

@@ -21,15 +21,15 @@ namespace fdeep { namespace internal
 struct im2col_filter_matrix
 {
     RowMajorMatrixXf mat_;
-    shape3_concrete filter_shape_;
+    shape3 filter_shape_;
     std::size_t filter_count_;
 };
 
 inline im2col_filter_matrix generate_im2col_filter_matrix(
     const std::vector<filter>& filters)
 {
     assertion(fplus::all_the_same_on(
-        fplus_c_mem_fn_t(filter, shape, shape3_concrete), filters),
+        fplus_c_mem_fn_t(filter, shape, shape3), filters),
         "all filters must have the same shape");
 
     const std::size_t fz = filters.front().shape().depth_;
@@ -133,7 +133,7 @@ inline tensor3 convolve_im2col(
     // https://stackoverflow.com/questions/48644724/multiply-two-eigen-matrices-directly-into-memory-of-target-matrix
     out_mat_map.noalias() = filter_mat.mat_ * a;
 
-    return tensor3(shape3_concrete(out_depth, out_height, out_width), res_vec);
+    return tensor3(shape3(out_depth, out_height, out_width), res_vec);
 }
 
 enum class padding { valid, same };
@@ -151,11 +151,11 @@ struct convolution_config
 };
 
 inline convolution_config preprocess_convolution(
-    const shape2_concrete& filter_shape,
-    const shape2_concrete& strides,
+    const shape2& filter_shape,
+    const shape2& strides,
     padding pad_type,
     bool use_offset,
-    const shape3_concrete& input_shape)
+    const shape3& input_shape)
 {
     // https://www.tensorflow.org/api_guides/python/nn#Convolution
     const int filter_height = static_cast<int>(filter_shape.height_);
@@ -217,7 +217,7 @@ inline convolution_config preprocess_convolution(
 }
 
 inline tensor3 convolve(
-    const shape2_concrete& strides,
+    const shape2& strides,
     const padding& pad_type,
     bool use_offset,
     const im2col_filter_matrix& filter_mat,
@@ -247,14 +247,14 @@ inline tensor3 convolve(
 }
 
 inline tensor3 convolve_transpose(
-    const shape2_concrete&,
+    const shape2&,
     const padding&,
     bool,
     const std::vector<filter>&,
     const tensor3&)
 {
     raise_error("convolve_transpose not yet implemented");
-    return tensor3(shape3_concrete(0, 0, 0), 0);
+    return tensor3(shape3(0, 0, 0), 0);
 }
 
 } } // namespace fdeep, namespace internal

include/fdeep/fdeep.hpp

@@ -15,9 +15,9 @@
 #include "fdeep/tensor3.hpp"
 #include "fdeep/tensor3_pos.hpp"
 #include "fdeep/node.hpp"
-#include "fdeep/shape2_concrete.hpp"
+#include "fdeep/shape2.hpp"
 #include "fdeep/shape2_variable.hpp"
-#include "fdeep/shape3_concrete.hpp"
+#include "fdeep/shape3.hpp"
 #include "fdeep/shape3_variable.hpp"
 #include "fdeep/layers/add_layer.hpp"
 #include "fdeep/layers/average_layer.hpp"

include/fdeep/filter.hpp

@@ -9,7 +9,7 @@
 #include "fdeep/common.hpp"
 
 #include "fdeep/tensor3.hpp"
-#include "fdeep/shape3_concrete.hpp"
+#include "fdeep/shape3.hpp"
 
 #include <cassert>
 #include <cstddef>
@@ -24,7 +24,7 @@ class filter
     filter(const tensor3& m, float_type bias) : m_(m), bias_(bias)
     {
     }
-    const shape3_concrete& shape() const
+    const shape3& shape() const
     {
         return m_.shape();
     }
@@ -58,15 +58,15 @@ class filter
 
 typedef std::vector<filter> filter_vec;
 
-inline filter dilate_filter(const shape2_concrete& dilation_rate, const filter& undilated)
+inline filter dilate_filter(const shape2& dilation_rate, const filter& undilated)
 {
     return filter(dilate_tensor3(dilation_rate, undilated.get_tensor3()),
         undilated.get_bias());
 }
 
 inline filter_vec generate_filters(
-    const shape2_concrete& dilation_rate,
-    const shape3_concrete& filter_shape, std::size_t k,
+    const shape2& dilation_rate,
+    const shape3& filter_shape, std::size_t k,
     const float_vec& weights, const float_vec& bias)
 {
     filter_vec filters(k, filter(tensor3(filter_shape, 0), 0));

include/fdeep/import_model.hpp

@@ -68,37 +68,37 @@ inline shape3_variable create_shape3_variable(const nlohmann::json& data)
         fplus::nothing<std::size_t>()); // Should never be called
 }
 
-inline shape3_concrete create_shape3_concrete(const nlohmann::json& data)
+inline shape3 create_shape3(const nlohmann::json& data)
 {
-    assertion(data.is_array(), "shape3_concrete needs to be an array");
+    assertion(data.is_array(), "shape3 needs to be an array");
     assertion(data.size() > 0, "need at least one dimension");
     //TODO: offset still needed?
     const std::size_t offset = data.front().is_null() ? 1 : 0;
     if (data.size() == 1 + offset)
-        return shape3_concrete(0, 0, data[0 + offset]);
+        return shape3(0, 0, data[0 + offset]);
     if (data.size() == 2 + offset)
-        return shape3_concrete(0, data[0 + offset], data[1 + offset]);
+        return shape3(0, data[0 + offset], data[1 + offset]);
     if (data.size() == 3 + offset)
-        return shape3_concrete(data[0 + offset], data[1 + offset], data[2 + offset]);
-    raise_error("shape3_concrete needs 1, 2 or 3 dimensions");
-    return shape3_concrete(0, 0, 0); // Should never be called
+        return shape3(data[0 + offset], data[1 + offset], data[2 + offset]);
+    raise_error("shape3 needs 1, 2 or 3 dimensions");
+    return shape3(0, 0, 0); // Should never be called
 }
 
-inline shape2_concrete create_shape2_concrete(const nlohmann::json& data)
+inline shape2 create_shape2(const nlohmann::json& data)
 {
     if (data.is_array())
     {
         assertion(data.size() == 1 || data.size() == 2,
-            "invalid number of dimensions in shape2_concrete");
+            "invalid number of dimensions in shape2");
         if (data.size() == 1)
-            return shape2_concrete(1, data[0]);
+            return shape2(1, data[0]);
         else
-            return shape2_concrete(data[0], data[1]);
+            return shape2(data[0], data[1]);
     }
     else
     {
         const std::size_t width = data;
-        return shape2_concrete(1, width);
+        return shape2(1, width);
     }
 }
 
@@ -146,7 +146,7 @@ inline float_vec decode_floats(const nlohmann::json& data)
 
 inline tensor3 create_tensor3(const nlohmann::json& data)
 {
-    const shape3_concrete shape = create_shape3_concrete(data["shape"]);
+    const shape3 shape = create_shape3(data["shape"]);
     return tensor3(shape, decode_floats(data["values"]));
 }
 
@@ -222,8 +222,8 @@ inline layer_ptr create_conv_2d_layer(const get_param_f& get_param,
     const std::string padding_str = data["config"]["padding"];
     const auto pad_type = create_padding(padding_str);
 
-    const shape2_concrete strides = create_shape2_concrete(data["config"]["strides"]);
-    const shape2_concrete dilation_rate = create_shape2_concrete(data["config"]["dilation_rate"]);
+    const shape2 strides = create_shape2(data["config"]["strides"]);
+    const shape2 dilation_rate = create_shape2(data["config"]["dilation_rate"]);
 
     const auto filter_count = create_size_t(data["config"]["filters"]);
     float_vec bias(filter_count, 0);
@@ -233,12 +233,12 @@ inline layer_ptr create_conv_2d_layer(const get_param_f& get_param,
     assertion(bias.size() == filter_count, "size of bias does not match");
 
     const float_vec weights = decode_floats(get_param(name, "weights"));
-    const shape2_concrete kernel_size = create_shape2_concrete(data["config"]["kernel_size"]);
+    const shape2 kernel_size = create_shape2(data["config"]["kernel_size"]);
     assertion(weights.size() % kernel_size.area() == 0,
         "invalid number of weights");
     const std::size_t filter_depths =
         weights.size() / (kernel_size.area() * filter_count);
-    const shape3_concrete filter_shape(
+    const shape3 filter_shape(
         filter_depths, kernel_size.height_, kernel_size.width_);
 
     const bool padding_valid_uses_offset_depth_1 =
@@ -263,7 +263,7 @@ inline layer_ptr create_conv_2d_transpose_layer(const get_param_f& get_param,
     const std::string padding_str = data["config"]["padding"];
     const auto pad_type = create_padding(padding_str);
 
-    const shape2_concrete strides = create_shape2_concrete(data["config"]["strides"]);
+    const shape2 strides = create_shape2(data["config"]["strides"]);
 
     const auto filter_count = create_size_t(data["config"]["filters"]);
     float_vec bias(filter_count, 0);
@@ -273,12 +273,12 @@ inline layer_ptr create_conv_2d_transpose_layer(const get_param_f& get_param,
     assertion(bias.size() == filter_count, "size of bias does not match");
 
     const float_vec weights = decode_floats(get_param(name, "weights"));
-    const shape2_concrete kernel_size = create_shape2_concrete(data["config"]["kernel_size"]);
+    const shape2 kernel_size = create_shape2(data["config"]["kernel_size"]);
     assertion(weights.size() % kernel_size.area() == 0,
         "invalid number of weights");
     const std::size_t filter_depths =
         weights.size() / (kernel_size.area() * filter_count);
-    const shape3_concrete filter_shape(
+    const shape3 filter_shape(
         filter_depths, kernel_size.height_, kernel_size.width_);
 
     const bool padding_valid_uses_offset_depth_1 =
@@ -303,8 +303,8 @@ inline layer_ptr create_separable_conv_2D_layer(const get_param_f& get_param,
     const std::string padding_str = data["config"]["padding"];
     const auto pad_type = create_padding(padding_str);
 
-    const shape2_concrete strides = create_shape2_concrete(data["config"]["strides"]);
-    const shape2_concrete dilation_rate = create_shape2_concrete(data["config"]["dilation_rate"]);
+    const shape2 strides = create_shape2(data["config"]["strides"]);
+    const shape2 dilation_rate = create_shape2(data["config"]["dilation_rate"]);
 
     const auto filter_count = create_size_t(data["config"]["filters"]);
     float_vec bias(filter_count, 0);
@@ -317,7 +317,7 @@ inline layer_ptr create_separable_conv_2D_layer(const get_param_f& get_param,
         get_param(name, "slice_weights"));
     const float_vec stack_weights = decode_floats(
         get_param(name, "stack_weights"));
-    const shape2_concrete kernel_size = create_shape2_concrete(data["config"]["kernel_size"]);
+    const shape2 kernel_size = create_shape2(data["config"]["kernel_size"]);
     assertion(slice_weights.size() % kernel_size.area() == 0,
         "invalid number of weights");
     assertion(stack_weights.size() % filter_count == 0,
@@ -326,7 +326,7 @@ inline layer_ptr create_separable_conv_2D_layer(const get_param_f& get_param,
     const std::size_t stack_output_depths_1 =
         stack_weights.size() / input_depth;
     assertion(stack_output_depths_1 == filter_count, "invalid weights sizes");
-    const shape3_concrete filter_shape(1,
+    const shape3 filter_shape(1,
         kernel_size.height_, kernel_size.width_);
     float_vec bias_0(input_depth, 0);
     const bool padding_valid_uses_offset_depth_1 =
@@ -351,16 +351,16 @@ inline layer_ptr create_depthwise_conv_2D_layer(const get_param_f& get_param,
     const std::string padding_str = data["config"]["padding"];
     const auto pad_type = create_padding(padding_str);
 
-    const shape2_concrete strides = create_shape2_concrete(data["config"]["strides"]);
-    const shape2_concrete dilation_rate = create_shape2_concrete(data["config"]["dilation_rate"]);
+    const shape2 strides = create_shape2(data["config"]["strides"]);
+    const shape2 dilation_rate = create_shape2(data["config"]["dilation_rate"]);
 
     const float_vec slice_weights = decode_floats(
         get_param(name, "slice_weights"));
-    const shape2_concrete kernel_size = create_shape2_concrete(data["config"]["kernel_size"]);
+    const shape2 kernel_size = create_shape2(data["config"]["kernel_size"]);
     assertion(slice_weights.size() % kernel_size.area() == 0,
         "invalid number of weights");
     const std::size_t input_depth = slice_weights.size() / kernel_size.area();
-    const shape3_concrete filter_shape(1,
+    const shape3 filter_shape(1,
         kernel_size.height_, kernel_size.width_);
     const std::size_t filter_count = input_depth;
     float_vec bias(filter_count, 0);
@@ -423,8 +423,8 @@ inline layer_ptr create_max_pooling_2d_layer(
     const get_param_f&, const get_global_param_f& get_global_param,
     const nlohmann::json& data, const std::string& name)
 {
-    const auto pool_size = create_shape2_concrete(data["config"]["pool_size"]);
-    const auto strides = create_shape2_concrete(data["config"]["strides"]);
+    const auto pool_size = create_shape2(data["config"]["pool_size"]);
+    const auto strides = create_shape2(data["config"]["strides"]);
     const std::string padding_str = data["config"]["padding"];
     const auto pad_type = create_padding(padding_str);
     const bool padding_valid_uses_offset =
@@ -441,8 +441,8 @@ inline layer_ptr create_average_pooling_2d_layer(
     const get_param_f&, const get_global_param_f& get_global_param,
     const nlohmann::json& data, const std::string& name)
 {
-    const auto pool_size = create_shape2_concrete(data["config"]["pool_size"]);
-    const auto strides = create_shape2_concrete(data["config"]["strides"]);
+    const auto pool_size = create_shape2(data["config"]["pool_size"]);
+    const auto strides = create_shape2(data["config"]["strides"]);
     const std::string padding_str = data["config"]["padding"];
     const auto pad_type = create_padding(padding_str);
     const bool padding_valid_uses_offset =
@@ -473,7 +473,7 @@ inline layer_ptr create_upsampling_2d_layer(
     const get_param_f&, const get_global_param_f&, const nlohmann::json& data,
     const std::string& name)
 {
-    const auto scale_factor = create_shape2_concrete(data["config"]["size"]);
+    const auto scale_factor = create_shape2(data["config"]["size"]);
     return std::make_shared<upsampling_2d_layer>(name, scale_factor);
 }
 

include/fdeep/layers/average_pooling_2d_layer.hpp

@@ -24,8 +24,8 @@ FDEEP_FORCE_INLINE tensor3 average_pool_2d(
     const float_type invalid = std::numeric_limits<float_type>::lowest();
 
     const auto conv_cfg = preprocess_convolution(
-        shape2_concrete(pool_height, pool_width),
-        shape2_concrete(strides_y, strides_x),
+        shape2(pool_height, pool_width),
+        shape2(strides_y, strides_x),
         pad_type, use_offset, in.shape());
 
     int pad_top_int = static_cast<int>(conv_cfg.pad_top_);
@@ -35,7 +35,7 @@ FDEEP_FORCE_INLINE tensor3 average_pool_2d(
     const std::size_t out_height = conv_cfg.out_height_;
     const std::size_t out_width = conv_cfg.out_width_;
 
-    tensor3 out(shape3_concrete(in.shape().depth_, out_height, out_width), 0);
+    tensor3 out(shape3(in.shape().depth_, out_height, out_width), 0);
     for (std::size_t z = 0; z < out.shape().depth_; ++z)
     {
         for (std::size_t y = 0; y < out.shape().height_; ++y)
@@ -70,7 +70,7 @@ class average_pooling_2d_layer : public pooling_2d_layer
 {
 public:
     explicit average_pooling_2d_layer(const std::string& name,
-        const shape2_concrete& pool_size, const shape2_concrete& strides, padding p,
+        const shape2& pool_size, const shape2& strides, padding p,
         bool padding_valid_uses_offset, bool padding_same_uses_offset) :
         pooling_2d_layer(name, pool_size, strides, p,
             padding_valid_uses_offset, padding_same_uses_offset)
@@ -79,9 +79,9 @@ class average_pooling_2d_layer : public pooling_2d_layer
 protected:
     tensor3 pool(const tensor3& in) const override
     {
-        if (pool_size_ == shape2_concrete(2, 2) && strides_ == shape2_concrete(2, 2))
+        if (pool_size_ == shape2(2, 2) && strides_ == shape2(2, 2))
             return average_pool_2d(2, 2, 2, 2, padding_, use_offset(), in);
-        else if (pool_size_ == shape2_concrete(4, 4) && strides_ == shape2_concrete(4, 4))
+        else if (pool_size_ == shape2(4, 4) && strides_ == shape2(4, 4))
             return average_pool_2d(4, 4, 4, 4, padding_, use_offset(), in);
         else
             return average_pool_2d(

include/fdeep/layers/conv_2d_layer.hpp

@@ -8,8 +8,8 @@
 
 #include "fdeep/convolution.hpp"
 #include "fdeep/filter.hpp"
-#include "fdeep/shape2_concrete.hpp"
-#include "fdeep/shape3_concrete.hpp"
+#include "fdeep/shape2.hpp"
+#include "fdeep/shape3.hpp"
 #include "fdeep/layers/layer.hpp"
 
 #include <fplus/fplus.hpp>
@@ -25,13 +25,13 @@ class conv_2d_layer : public layer
 {
 public:
     explicit conv_2d_layer(
-            const std::string& name, const shape3_concrete& filter_shape,
-            std::size_t k, const shape2_concrete& strides, padding p,
+            const std::string& name, const shape3& filter_shape,
+            std::size_t k, const shape2& strides, padding p,
             bool padding_valid_offset_depth_1,
             bool padding_same_offset_depth_1,
             bool padding_valid_offset_depth_2,
             bool padding_same_offset_depth_2,
-            const shape2_concrete& dilation_rate,
+            const shape2& dilation_rate,
             const float_vec& weights, const float_vec& bias)
         : layer(name),
         filters_(generate_im2col_filter_matrix(
@@ -60,7 +60,7 @@ class conv_2d_layer : public layer
             filters_, inputs.front())};
     }
     im2col_filter_matrix filters_;
-    shape2_concrete strides_;
+    shape2 strides_;
     padding padding_;
     bool padding_valid_offset_depth_1_;
     bool padding_same_offset_depth_1_;