Для яких статистичних методів GPU швидше, ніж процесори?

Я щойно встановив на робочий стіл графічну карту Nvidia GT660 і після певної боротьби мені вдається з'єднати її з R.

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

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

Зауважте, що я експериментував переважно з gputools, тому, можливо, інші пакети працюють краще.

У широкому розумінні моє запитання таке: які деякі рутинні статистичні операції, які можуть бути вартими виконувати на GPU, а не на процесорі?

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

Якщо ви шукаєте в графічних процесорах, тому що ви виявили, що на деякий розрахунок, який потрібно запустити, знадобиться тижнів / місяців, щоб закінчити, можливо, варто витратити час на перехід від 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];
            }
        }
    }
}

Головне, що тут слід побачити, - це те, що є багато вкладених циклів і кожен крок повинен бути виконаний один за одним.

Дивіться схему цього

Зауважте, що обчислення кожного елемента С не залежить від жодного з інших елементів. Тож не має значення, в якому порядку проводяться розрахунки.

Отже, на 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];
         }
     }
}

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

Однак існують деякі алгоритми, які сповільнюватимуть графічний процес. Деякі не дуже підходять для GPU.

Наприклад, існували залежності даних, тобто: уявіть, обчислення кожного елемента C залежало від попередніх елементів. Програмісту доведеться поставити бар'єр у ядрі, щоб дочекатися завершення кожного попереднього обчислення. Це було б серйозним уповільненням.

Також алгоритми, які мають багато логіки розгалуження, тобто:

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

прагнуть повільніше працювати на графічному процесорі, оскільки GPU вже не робить те саме в кожному потоці.

Це спрощене пояснення, оскільки є багато інших факторів, які слід враховувати. Наприклад, передача даних між процесором та графічним процесором також забирає багато часу. Іноді варто робити обчислення на графічному процесорі навіть тоді, коли його швидше на процесорі, просто щоб уникнути зайвого часу надсилання (І навпаки).

Також багато сучасних процесорів підтримують паралельність зараз, а також з багатопотоковими процесорами з гіперпотоком.

Графічні процесори також здаються не дуже хорошими для рекурсії, дивіться тут, що, ймовірно, пояснює деякі проблеми з алгоритмом QR. Я вважаю, що людина має деякі рекурсивні залежності даних.

Для всіх згаданих вами додатків графічні процесори повинні бути більш здатними (з апаратної точки зору), ніж процесори для досить великих матриць. Я нічого не знаю про реалізацію R, але я використовував cuBLAS і Magma з великим успіхом для інверсій навколо$n = 2^{10}$ і множення / співвіднесення для прямокутних матриць з $n,m \approx 2^{10}, k \approx 2^{14}$. Для мене особливо велике здивування, що великі кореляційні матриці будуть швидшими на процесорі за допомогою R.

Загалом, я підозрюю, що більшість статистичних операцій, які проводять більшу частину свого часу в щільній лінійній алгебрі (функціональність BLAS, Lapack), можуть бути ефективно реалізовані на GPU.

Кілька методів імпутації для відсутніх даних? Як і в Алісі-II (R).

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