ประสิทธิภาพของไลบรารีคณิตศาสตร์ Java matrix หรือไม่ [ปิด]

เรากำลังคำนวณอะไรบางอย่างที่ runtime ถูกผูกมัดโดยการดำเนินการเมทริกซ์ (รายละเอียดบางอย่างด้านล่างหากสนใจ) ประสบการณ์นี้ทำให้เกิดคำถามต่อไปนี้:

ชาวบ้านมีประสบการณ์กับการทำงานของห้องสมุด Java สำหรับคณิตศาสตร์เมทริกซ์ (เช่นทวีคูณผกผัน ฯลฯ ) หรือไม่? ตัวอย่างเช่น:

• JAMA
• COLT
• Apache ทั่วไปคณิตศาสตร์

ฉันค้นหาและพบว่าไม่มีอะไร

รายละเอียดการเปรียบเทียบความเร็วของเรา:

เราใช้ Intel FORTRAN (ifort (IFORT) 10.1 20070913) เราได้นำมาใช้ใหม่ใน Java (1.6) โดยใช้ Apache commons math 1.2 matrix ops และยอมรับความถูกต้องของตัวเลขทั้งหมด (เรามีเหตุผลที่ต้องการเป็นภาษาจาวา) (Java doubles, Fortran real * 8) Fortran: 6 นาที, Java 33 นาที, เครื่องเดียวกัน การทำโปรไฟล์ jvisualm แสดงเวลาที่ใช้ใน RealMatrixImpl {getEntry, isValidCoordinate} (ซึ่งดูเหมือนว่าจะหายไปใน Apache Commons math 2.0 แต่ 2.0 ไม่เร็วขึ้น) Fortran ใช้งานประจำของ Atlas BLAS (dpotrf เป็นต้น)

เห็นได้ชัดว่าสิ่งนี้อาจขึ้นอยู่กับรหัสของเราในแต่ละภาษา แต่เราเชื่อว่าส่วนใหญ่อยู่ในการดำเนินการเมทริกซ์ที่เทียบเท่า

ในการคำนวณอื่น ๆ ที่ไม่เกี่ยวข้องกับไลบรารี Java ไม่ได้ช้ากว่าและบางครั้งก็เร็วกว่ามาก

เพียงแค่เพิ่ม 2 เซนต์ของฉัน ฉันเปรียบเทียบบางห้องสมุดเหล่านี้ ฉันพยายามเมทริกซ์คูณเมทริกซ์ 3000 คูณ 3000 ด้วยตัวมันเอง ผลการวิจัยมีดังนี้

การใช้ ATLAS แบบมัลติเธรดกับ C / C ++, อ็อกเทฟ, ไพ ธ อนและ R, เวลาที่ใช้คือประมาณ 4 วินาที

การใช้ Jama กับ Java เวลาที่ใช้คือ 50 วินาที

ใช้ Colt และ Parallel Colt กับ Java เวลาที่ใช้คือ 150 วินาที!

การใช้ JBLAS กับ Java เวลาที่ใช้จะอยู่ที่ประมาณ 4 วินาทีเนื่องจาก JBLAS ใช้ ATLAS แบบมัลติเธรด

ดังนั้นสำหรับฉันมันชัดเจนว่าห้องสมุด Java ไม่ทำงานได้ดีเกินไป อย่างไรก็ตามถ้ามีคนต้องใช้รหัสใน Java แล้วตัวเลือกที่ดีที่สุดคือ JBLAS Jama, Colt และ Parallel Colt นั้นไม่เร็ว

ฉันเป็นผู้เขียน Java Matrix Benchmark ( JMatBench ) และฉันจะให้ความคิดเกี่ยวกับการสนทนานี้

มีความแตกต่างที่สำคัญระหว่างห้องสมุด Java และแม้ว่าจะไม่มีผู้ชนะที่ชัดเจนในการดำเนินงานทั้งหมด แต่ก็มีผู้นำที่ชัดเจนเพียงไม่กี่คนที่สามารถเห็นได้ในผลการดำเนินงานล่าสุด (ตุลาคม 2013)

หากคุณทำงานกับเมทริกซ์ "ใหญ่" และสามารถใช้ไลบรารี่ดั้งเดิมได้ผู้ชนะที่ชัดเจน (เร็วกว่า 3.5x) คือMTJพร้อมด้วยระบบ netlib ที่ปรับให้เหมาะสม หากคุณต้องการโซลูชัน Java ที่แท้จริงMTJ , OjAlgo , EJMLและParallel Coltเป็นตัวเลือกที่ดี สำหรับเมทริกซ์ขนาดเล็ก EJML เป็นผู้ชนะที่ชัดเจน

ห้องสมุดที่ฉันไม่ได้กล่าวถึงพบว่ามีปัญหาด้านประสิทธิภาพที่สำคัญหรือขาดคุณสมบัติที่สำคัญ

ฉันเป็นผู้เขียนหลักของ jblas และต้องการชี้ให้เห็นว่าฉันเปิดตัวเวอร์ชัน 1.0 ในปลายเดือนธันวาคม 2009 ฉันทำงานบนบรรจุภัณฑ์มากซึ่งหมายความว่าตอนนี้คุณสามารถดาวน์โหลด "jar ไขมัน" กับไลบรารี ATLAS และ JNI ได้แล้ว สำหรับ Windows, Linux, Mac OS X, 32 และ 64 บิต (ยกเว้นสำหรับ Windows) วิธีนี้คุณจะได้รับประสิทธิภาพเนทีฟเพียงแค่เพิ่มไฟล์ jar ใน classpath ของคุณ ตรวจสอบได้ที่http://jblas.org !

ฉันไม่สามารถแสดงความคิดเห็นในไลบรารีที่เฉพาะเจาะจงได้ แต่โดยหลักการแล้วมีเหตุผลเล็กน้อยที่การดำเนินการดังกล่าวจะช้าลงใน Java โดยทั่วไปฮอตสปอตจะทำสิ่งต่าง ๆ ที่คุณคาดหวังว่าคอมไพเลอร์ต้องทำ: มันรวบรวมการดำเนินการทางคณิตศาสตร์ขั้นพื้นฐานเกี่ยวกับตัวแปร Java ไปยังคำสั่งเครื่องที่เกี่ยวข้อง การเข้าถึงองค์ประกอบของอาเรย์นั้นรวบรวมเพื่อใช้คำสั่ง MOV แบบ "ดิบ" ตามที่คุณต้องการ มันทำการตัดสินใจเกี่ยวกับวิธีการจัดสรรตัวแปรให้กับการลงทะเบียนเมื่อทำได้ มันสั่งซื้อคำสั่งอีกครั้งเพื่อใช้ประโยชน์จากสถาปัตยกรรมตัวประมวลผล ... ข้อยกเว้นที่เป็นไปได้คือตามที่ฉันกล่าวถึง Hotspot จะดำเนินการหนึ่งการดำเนินการต่อคำสั่ง SSE เท่านั้น โดยหลักการแล้วคุณสามารถมีเมทริกซ์ไลบรารีที่ได้รับการปรับให้เหมาะสมอย่างน่าอัศจรรย์ซึ่งดำเนินการหลายอย่างต่อการสอนแม้ว่าฉันจะไม่ ไม่รู้ว่าพูดว่าห้องสมุด FORTRAN ของคุณทำเช่นนั้นหรือถ้าห้องสมุดนั้นมีอยู่จริง ถ้าเป็นเช่นนั้นในปัจจุบันไม่มีทางที่ Java (หรืออย่างน้อย Hotspot) จะแข่งขันกับมัน (แม้ว่าคุณจะสามารถเขียนไลบรารี่ของคุณเองด้วยการเพิ่มประสิทธิภาพที่จะเรียกจาก Java)

ดังนั้นทั้งหมดนี้หมายความว่าอย่างไร ดี:

• โดยหลักการแล้วมันคุ้มค่าที่จะหาห้องสมุดที่มีประสิทธิภาพดีกว่า แต่น่าเสียดายที่ฉันไม่สามารถแนะนำได้
• หากประสิทธิภาพมีความสำคัญอย่างยิ่งต่อคุณฉันจะลองเขียนโค้ดการทำงานของเมทริกซ์ของคุณเองเพราะคุณอาจจะสามารถทำการออปติไมซ์บางอย่างที่ไลบรารี่ทั่วไปไม่สามารถทำได้หรือไลบรารีเฉพาะที่คุณใช้ไม่ได้ เครื่องมัลติโปรเซสเซอร์ดูว่าห้องสมุดเป็นมัลติเธรดจริงหรือไม่

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

ฉันเพิ่งเปรียบเทียบ Apache Commons Math กับ jlapack

ทดสอบ: การสลายตัวค่าเอกพจน์ของเมทริกซ์ 1024x1024 สุ่ม

เครื่อง: Intel (R) Core (TM) 2 Duo CPU E6750 @ 2.66GHz, linux x64

รหัสระดับแปดเสียง: A = rand (1024); กระตุก [U, S, V] = SVD (A); toc

เวลาดำเนินการผลลัพธ์
-------------------------------------------------- -------
อ็อกเทฟ 36.34 วินาที

JDK 1.7u2 64 บิต
    jlapack dgesvd 37.78 วินาที
    apache commons math SVD 42.24 วินาที


JDK 1.6u30 64 บิต
    jlapack dgesvd 48.68 วินาที
    apache สามัญคณิตศาสตร์ SVD 50.59 วินาที

พื้นเมืองประจำ
Lapack * ถูกเรียกใช้จาก C: 37.64 วินาที
Intel MKL 6.89 วินาที (!)

ข้อสรุปของฉันคือ jlapack ที่เรียกว่าจาก JDK 1.7 นั้นใกล้เคียงกับประสิทธิภาพไบนารีดั้งเดิมของ lapack ฉันใช้ไลบรารีไบนารี lapack ที่มาพร้อมกับ linux distro และเรียกใช้ชุดคำสั่ง dgesvd เพื่อรับเมทริกซ์ U, S และ VT เช่นกัน การทดสอบทั้งหมดทำโดยใช้ความแม่นยำสองเท่าบนเมทริกซ์เดียวกันทุกครั้ง (ยกเว้นคู่)

ข้อสงวนสิทธิ์ - ฉันไม่ใช่ผู้เชี่ยวชาญในพีชคณิตเชิงเส้นซึ่งไม่เกี่ยวข้องกับห้องสมุดใด ๆ ข้างต้นและนี่ไม่ใช่มาตรฐานที่เข้มงวด เป็นการทดสอบแบบ 'ทำที่บ้าน' เนื่องจากฉันสนใจที่จะเปรียบเทียบการเพิ่มประสิทธิภาพของ JDK 1.7 เป็น 1.6 รวมถึงการใช้คณิตศาสตร์ทั่วไป SVD กับ jlapack

Jeigen https://github.com/hughperkins/jeigen

• ล้อมรอบไลบรารี Eigen C ++ ที่http://eigen.tuxfamily.orgซึ่งเป็นหนึ่งในไลบรารี C ++ ที่เร็วที่สุดฟรี
• ไวยากรณ์ที่ค่อนข้างสั้นเช่น 'mmul', 'sub'
• จัดการทั้งเมทริกซ์หนาแน่นและกระจัดกระจาย

การทดสอบอย่างรวดเร็วโดยการคูณเมทริกซ์หนาแน่นสองตัวคือ:

นำเข้าคงที่ jeigen.MatrixUtil. *;

int K = 100;
int N = 100000;
DenseMatrix A = rand(N, K);
DenseMatrix B = rand(K, N);
Timer timer = new Timer();
DenseMatrix C = B.mmul(A);
timer.printTimeCheckMilliseconds();

ผล:

Jama: 4090 ms
Jblas: 1594 ms
Ojalgo: 2381 ms (using two threads)
Jeigen: 2514 ms

• เปรียบเทียบกับ jama ทุกอย่างเร็วกว่า :-P
• เมื่อเปรียบเทียบกับ jblas แล้ว Jeigen นั้นไม่ค่อยเร็วเท่าไหร่ แต่มันจัดการกับเมทริกซ์เบาบาง
• เปรียบเทียบกับ ojalgo, Jeigen ใช้เวลาประมาณเท่ากัน แต่ใช้เพียงแกนเดียวดังนั้น Jeigen จึงใช้ซีพียูทั้งหมดครึ่งหนึ่ง Jeigen มีไวยากรณ์ terser เช่น 'mmul' กับ 'multiplyRight'

มีเกณฑ์มาตรฐานของแพ็คเกจเมทริกซ์ต่างๆที่มีอยู่ใน java ขึ้นบน http://code.google.com/p/java-matrix-benchmark/สำหรับการกำหนดค่าฮาร์ดแวร์ที่แตกต่างกันสองสามตัว แต่มันก็ไม่ใช่สิ่งทดแทนการทำเกณฑ์มาตรฐานของคุณเอง

ประสิทธิภาพจะแตกต่างกันไปตามประเภทของฮาร์ดแวร์ที่คุณมี (cpu, คอร์, หน่วยความจำ, แคช L1-3, ความเร็วบัส), ขนาดของเมทริกซ์และอัลกอริธึมที่คุณต้องการใช้ ห้องสมุดที่แตกต่างกันจะใช้เวลาที่แตกต่างกันสำหรับอัลกอริทึมที่แตกต่างกันจึงไม่มีคำตอบเดียว คุณอาจพบว่าโอเวอร์เฮดของการแปลไปยังแบบฟอร์มที่คาดไว้โดยไลบรารีเนทีฟจะทำให้เกิดข้อได้เปรียบด้านประสิทธิภาพสำหรับกรณีการใช้งานของคุณ (ไลบรารีจาวาบางตัวมีตัวเลือกที่ยืดหยุ่นมากขึ้นเกี่ยวกับการจัดเก็บเมทริกซ์

โดยทั่วไปแล้ว JAMA, Jampack และ COLT กำลังจะเก่าและไม่ได้แสดงสถานะของประสิทธิภาพปัจจุบันที่มีใน Java สำหรับพีชคณิตเชิงเส้น ห้องสมุดที่ทันสมัยกว่าทำให้การใช้งานหลายแกนและ cpu แคชมีประสิทธิภาพมากขึ้น JAMA เป็นการดำเนินการอ้างอิงและใช้อัลกอริทึมตำราเรียนที่ค่อนข้างคำนึงถึงประสิทธิภาพ COLT และ IBM Ninja เป็นไลบรารี java ตัวแรกที่แสดงให้เห็นว่าประสิทธิภาพเป็นไปได้ใน java แม้ว่าพวกเขาจะล้าหลัง 50% หลังไลบรารีดั้งเดิม

ฉันเป็นผู้เขียนห้องสมุด la4j (Linear Algebra for Java) และนี่คือจุดของฉัน ฉันทำงานกับ la4j เป็นเวลา 3 ปี (รีลีสล่าสุดคือ 0.4.0 [01 มิถุนายน 2013]) และตอนนี้ฉันสามารถเริ่มทำการวิเคราะห์และปรับแต่งประสิทธิภาพได้ตั้งแต่ตอนที่ฉันได้ครอบคลุมฟังก์ชั่นที่ต้องการน้อยที่สุด ดังนั้น la4j ไม่เร็วอย่างที่ฉันต้องการ แต่ฉันใช้เวลามากมายในการเปลี่ยนแปลง

ฉันกำลังอยู่ระหว่างการย้ายเวอร์ชั่นใหม่ของ la4j ไปยังแพลตฟอร์มJMatBench ฉันหวังว่าเวอร์ชั่นใหม่จะแสดงประสิทธิภาพที่ดีขึ้นจากนั้นรุ่นก่อนหน้าเนื่องจากมีการปรับปรุงหลายอย่างที่ฉันทำใน la4j เช่นรูปแบบเมทริกซ์ภายในที่เร็วขึ้น accessors ที่ไม่ปลอดภัยและอัลกอริทึมการบล็อกที่รวดเร็วสำหรับการคูณเมทริกซ์

รหัส Linalg ที่ต้องอาศัย Pentium และความสามารถในการคำนวณเวกเตอร์ของโปรเซสเซอร์ในภายหลัง (เริ่มต้นด้วยส่วนขยาย MMX เช่น LAPACK และตอนนี้ Atlas BLAS) ไม่ใช่ "ปรับให้เหมาะสมที่สุด" แต่เป็นมาตรฐานอุตสาหกรรม เพื่อทำซ้ำความสมบูรณ์แบบใน Java คุณจะต้องมีห้องสมุดท้องถิ่น ฉันมีปัญหาประสิทธิภาพการทำงานเช่นเดียวกับที่คุณอธิบาย (ส่วนใหญ่เพื่อให้สามารถคำนวณการสลายตัว Choleski) และพบว่าไม่มีอะไรที่มีประสิทธิภาพจริงๆ: Jama เป็น Java บริสุทธิ์เนื่องจากมันควรจะเป็นเพียงแม่แบบและชุดอ้างอิงสำหรับผู้ใช้งานที่จะปฏิบัติตาม .. ซึ่งไม่เคยเกิดขึ้น คุณรู้จัก Apache math Commons ... สำหรับ COLT ฉันยังคงต้องทดสอบ แต่ดูเหมือนว่าจะต้องพึ่งพาการปรับปรุงของนินจาเป็นอย่างมากซึ่งส่วนใหญ่มาจากการสร้างคอมไพเลอร์ Java ad-hoc ดังนั้นฉันสงสัยว่ามันจะช่วยได้ ณ จุดนี้ฉันคิดว่าเรา "

เราได้ใช้ COLT สำหรับการคำนวณทางการเงินที่ค่อนข้างใหญ่และมีความสุขมากกับมัน ในโค้ดที่มีการทำโปรไฟล์อย่างหนักของเราเราแทบไม่เคยต้องเปลี่ยนการใช้ COLT ไปเป็นหนึ่งในของเราเอง

ในการทดสอบของพวกเขาเอง (เห็นได้ชัดว่าไม่เป็นอิสระ) ฉันคิดว่าพวกเขาอ้างสิทธิ์ภายใน 2 ปัจจัยจากรูทีนแอสเซมเบลอร์ที่ปรับปรุงด้วยมือของ Intel เคล็ดลับในการใช้อย่างดีคือการทำให้แน่ใจว่าคุณเข้าใจปรัชญาการออกแบบของพวกเขาและหลีกเลี่ยงการจัดสรรวัตถุภายนอก

คุณลองดูที่ห้องสมุดคณิตศาสตร์ของ Intel Mathหรือไม่? ที่อ้างว่ามีประสิทธิภาพสูงกว่าแม้ATLAS MKL สามารถใช้ใน Javaผ่านทาง JNI wrappers

การสร้างโพสต์ของ Varkhan ว่ารหัสพื้นเมืองของ Pentium จะทำได้ดีกว่า:

• jBLAS: โครงการอัลฟาเวทีกับห่อ JNI ของ Atlas: http://www.jblas.org

  • บล็อกโพสต์ของผู้แต่ง: http://mikiobraun.blogspot.com/2008/10/matrices-jni-directbuffers-and-number.html

• MTJ: อีกหนึ่งโครงการดังกล่าว: http://code.google.com/p/matrix-toolkits-java/

คุณอาจต้องการตรวจสอบโครงการjblas มันเป็นห้องสมุด Java ที่ค่อนข้างใหม่ที่ใช้ BLAS, LAPACK และ ATLAS สำหรับการดำเนินงานเมทริกซ์ประสิทธิภาพสูง

นักพัฒนาได้โพสต์เกณฑ์มาตรฐานบางอย่างที่ jblas หลุดพ้นจากการเปรียบเทียบกับ MTJ และ Colt

สำหรับแอปพลิเคชั่นกราฟิก 3 มิติการใช้เวกเตอร์ lwjgl.util ได้รับการดำเนินการดังกล่าวข้างต้น jblas โดยปัจจัยประมาณ 3

ฉันได้ทำคูณ 1 ล้านเมทริกซ์ของ vec4 กับ 4x4 เมทริกซ์

lwjgl เสร็จในประมาณ 18ms, jblas ต้องการประมาณ 60ms

(ฉันสมมติว่าวิธี JNI นั้นไม่เหมาะสำหรับการประยุกต์ใช้การคูณต่อเนื่องที่รวดเร็วอย่างรวดเร็วเนื่องจากการแปล / การจับคู่อาจใช้เวลามากกว่าการประมวลผลการคูณจริง)

ฉันได้พบว่าถ้าคุณกำลังสร้างเมทริกซ์มิติสูงคุณสามารถทำให้ Jama เร็วขึ้นประมาณ 20% ถ้าคุณเปลี่ยนมันให้ใช้อาร์เรย์มิติเดียวแทนที่จะเป็นอาร์เรย์สองมิติ เนื่องจาก Java ไม่รองรับอาเรย์หลายมิติอย่างมีประสิทธิภาพ กล่าวคือ มันสร้างอาร์เรย์ของอาร์เรย์

Colt ทำสิ่งนี้มาแล้ว แต่ฉันพบว่ามันซับซ้อนและมีประสิทธิภาพมากกว่า Jama ซึ่งอาจอธิบายได้ว่าทำไมฟังก์ชั่นง่าย ๆ กับ Colt

คำตอบนั้นขึ้นอยู่กับว่าคุณกำลังทำอะไร Jama ไม่สนับสนุนส่วนที่ Colt สามารถทำได้ซึ่งทำให้เกิดความแตกต่าง

นอกจากนี้ยังมีUJMP

มีไลบรารีพีชคณิตเชิงเส้นของ java เชิงเส้นที่แตกต่างกันมากมาย http://www.ujmp.org/java-matrix/benchmark/ น่าเสียดายที่เบนช์มาร์กให้ข้อมูลเกี่ยวกับการคูณเมทริกซ์เท่านั้น (ด้วยการย้ายการทดสอบไม่อนุญาตให้ห้องสมุดต่าง ๆ ใช้ประโยชน์จากคุณสมบัติการออกแบบที่เกี่ยวข้อง)

สิ่งที่คุณควรดูคือห้องสมุดพีชคณิตเชิงเส้นเหล่านี้ทำงานอย่างไรเมื่อถูกขอให้คำนวณการสลายตัวเมทริกซ์ต่างๆ http://ojalgo.org/matrix_compare.html

Matrix Tookits Java (MTJ) ได้ถูกกล่าวถึงก่อนหน้านี้แล้ว แต่บางทีมันก็คุ้มค่าที่จะกล่าวถึงอีกครั้งสำหรับผู้อื่นที่เข้ามาในกระทู้นี้ สำหรับผู้ที่สนใจดูเหมือนว่ายังมีการพูดคุยเกี่ยวกับการมี MTJ แทนที่ห้องสมุด linalg ในapache ทั่วไปคณิตศาสตร์ 2.0แต่ฉันไม่แน่ใจว่าวิธีการที่กำลังคืบหน้าเมื่อเร็ว ๆ นี้

คุณควรเพิ่ม Apache Mahout ในรายการช็อปปิ้งของคุณ