4D Convolution

conv4d.cpp

#include <iostream>
#include <vector>

using namespace std;

vector<vector<vector<vector<float>>>> Conv4D(
    vector<vector<vector<vector<float>>>> image,
    vector<vector<vector<vector<float>>>> kernel,
    int stride,
    int padding)
{
    int image_depth = image.size();
    int image_height = image[0].size();
    int image_width = image[0][0].size();
    int image_channels = image[0][0][0].size();
    int kernel_depth = kernel.size();
    int kernel_height = kernel[0].size();
    int kernel_width = kernel[0][0].size();
    int kernel_channels = kernel[0][0][0].size();
    int output_depth = (image_depth - kernel_depth + 2 * padding) / stride + 1;
    int output_height = (image_height - kernel_height + 2 * padding) / stride + 1;
    int output_width = (image_width - kernel_width + 2 * padding) / stride + 1;
    int output_channels = kernel_channels;

    // Initialize output tensor with zeros
    vector<vector<vector<vector<float>>>> output(
        output_depth,
        vector<vector<vector<float>>>(
            output_height,
            vector<vector<float>>(
                output_width,
                vector<float>(output_channels, 0.0))));

    // Pad input tensor
    vector<vector<vector<vector<float>>>> padded_image(
        image_depth + 2 * padding,
        vector<vector<vector<float>>>(
            image_height + 2 * padding,
            vector<vector<float>>(
                image_width + 2 * padding,
                vector<float>(image_channels, 0.0))));

    for (int d = 0; d < image_depth; d++) {
        for (int i = 0; i < image_height; i++) {
            for (int j = 0; j < image_width; j++) {
                for (int c = 0; c < image_channels; c++) {
                    padded_image[d + padding][i + padding][j + padding][c] = image[d][i][j][c];
                }
            }
        }
    }

    // Perform 4D convolution
    for (int z = 0; z < output_depth; z++) {
        for (int y = 0; y < output_height; y++) {
            for (int x = 0; x < output_width; x++) {
                for (int c = 0; c < output_channels; c++) {
                    for (int kd = 0; kd < kernel_depth; kd++) {
                        for (int kh = 0; kh < kernel_height; kh++) {
                            for (int kw = 0; kw < kernel_width; kw++) {
                                for (int cc = 0; cc < kernel_channels; cc++) {
                                    output[z][y][x][c] += padded_image[z * stride + kd][y * stride + kh][x * stride + kw][cc] * kernel[kd][kh][kw][cc];
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    return output;
}