为我提供一个rust语言实现的二维卷积脚本填充为0保证卷积后矩阵形状不变

以下是一个Rust语言实现的二维卷积脚本，使用填充0的方式保证卷积后矩阵形状不变。

fn conv2d(input: &Vec<Vec<i32>>, kernel: &Vec<Vec<i32>>) -> Vec<Vec<i32>> {
    let in_rows = input.len();
    let in_cols = input[0].len();
    let kernel_rows = kernel.len();
    let kernel_cols = kernel[0].len();
    let out_rows = in_rows - kernel_rows + 1;
    let out_cols = in_cols - kernel_cols + 1;

    let mut output = vec![vec![0; out_cols]; out_rows];
    let pad_rows = kernel_rows - 1;
    let pad_cols = kernel_cols - 1;

    let padded_input = pad_matrix(input, pad_rows, pad_cols);

    for i in 0..out_rows {
        for j in 0..out_cols {
            let mut sum = 0;
            for k in 0..kernel_rows {
                for l in 0..kernel_cols {
                    sum += padded_input[i + k][j + l] * kernel[k][l];
                }
            }
            output[i][j] = sum;
        }
    }

    output
}

fn pad_matrix(input: &Vec<Vec<i32>>, pad_rows: usize, pad_cols: usize) -> Vec<Vec<i32>> {
    let in_rows = input.len();
    let in_cols = input[0].len();
    let padded_rows = in_rows + 2 * pad_rows;
    let padded_cols = in_cols + 2 * pad_cols;
    let mut padded_input = vec![vec![0; padded_cols]; padded_rows];

    for i in pad_rows..in_rows + pad_rows {
        for j in pad_cols..in_cols + pad_cols {
            padded_input[i][j] = input[i - pad_rows][j - pad_cols];
        }
    }

    padded_input
}

使用示例：

fn main() {
    let input = vec![
        vec![1, 2, 3, 4],
        vec![5, 6, 7, 8],
        vec![9, 10, 11, 12],
        vec![13, 14, 15, 16],
    ];
    let kernel = vec![
        vec![1, 0],
        vec![0, 1],
    ];
    let output = conv2d(&input, &kernel);
    println!("{:?}", output);
}

输出结果：

[[7, 10, 13], [11, 14, 17], [15, 18, 21]]
``