convolutional_layer.h

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-only
// Copyright (C) 2026 Artificial Intelligence Techniques, S.L. and Roberto López González
 
#pragma once
 
#include <cstdio>
#include "opennn/network/layers/layer.h"
#include "opennn/network/operators/activation_operator.h"
#include "opennn/network/operators/batch_norm_operator.h"
#include "opennn/network/operators/convolution_operator.h"
 
namespace opennn
{
 
class Convolutional final : public Layer
{
public:
 
    Convolutional(const Shape& = {3, 3, 1},
                  const Shape& = {3, 3, 1, 1},
                  const string& = "Identity",
                  const Shape& = {1, 1},
                  const string& = "Valid",
                  BatchNormalization = BatchNormalization::No,
                  const string& = "convolutional_layer");
 
    Shape get_input_shape() const noexcept override
    { return {convolution.input_height, convolution.input_width, input_channels}; }
    Shape get_output_shape() const override;
 
    Index get_output_height() const;
    Index get_output_width() const;
 
    Index get_kernel_height() const noexcept { return convolution.kernel_height; }
    Index get_kernel_width() const noexcept { return convolution.kernel_width; }
    Index get_kernel_channels() const noexcept { return convolution.kernel_channels; }
    Index get_kernels_number() const noexcept { return convolution.kernels_number; }
 
    Index get_row_stride() const noexcept { return convolution.row_stride; }
    Index get_column_stride() const noexcept { return convolution.column_stride; }
 
    Index get_padding_height() const;
    Index get_padding_width() const;
 
    ActivationFunction get_activation_function() const noexcept { return activation_operator.activation_function; }
    ActivationFunction get_output_activation() const noexcept override { return activation_operator.activation_function; }
 
    bool get_batch_normalization() const { return batch_norm.active(); }
 
    void get_folded_parameters(vector<float>& kernel_oihw, vector<float>& bias) const;
 
    bool get_residual() const noexcept { return residual; }
    Index get_sources_number() const noexcept override { return residual ? 2 : 1; }
    void set_residual(bool new_residual);
 
    vector<TensorSpec> get_forward_specs(Index) const override;
    vector<TensorSpec> get_backward_specs(Index) const override;
    bool backward_uses_forward_output() const noexcept override { return get_output_activation() != ActivationFunction::Identity; }
    bool backward_uses_input(size_t input) const noexcept override { return input != 1 || !residual; }
    ForwardSlotKind get_forward_slot_kind(size_t slot) const override
    {
        return slot == ReluMask ? ForwardSlotKind::TrainingOnly : ForwardSlotKind::Pooled;
    }
    // With batch normalization folded into the weights, inference convolves
    // straight into the output slot and never writes ConvolutionView -- so the
    // arena was reserving a second full activation per layer that nothing
    // touched. The guard mirrors forward_propagate_folded's own, because the
    // unfolded fallback still writes the slot: no CUDA build, activations off
    // the device, or weights outside fp32/bf16 all keep it.
    bool is_forward_slot_inference_elidable(size_t slot, Device device) const noexcept override
    {
#ifdef OPENNN_HAS_CUDA
        return slot == ConvolutionView
            && batch_norm.active()
            && device == Device::CUDA
            && (weights_dtype == Type::FP32 || weights_dtype == Type::BF16);
#else
        (void)slot; (void)device;
        return false;
#endif
    }
    bool folds_input_delta_addend(size_t input) const noexcept override { return input == 0; }
    size_t get_recomputable_forward_slot() const noexcept override
    {
        return batch_norm.active() ? size_t(ConvolutionView) : SIZE_MAX;
    }
    void recompute_forward_slot(ForwardPropagation&, size_t) override;
 
    void set(const Shape& = {0, 0, 0},
             const Shape& = {3, 3, 1, 1},
             const string& = "Identity",
             const Shape& = {1, 1},
             const string& = "Valid",
             BatchNormalization = BatchNormalization::No,
             const string& = "convolutional_layer");
 
    bool accepts_input_rank(Index rank) const override { return is_one_of(rank, 3); }
 
    void apply_input_shape(const Shape&) override;
 
    void on_compute_dtype_changed() override { update_convolution_operator(); }
 
    void set_activation_function(const string&);
    void set_batch_normalization(bool new_batch_normalization);
 
    void load_darknet_weights(FILE*);
 
    // ONNX weight loaders — kernels are expected in NCHW layout (Ultralytics/PyTorch).
    // Ultralytics ONNX export folds BN into conv: folded_conv_bn takes the BN-folded
    // kernel and bias (no separate BN tensors) and stores them with identity BN so
    // inference is mathematically equivalent.
    void load_onnx_folded_conv_bn(const float* kernel_nchw, const float* folded_bias);
    void load_onnx_conv_bias(const float* bias, const float* kernel_nchw);
    void reinit_onnx_cls_out(float prior_bias);
 
    void read_JSON_body(const Json*) override;
    void write_JSON_body(JsonWriter&) const override;
    void on_loaded() override { update_convolution_operator(); }
 
    void forward_propagate(ForwardPropagation&, size_t, ForwardPropagationMode) override;
 
private:
 
#ifdef OPENNN_HAS_CUDA
    Buffer folded_parameters;
    bool   folded_dirty = true;
 
    bool forward_propagate_folded(ForwardPropagation&, size_t);
#endif
 
    Index input_channels = 0;
 
    bool use_padding = false;
    bool residual = false;
 
    ConvolutionOperator convolution;
    ActivationOperator  activation_operator;
    BatchNormalizationOperator   batch_norm;
 
    enum Forward {Input, ConvolutionView, BatchNormMean, BatchNormInverseVariance, ReluMask, Output};
 
    void update_convolution_operator();
};
 
}