Convolution 1D CNTK C++ about cntk HOT 1 OPEN

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>

// Define a 1D convolution function
std::vector<float> conv1D(std::vector<float> input, std::vector<float> filter, int stride) {
    int input_size = input.size();
    int filter_size = filter.size();
    int output_size = (input_size - filter_size) / stride + 1;

    // Pad the input data with zeros
    int padding = filter_size / 2;
    std::vector<float> padded_input(input_size + 2 * padding, 0);
    std::copy(input.begin(), input.end(), padded_input.begin() + padding);

    // Perform convolution
    std::vector<float> output(output_size);
    for (int i = 0; i < output_size; i++) {
        int start = i * stride;
        int end = start + filter_size;
        std::vector<float> window(padded_input.begin() + start, padded_input.begin() + end);
        output[i] = std::inner_product(window.begin(), window.end(), filter.begin(), 0.0f);
    }

    return output;
}

int main() {
    // Define input data
    int input_size = 20000;
    std::vector<float> input_data(input_size, 1.0f);
    std::vector<int> input_shape = {500, 40};

    // Reshape input data
    int batch_size = input_shape[0];
    int input_dim = input_shape[1];
    std::vector<float> reshaped_input(batch_size * input_dim);
    for (int i = 0; i < batch_size; i++) {
        std::vector<float> input_row(input_data.begin() + i * input_dim, input_data.begin() + (i + 1) * input_dim);
        std::copy(input_row.begin(), input_row.end(), reshaped_input.begin() + i * input_dim);
    }

    // Define convolution filter
    int filter_size = 3;
    int num_filters = 512;
    std::vector<float> filter(filter_size * num_filters, 1.0f);

    // Perform convolution
    int stride = 1;
    std::vector<float> output = conv1D(reshaped_input, filter, stride);

    // Reshape output data
    int output_dim = num_filters;
    std::vector<int> output_shape = {batch_size, output_dim};
    std::vector<float> reshaped_output(batch_size * output_dim);
    for (int i = 0; i < batch_size; i++) {
        std::vector<float> output_row(output.begin() + i * output_dim, output.begin() + (i + 1) * output_dim);
        std::copy(output_row.begin(), output_row.end(), reshaped_output.begin() + i * output_dim);
    }

    std::cout << "Output shape: " << batch_size << "x" << output_dim << std::endl;
    return 0;
}