Для каких статистических методов GPU быстрее, чем CPU?

Я только что установил графическую карту Nvidia GT660 на свой рабочий стол, и после некоторой борьбы мне удается связать ее с R.

Я играл с несколькими R-пакетами, использующими графические процессоры, особенно gputools, и сравнивал время, затрачиваемое моим GPU и процессором на выполнение некоторых основных операций:

• инвертирующие матрицы (процессор быстрее)
• декомпозиция qr (процессор быстрее)
• большие корреляционные матрицы (процессор быстрее)
• умножение матриц (GPU намного быстрее!)

Обратите внимание, что я экспериментировал в основном с gputools, поэтому, возможно, другие пакеты работают лучше.

В общих чертах мой вопрос таков: какие рутинные статистические операции стоит выполнять на GPU, а не на CPU?

GPU - чувствительные звери. Хотя beefiest карты Nvidia, теоретически может выполнить любой из операций , перечисленных вами 100x быстрее , чем самый быстрый процессор, около миллионов вещи могут стать на пути этого ускорения. Каждая часть соответствующего алгоритма и программы, которая его запускает, должна быть тщательно настроена и оптимизирована, чтобы приблизиться к этому теоретическому максимальному ускорению. Обычно не известно, что R является особенно быстрым языком, и поэтому меня не удивляет, что его стандартная реализация GPU не так уж хороша, по крайней мере, с точки зрения сырой производительности. Однако функции графического процессора R могут иметь параметры оптимизации, которые можно настроить для восстановления некоторой недостающей производительности.

Если вы смотрите на графические процессоры, потому что обнаружили, что для выполнения некоторых вычислений вам потребуются недели / месяцы, возможно, вам стоит потратить время на переход с R на более удобный язык. С Python работать не намного сложнее, чем с R. Пакеты NumPy и SciPy имеют большинство тех же функций статистики, что и R, и PyCuda можно использовать для реализации ваших собственных функций на основе графического процессора довольно простым способом.

Если вы действительно хотите увеличить скорость, с которой ваши функции выполняются на графических процессорах, я хотел бы рассмотреть возможность реализации ваших собственных функций в комбинации C ++ и CUDA. Библиотека CUBLAS может использоваться для обработки всего, связанного с линейной алгеброй. Однако имейте в виду, что для написания такого кода может потребоваться довольно много времени (особенно, если вы делаете это впервые), и поэтому этот подход должен быть зарезервирован только для тех вычислений, которые выполняются очень долго (месяцы) и / или что вы будете повторять сотни раз.

В общих чертах, алгоритмы, которые работают быстрее на графическом процессоре, - это те, в которых вы выполняете инструкции одного и того же типа для множества различных точек данных.

Простой пример для иллюстрации этого - умножение матриц.

Предположим, что мы делаем матричные вычисления

$A \times B = C$

Простой алгоритм процессора может выглядеть примерно так

// начиная с C = 0

for (int i = 0; i < C_Width; i++)
{
    for (int j = 0; j < C_Height; j++)
    {
        for (int k = 0; k < A_Width; k++)
        {
            for (int l = 0; l < B_Height; l++)
            {
                C[j, i] += A[j, k] * B[l, i];
            }
        }
    }
}

Главное, что здесь нужно увидеть, это то, что существует множество вложенных циклов, и каждый шаг должен выполняться один за другим.

Смотрите схему этого

Обратите внимание, что расчет каждого элемента C не зависит от других элементов. Поэтому не имеет значения, в каком порядке производятся расчеты.

Таким образом, на GPU эти операции могут выполняться одновременно.

Ядро GPU для вычисления умножения матриц будет выглядеть примерно так

__kernel void Multiply
(
    __global float * A,
    __global float * B,
    __global float * C
)
{
     const int x = get_global_id(0);
     const int y = get_global_id(1);
     for (int k = 0; k < A_Width; k++)
     {
         for (int l = 0; l < B_Height; l++)
         {
             C[x, y] += A[x, k] * B[l, y];
         }
     }
}

Это ядро ​​имеет только два внутренних цикла for. Программа, отправляющая это задание в GPU, скажет GPU выполнить это ядро ​​для каждой точки данных в C. GPU будет выполнять каждую из этих инструкций одновременно во многих потоках. Точно так же, как старая поговорка «Дешевле на дюжину», графические процессоры предназначены для того, чтобы быстрее делать одно и то же много раз.

Однако есть некоторые алгоритмы, которые замедляют работу графического процессора. Некоторые не очень подходят для графического процессора.

Если, например, были зависимости данных, то есть: представьте, что вычисление каждого элемента C зависело от предыдущих элементов. Программист должен был бы поставить барьер в ядре, чтобы дождаться завершения каждого предыдущего вычисления. Это было бы серьезным замедлением.

Кроме того, алгоритмы, которые имеют много логики ветвления, то есть:

__kernel Foo()
{
    if (somecondition)
    {
        do something
    }
    else
    {
        do something completely different
    }
}

на GPU работают медленнее, потому что GPU больше не делает одно и то же в каждом потоке.

Это упрощенное объяснение, потому что есть много других факторов, которые необходимо учитывать. Например, передача данных между процессором и графическим процессором также занимает много времени. Иногда стоит выполнить вычисления на графическом процессоре, даже если он быстрее на процессоре, просто чтобы избежать дополнительного времени отправки (и наоборот).

Кроме того, многие современные процессоры теперь поддерживают параллелизм и с многопоточными многоядерными процессорами.

Также кажется, что графические процессоры не очень хороши для рекурсии, см. Здесь, что, вероятно, объясняет некоторые проблемы с алгоритмом QR. Я считаю, что у кого-то есть рекурсивные зависимости данных.

$n = 2^{10}$$n,m \approx 2^{10}, k \approx 2^{14}$

В более широком смысле, я подозреваю, что большинство статистических операций, которые проводят большую часть своего времени в плотной линейной алгебре (BLAS, функциональность Лапака), могут быть эффективно реализованы на графическом процессоре.

Несколько методов вменения для отсутствующих данных? Как те, что в Алисе-II (R).

Я думаю, что они часто смущают параллель и, следовательно, подходят для архитектуры GPU. Никогда сам не пробовал.