convolution_operator.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 "opennn/network/operators/operator.h"
 
namespace opennn
{
 
struct ConvolutionOperator : Operator
{
    Index input_height = 0;
    Index input_width = 0;
 
    Index kernels_number = 0;
    Index kernel_height = 0;
    Index kernel_width = 0;
    Index kernel_channels = 0;
    Index row_stride = 1;
    Index column_stride = 1;
 
    Index padding_height = 0;
    Index padding_width = 0;
 
    bool use_bias = true;
 
    TensorView weights;
    TensorView bias;
    TensorView weight_scale;
 
    TensorView weight_gradient;
    TensorView bias_gradient;
 
    bool fuse_relu = false;
 
    bool weights_relinked = true;
 
    struct ConvGraphCache;
 
    unique_ptr<ConvGraphCache> conv_graph_cache;
 
#ifdef OPENNN_HAS_CUDA
 
    void apply_gpu_folded(const TensorView& input,
                          const TensorView& folded_weights,
                          const TensorView& folded_bias,
                          bool relu, TensorView& output,
                          const TensorView* residual = nullptr) const;
#endif
 
    vector<TensorSpec> parameter_specs() const override;
    vector<SlotQuantization> parameter_quantization() const override;
    vector<ParameterSlot> parameter_slots() override;
    void link_parameters(span<const TensorView>) override;
    void link_parameter_scales(span<const TensorView>) override;
 
    void set_parameters_random() override;
    void set_parameters_glorot() override;
 
    ~ConvolutionOperator() override;
 
    ConvolutionOperator();
    ConvolutionOperator(const ConvolutionOperator&) = delete;
    ConvolutionOperator& operator=(const ConvolutionOperator&) = delete;
 
    void forward_propagate(ForwardPropagation&, size_t, ForwardPropagationMode) override;
    void back_propagate(ForwardPropagation&, BackPropagation&, size_t) const override;
 
private:
    void apply_cpu(const TensorView&, TensorView&) const;
    void apply_gpu(const TensorView&, TensorView&) const;
 
    // Lower bound on what a convolution has to move: read the input, read the
    // weights, write the output. cuDNN may move more depending on the algorithm
    // it picks -- an implicit-GEMM pass over a workspace, say -- but never less,
    // so a scope reporting a high fraction of peak against this is genuinely
    // bandwidth-bound while a low one only says the bound is loose.
    double minimum_traffic_bytes(const TensorView& input, const TensorView& output) const;
 
    void apply_delta_cpu(const TensorView&, const TensorView&,
                         TensorView&) const;
    void apply_delta_gpu(const TensorView&, const TensorView&,
                         TensorView&, const TensorView&) const;
};
 
}