Untuk metode statistik manakah GPU lebih cepat dari CPU?

Saya baru saja menginstal kartu grafis Nvidia GT660 di desktop saya dan, setelah beberapa perjuangan, saya berhasil menghubungkannya dengan R.

Saya telah bermain dengan beberapa paket R yang menggunakan GPU, terutama gputools, dan saya membandingkan waktu yang dibutuhkan oleh GPU dan CPU saya untuk melakukan beberapa operasi dasar:

• matriks pembalik (CPU lebih cepat)
• dekomposisi qr (CPU lebih cepat)
• matriks korelasi besar (CPU lebih cepat)
• perkalian matriks (GPU jauh lebih cepat!)

Perhatikan bahwa saya telah bereksperimen terutama dengan gputool jadi mungkin paket lain berkinerja lebih baik.

Secara umum pertanyaan saya adalah: apa beberapa operasi statistik rutin yang mungkin layak dijalankan pada GPU daripada CPU?

GPU adalah binatang yang sensitif. Meskipun kartu Nvidia yang paling besar secara teoritis dapat menjalankan operasi apa pun yang Anda daftarkan 100x lebih cepat dari CPU tercepat, sekitar satu juta hal dapat menghalangi kecepatan itu. Setiap bagian dari algoritme yang relevan, dan program yang menjalankannya, harus diubah dan dioptimalkan secara ekstensif agar dapat mendekati kecepatan maksimum teoretis tersebut. R pada umumnya tidak dikenal sebagai bahasa yang sangat cepat, dan karenanya tidak mengejutkan saya bahwa implementasi standar GPU-nya tidak terlalu bagus, setidaknya dalam hal kinerja mentah. Namun, fungsi R GPU mungkin memiliki pengaturan pengoptimalan yang dapat Anda atur untuk mendapatkan kembali sebagian dari kinerja yang hilang itu.

Jika Anda mencari GPU karena Anda menemukan bahwa beberapa perhitungan yang perlu Anda jalankan akan memakan waktu berminggu-minggu / bulan untuk diselesaikan, mungkin ada baiknya Anda bermigrasi dari R ke bahasa yang lebih ramah-kinerja. Python tidak terlalu sulit untuk dikerjakan daripada R. Paket NumPy dan SciPy memiliki sebagian besar fungsi stat yang sama dengan R, dan PyCuda dapat digunakan untuk mengimplementasikan fungsi berbasis GPU Anda sendiri dengan cara yang cukup mudah.

Jika Anda benar - benar ingin meningkatkan kecepatan di mana fungsi Anda berjalan pada GPU, saya akan mempertimbangkan untuk mengimplementasikan fungsi Anda sendiri dalam kombinasi C ++ dan CUDA. Perpustakaan CUBLAS dapat digunakan untuk menangani semua pengangkatan berat terkait aljabar linier. Namun, perlu diingat bahwa perlu waktu cukup lama untuk menulis kode seperti itu (terutama jika ini adalah pertama kalinya Anda melakukannya), sehingga pendekatan ini hanya diperuntukkan bagi perhitungan yang membutuhkan waktu sangat lama untuk dijalankan (berbulan-bulan) dan / atau Anda akan mengulangi ratusan kali.

Secara umum, algoritma yang bekerja lebih cepat pada GPU adalah algoritma di mana Anda melakukan jenis instruksi yang sama pada banyak titik data yang berbeda.

Contoh mudah untuk menggambarkan ini adalah dengan perkalian matriks.

Misalkan kita sedang melakukan perhitungan matriks

$A \times B = C$

Algoritme CPU sederhana mungkin terlihat seperti ini

// dimulai dengan 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];
            }
        }
    }
}

Kuncinya untuk dilihat di sini adalah ada banyak loop yang bersarang dan setiap langkah harus dijalankan satu demi satu.

Lihat diagram ini

Perhatikan bahwa perhitungan setiap elemen C tidak tergantung pada elemen lainnya. Jadi tidak masalah urutan urut apa yang dilakukan.

Jadi pada GPU, operasi ini bisa dilakukan bersamaan.

Kernel GPU untuk menghitung perkalian matriks akan terlihat seperti ini

__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];
         }
     }
}

Kernel ini hanya memiliki dua inner untuk loop. Suatu program yang mengirimkan pekerjaan ini ke GPU akan memberitahu GPU untuk menjalankan kernel ini untuk setiap titik data dalam C. GPU akan melakukan masing-masing instruksi ini secara bersamaan di banyak utas. Sama seperti pepatah lama "Lebih murah oleh selusin" GPU dirancang untuk lebih cepat melakukan hal yang sama berkali-kali.

Namun ada beberapa algoritma yang akan memperlambat GPU. Beberapa tidak cocok untuk GPU.

Jika misalnya, ada dependensi data, yaitu: bayangkan perhitungan setiap elemen C tergantung pada elemen sebelumnya. Programmer harus meletakkan penghalang di kernel untuk menunggu setiap perhitungan sebelumnya selesai. Ini akan menjadi penurunan besar.

Juga, algoritma yang memiliki banyak logika percabangan yaitu:

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

cenderung berjalan lebih lambat pada GPU karena GPU tidak lagi melakukan hal yang sama di setiap utas.

Ini adalah penjelasan yang disederhanakan karena ada banyak faktor lain yang perlu dipertimbangkan. Misalnya, mengirim data antara CPU dan GPU juga memakan waktu. Kadang-kadang ada baiknya melakukan perhitungan pada GPU bahkan ketika itu lebih cepat pada CPU, hanya untuk menghindari waktu pengiriman tambahan (Dan sebaliknya).

Juga banyak CPU modern mendukung konkurensi sekarang juga dengan prosesor multicore hyperthreaded.

GPU juga tampaknya tidak begitu baik untuk rekursi, lihat di sini yang mungkin menjelaskan beberapa masalah dengan algoritma QR. Saya percaya bahwa seseorang memiliki beberapa dependensi data rekursif.

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

Secara lebih luas, saya menduga sebagian besar operasi statistik yang menghabiskan sebagian besar waktu mereka dalam aljabar linier padat (BLAS, fungsionalitas Lapack) dapat diimplementasikan secara efisien pada GPU.

Berbagai metode Imputasi untuk Data yang Hilang? Seperti yang ada di Alice-II (R).

Saya pikir mereka cenderung paralel paralel dan karenanya cocok untuk arsitektur GPU. Namun tidak pernah mencobanya sendiri.