Aparapi 无法解析最大值并回退到 CPU

Question

所以我在 Java 中设计了一个 CNN，我真的想要并行化卷积和池化。 这是我的方法（行、列、inputLayer、convLayer、poolLayer 和特性已经在构造函数中初始化）：

    int padding = 3;
    int filterSize = 2 * padding + 1;
    int[] input = new int[rows * columns];
    for(int r = 0; r < rows; r++)
        System.arraycopy(inputLayer[r], 0, input, r * columns, columns);
    int[] filters = new int[4 * filterSize * filterSize];
    for(int fl = 0; fl < 4; fl++)
        for(int fr = 0; fr < filterSize; fr++)
            System.arraycopy(features[fl][fr], 0, filters, fl * filterSize * filterSize + fr * filterSize, filterSize);
    float[] conv = new float[4 * rows * columns];
    float[] pool = new float[rows * columns];

    Range convRange = Range.create3D(columns, rows, 4, 2, 2, 2);
    Kernel convKernel = new Kernel(){
        int h = rows;
        int w = columns;
        int p = padding;
        int fs = filterSize;
        public void run(){
            int val = 0;
            int c = getGlobalId(0);
            int r = getGlobalId(1);
            int l = getGlobalId(2);
            int upper = max(0, p - r);
            int lower = min(fs, h + p - r);
            int left = max(0, p - c);
            int right = min(fs, w + p - c);
            for (int i = upper; i < lower; i++)
                for (int j = left; j < right; j++)
                    val += input[(r + i - p) * w + c + j - p] * filters[l * fs * fs + i * fs + j];
            conv[l * h * w + r * w + c] = Math.round(100.00f * val / fs) / 100.00f;
        }
    };
    convKernel.setExplicit(true);
    convKernel.put(input);
    convKernel.put(conv);
    convKernel.put(filters);
    convKernel.execute(convRange);
    convKernel.get(conv);
    for(int convL = 0; convL < 4; convL++)
        for(int convR = 0; convR < rows; convR++)
            System.arraycopy(conv, convL * rows * columns + convR * columns, convLayer[convL][convR], 0, columns);

    Range poolRange = Range.create3D(columns / 2, rows / 2, 4, 2, 2, 2);
    Kernel poolKernel = new Kernel(){
        public void run(){
            int wt = columns;
            int ht = rows;
            float val = 0.00f;
            int c = getGlobalId(0);
            int r = getGlobalId(1);
            int l = getGlobalId(2);
            for(int i = 0; i < 2; i++)
                for(int j = 0; j < 2; j++)
                    val = max(val, leakyReLU(conv[l * ht * wt + (2 * r + i) * wt + 2 * c + j]));
            pool[(l * ht * wt / 4) + (r * wt / 2) + c] = Math.round(100.00f * val) / 100.00f;
        }
    };
    poolKernel.setExplicit(true);
    poolKernel.put(conv);
    poolKernel.put(pool);
    poolKernel.execute(poolRange);
    poolKernel.get(pool);
    for(int poolL = 0; poolL < 4; poolL++)
        for(int poolR = 0; poolR < rows / 2; poolR++)
            System.arraycopy(pool, (poolL * rows * columns / 4) + (poolR * columns / 2), poolLayer[poolL][poolR], 0, columns / 2);

不是最漂亮的代码，但我已经很久没有使用过 Java，更不用说 Aparapi 了。

最初我直接使用原来的 arrays，但是 api 显示一条消息，它不支持它们并切换到原生模式。 将所有内容转换为 1d arrays 应该可以工作，但现在我收到此消息：

VIII 2022 年 9 月 9 日下午 9:03:02 com.aparapi.internal.model.MethodModel init 警告：方法 max(FF)F 不包含 LocalVariableTable 条目（未使用 -g 编译的源）代码生成将尝试创建合成表基于字节码。 This is experimental,: VIII 09: 2022 9.03.02 PM com.aparapi.internal:kernel,KernelRunner fallBackToNextDevice WARNING: Device failed for NeuralNetwork$2, devices={NVIDIA|Intel|Java Alternative Algorithm|Java Thread Pool}: null

所以看起来 poolKernel 无法解决最大的 function 并且整个事情都回到了 CPU 上。

调试时，我可以确认它只使用了 12 个线程——这是我的 Intel Core i7 支持的数量。 GPU 是具有 896 个内核的 NVIDIA GeForce GTX 1650，所以这就是我所期望看到的。

此外，最后它说：

警告：Aparapi 在未经测试的 OpenCL 平台版本上运行：OpenCL 3.0 CUDA 11.3.123 警告：Aparapi 在未经测试的 OpenCL 平台版本上运行：OpenCL 3.0

我错过了什么？ PS：正如你想象的那样，我对卷积网络和 GPGPU 都是新手。 我知道有一个包含所有需要的 cnn 函数（cudnn）的库，但我想自己实现它以真正了解它是如何工作的。

Answer 1

想通了——leakyReLU 还使用了一个我完全忘记的浮点数的最大值......我用 if 语句替换了两者。 现在我得到的唯一错误消息是，根据 api，有对象传递给内核（不支持）。 但我没有看到任何物体......如果有人可以帮助这部分，请插话。

    int padding = 3;
    int filterSize = 2 * padding + 1;
    int[] input = new int[rows * columns];
    for(int r = 0; r < rows; r++)
        System.arraycopy(inputLayer[r], 0, input, r * columns, columns);
    int[] filters = new int[4 * filterSize * filterSize];
    for(int fl = 0; fl < 4; fl++)
        for(int fr = 0; fr < filterSize; fr++)
            System.arraycopy(features[fl][fr], 0, filters, fl * filterSize * filterSize + fr * filterSize, filterSize);
    float[] conv = new float[4 * rows * columns];
    float[] pool = new float[rows * columns];

    Range convRange = Range.create3D(columns, rows, 4);
    Kernel convKernel = new Kernel(){
        int h = rows;
        int w = columns;
        int p = padding;
        int fs = filterSize;
        public void run(){
            int val = 0;
            int c = getGlobalId(0);
            int r = getGlobalId(1);
            int l = getGlobalId(2);
            int upper = max(0, p - r);
            int lower = min(fs, h + p - r);
            int left = max(0, p - c);
            int right = min(fs, w + p - c);
            for (int i = upper; i < lower; i++)
                for (int j = left; j < right; j++)
                    val += input[(r + i - p) * w + c + j - p] * filters[l * fs * fs + i * fs + j];
            conv[l * h * w + r * w + c] = Math.round(100.00f * val / fs) / 100.00f;
        }
    };
    convKernel.setExplicit(true);
    convKernel.put(input);
    convKernel.put(conv);
    convKernel.put(filters);
    convKernel.execute(convRange);
    convKernel.get(conv);
    for(int convL = 0; convL < 4; convL++)
        for(int convR = 0; convR < rows; convR++)
            System.arraycopy(conv, convL * rows * columns + convR * columns, convLayer[convL][convR], 0, columns);

    Range poolRange = Range.create3D(columns / 2, rows / 2, 4);
    Kernel poolKernel = new Kernel(){
        public void run(){
            int wt = columns;
            int ht = rows;
            float coef = coefficient;
            float val = 0.00f;
            int c = getGlobalId(0);
            int r = getGlobalId(1);
            int l = getGlobalId(2);
            for(int i = 0; i < 2; i++)
                for (int j = 0; j < 2; j++) {
                    float tmp = conv[l * ht * wt + (2 * r + i) * wt + 2 * c + j];
                    if(tmp < 0) tmp = tmp * coef;
                    if (val < tmp) val = tmp;
                }
            pool[(l * ht * wt / 4) + (r * wt / 2) + c] = Math.round(100.00f * val) / 100.00f;
        }
    };
    poolKernel.setExplicit(true);
    poolKernel.put(conv);
    poolKernel.put(pool);
    poolKernel.execute(poolRange);
    poolKernel.get(pool);
    for(int poolL = 0; poolL < 4; poolL++)
        for(int poolR = 0; poolR < rows / 2; poolR++)
            System.arraycopy(pool, (poolL * rows * columns / 4) + (poolR * columns / 2), poolLayer[poolL][poolR], 0, columns / 2);

Answer 2

嗯......有时，显然，一个人需要写下自己的问题才能回答它。 是否进行了一些返工，现在所有错误似乎都消失了：

    int padding = 3;
    int filterSize = 2 * padding + 1;
    int[] params = {rows, columns, padding, filterSize};
    int[] input = new int[rows * columns];
    for(int r = 0; r < rows; r++)
        System.arraycopy(inputLayer[r], 0, input, r * columns, columns);
    int[] filters = new int[4 * filterSize * filterSize];
    for(int fl = 0; fl < 4; fl++)
        for(int fr = 0; fr < filterSize; fr++)
            System.arraycopy(features[fl][fr], 0, filters, fl * filterSize * filterSize + fr * filterSize, filterSize);
    float[] conv = new float[4 * rows * columns];
    float[] pool = new float[rows * columns];

    Range convRange = Range.create3D(columns, rows, 4);
    Kernel convKernel = new Kernel(){
        final int h = params[0];
        final int w = params[1];
        final int p = params[2];
        final int fs = params[3];
        public void run(){
            int val = 0;
            final int c = getGlobalId(0);
            final int r = getGlobalId(1);
            final int l = getGlobalId(2);
            final int upper = max(0, p - r);
            final int lower = min(fs, h + p - r);
            final int left = max(0, p - c);
            final int right = min(fs, w + p - c);
            for (int i = upper; i < lower; i++)
                for (int j = left; j < right; j++)
                    val += input[(r + i - p) * w + c + j - p] * filters[l * fs * fs + i * fs + j];
            conv[l * h * w + r * w + c] = Math.round(100.00f * val / fs) / 100.00f;
        }
    };
    convKernel.setExplicit(true);
    convKernel.put(params);
    convKernel.put(input);
    convKernel.put(conv);
    convKernel.put(filters);
    convKernel.execute(convRange);
    convKernel.get(conv);
    for(int convL = 0; convL < 4; convL++)
        for(int convR = 0; convR < rows; convR++)
            System.arraycopy(conv, convL * rows * columns + convR * columns, convLayer[convL][convR], 0, columns);

    Range poolRange = Range.create3D(columns / 2, rows / 2, 4);
    Kernel poolKernel = new Kernel(){
        final int ht = params[0];
        final int wt = params[1];
        public void run(){
            //final float coef = coefficient;
            float val = 0.00f;
            final int c = getGlobalId(0);
            final int r = getGlobalId(1);
            final int l = getGlobalId(2);
            for(int i = 0; i < 2; i++)
                for (int j = 0; j < 2; j++) {
                    float tmp = NeuralNetwork.ReLU(conv[l * ht * wt + (2 * r + i) * wt + 2 * c + j]);
                    if(val < tmp) val = tmp;
                }
            pool[(l * ht * wt / 4) + (r * wt / 2) + c] = Math.round(100.00f * val) / 100.00f;
        }
    };
    poolKernel.setExplicit(true);
    poolKernel.put(params);
    poolKernel.put(conv);
    poolKernel.put(pool);
    poolKernel.execute(poolRange);
    poolKernel.get(pool);
    for(int poolL = 0; poolL < 4; poolL++)
        for(int poolR = 0; poolR < rows / 2; poolR++)
            System.arraycopy(pool, (poolL * rows * columns / 4) + (poolR * columns / 2), poolLayer[poolL][poolR], 0, columns / 2);

此外，我得出的结论是我不需要 LeakyReLU - 常规 ReLU 非常好，也就是说。 我认为这个话题或多或少是封闭的：我希望有人能从我的崎岖道路中学习：D