วิธีการทางสถิติแบบใดที่ GPU เร็วกว่าซีพียู?

ฉันเพิ่งติดตั้งการ์ดกราฟิก Nvidia GT660 บนเดสก์ท็อปของฉันและหลังจากการต่อสู้บางอย่างฉันก็สามารถเชื่อมต่อกับ R ได้

ฉันได้เล่นกับแพ็คเกจ R หลายอันที่ใช้ GPU โดยเฉพาะอย่างยิ่ง gputools และฉันได้เปรียบเทียบเวลาที่ GPU และ CPU ของฉันใช้เพื่อดำเนินการขั้นพื้นฐาน:

• การแปลงเมทริกซ์ (CPU เร็วขึ้น)
• การสลายตัว qr (CPU เร็วขึ้น)
• เมทริกซ์ความสัมพันธ์ขนาดใหญ่ (เร็วกว่า CPU)
• การคูณเมทริกซ์ (GPU เร็วขึ้นมาก!)

สังเกตว่าฉันได้ทำการทดลองกับ gputools เป็นหลักดังนั้นบางทีแพ็คเกจอื่นอาจทำงานได้ดีขึ้น

ในแง่กว้างคำถามของฉันคืออะไรการดำเนินการทางสถิติประจำที่อาจมีมูลค่าการดำเนินการใน GPU มากกว่า CPU?

GPU เป็นสัตว์ร้าย แม้ว่า Nvidia จะมีการ์ดที่สุดเท่าที่จะทำได้ในทางปฏิบัติการใด ๆ ก็ตามที่คุณระบุไว้ว่าเร็วกว่าซีพียูที่เร็วที่สุดถึง 100x แต่มีประมาณหนึ่งล้านชิ้น ที่สามารถเร่งความเร็วได้ ทุกส่วนของอัลกอริธึมที่เกี่ยวข้องและของโปรแกรมที่ทำงานนั้นจะต้องได้รับการปรับแต่งอย่างกว้างขวางและปรับให้เหมาะสมเพื่อให้ได้ทุกที่ใกล้กับการเร่งความเร็วสูงสุดตามทฤษฎี โดยทั่วไปจะไม่รู้ว่าเป็นภาษาที่รวดเร็วโดยเฉพาะและดังนั้นจึงไม่แปลกใจเลยที่การใช้งาน GPU เริ่มต้นนั้นไม่ดีอย่างน้อยในแง่ของประสิทธิภาพดิบ อย่างไรก็ตามฟังก์ชั่น R GPU อาจมีการตั้งค่าการปรับแต่งที่คุณสามารถปรับแต่งเพื่อให้ได้ประสิทธิภาพที่ขาดหายไป

หากคุณกำลังมองหา GPU เพราะคุณพบว่าการคำนวณบางอย่างที่คุณต้องดำเนินการนั้นต้องใช้เวลาหลายสัปดาห์ / เดือนในการดำเนินการให้เสร็จสิ้นการโอนย้ายจาก R ไปเป็นภาษาที่มีประสิทธิภาพดีกว่าอาจคุ้มค่า Python ไม่ยากที่จะทำงานด้วย R แพคเกจ NumPy และ SciPy นั้นมีฟังก์ชั่นสถิติเหมือนกันกับ R และ PyCuda สามารถใช้ในการสร้างฟังก์ชั่น GPU ของคุณได้อย่างตรงไปตรงมา

หากคุณจริงๆต้องการที่จะเพิ่มความเร็วในการทำงานของคุณทำงานใน GPUs, ฉันจะพิจารณาการใช้ฟังก์ชั่นของคุณเองในการรวมกันของภาษา C ++ และ CUDA ไลบรารี CUBLAS สามารถใช้เพื่อจัดการการยกของพีชคณิตเชิงเส้นทั้งหมดที่เกี่ยวข้อง อย่างไรก็ตามโปรดจำไว้ว่าอาจใช้เวลาสักครู่ในการเขียนโค้ดดังกล่าว (โดยเฉพาะอย่างยิ่งถ้าเป็นครั้งแรกที่คุณทำเช่นนั้น) และดังนั้นวิธีการนี้ควรสงวนไว้เฉพาะการคำนวณที่ใช้เวลานานมากในการรัน (เดือน) และ / หรือว่าคุณจะต้องทำซ้ำหลายร้อยครั้ง

ในแง่กว้างอัลกอริธึมที่ทำงานเร็วกว่าบน GPU เป็นสิ่งที่คุณกำลังทำการสอนชนิดเดียวกันในจุดข้อมูลที่แตกต่างกัน

ตัวอย่างง่ายๆในการอธิบายนี้คือการคูณเมทริกซ์

สมมติว่าเรากำลังทำการคำนวณเมทริกซ์

$A \times B = C$

อัลกอริทึมของ CPU อย่างง่ายอาจมีลักษณะคล้าย

// เริ่มต้นด้วย 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];
         }
     }
}

เคอร์เนลนี้มีสองด้านสำหรับลูปเท่านั้น โปรแกรมที่ส่งงานนี้ไปยัง GPU จะบอกให้ GPU ดำเนินการเคอร์เนลนี้สำหรับแต่ละจุดข้อมูลใน C GPU จะทำตามคำแนะนำเหล่านี้พร้อมกันในหลายเธรด เช่นเดียวกับคำพูดเก่า ๆ ที่ว่า "ถูกกว่าด้วยโหล" GPU ได้รับการออกแบบมาให้ทำสิ่งเดียวกันได้เร็วขึ้นหลายครั้ง

อย่างไรก็ตามมีอัลกอริทึมบางตัวที่จะทำให้ GPU ช้าลง บางตัวไม่เหมาะสำหรับ GPU

ตัวอย่างเช่นหากมีการพึ่งพาข้อมูลคือ: จินตนาการการคำนวณของแต่ละองค์ประกอบของ C ขึ้นอยู่กับองค์ประกอบก่อนหน้า โปรแกรมเมอร์จะต้องใส่สิ่งกีดขวางในเคอร์เนลเพื่อรอให้การคำนวณก่อนหน้านี้เสร็จสิ้น นี่จะเป็นการชะลอตัวครั้งใหญ่

นอกจากนี้อัลกอริทึมที่มีตรรกะการแยกย่อยมากมายเช่น:

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

มักจะทำงานช้าลงบน GPU เพราะ GPU ไม่ทำสิ่งเดียวกันในแต่ละเธรดอีกต่อไป

นี่เป็นคำอธิบายที่ง่ายขึ้นเนื่องจากมีปัจจัยอื่นอีกมากมายที่ต้องพิจารณา ตัวอย่างเช่นการส่งข้อมูลระหว่าง CPU และ GPU นั้นใช้เวลานานเช่นกัน บางครั้งมันก็คุ้มค่าที่จะทำการคำนวณบน GPU แม้ว่ามันจะเร็วกว่าบนซีพียูเพียงเพื่อหลีกเลี่ยงเวลาส่งเพิ่ม (และในทางกลับกัน)

ซีพียูสมัยใหม่หลายรุ่นรองรับการทำงานพร้อมกันในขณะนี้พร้อมกับโปรเซสเซอร์มัลติคอร์แบบหลายเธรด

GPU ดูเหมือนจะไม่ดีสำหรับการเรียกดูอีกครั้งดูที่นี่ซึ่งอาจอธิบายปัญหาบางอย่างเกี่ยวกับอัลกอริทึม QR ฉันเชื่อว่ามีการอ้างอิงข้อมูลซ้ำ

สำหรับแอพพลิเคชั่นทั้งหมดที่คุณพูดถึง GPU ควรมีความสามารถมากกว่า (จากมุมมองของฮาร์ดแวร์) มากกว่าซีพียูสำหรับเมทริกซ์ที่มีขนาดใหญ่เพียงพอ ฉันไม่รู้อะไรเลยเกี่ยวกับการนำไปใช้ของ R แต่ฉันใช้cuBLASและMagma$n = 2^{10}$$n,m \approx 2^{10}, k \approx 2^{14}$ 14เป็นเรื่องประหลาดใจอย่างยิ่งสำหรับฉันที่เมทริกซ์ความสัมพันธ์ขนาดใหญ่จะเร็วขึ้นใน CPU โดยใช้ R

ในวงกว้างฉันสงสัยว่าการดำเนินการทางสถิติส่วนใหญ่ที่ใช้เวลาส่วนใหญ่ในพีชคณิตเชิงเส้นหนาแน่น (ฟังก์ชั่น BLAS, Lapack) สามารถนำไปใช้กับ GPU ได้อย่างมีประสิทธิภาพ

การใส่ข้อมูลหลายวิธีสำหรับข้อมูลที่ขาดหายไป? เช่นเดียวกับใน Alice-II (R)

ฉันคิดว่าสิ่งเหล่านี้มักจะขนานกันอย่างน่าอายและเหมาะสมกับสถาปัตยกรรม GPU ไม่เคยลองด้วยตัวเอง