SVM โดยใช้ scikit เรียนรู้ทำงานอย่างไม่มีที่สิ้นสุดและไม่เคยดำเนินการจนเสร็จสมบูรณ์

ฉันพยายามเรียกใช้ SVR โดยใช้ scikit learn (python) บนชุดข้อมูลการฝึกอบรมที่มี 595605 แถวและ 5 คอลัมน์ (คุณสมบัติ) และชุดทดสอบที่มี 397070 แถว ข้อมูลได้รับการประมวลผลล่วงหน้าและทำให้เป็นมาตรฐาน

ฉันสามารถรันตัวอย่างทดสอบได้สำเร็จ แต่เมื่อใช้งานชุดข้อมูลของฉันและปล่อยให้มันทำงานนานกว่าหนึ่งชั่วโมงฉันก็ยังไม่เห็นผลลัพธ์หรือการสิ้นสุดของโปรแกรม ฉันได้ลองใช้งานด้วย IDE ที่แตกต่างกันและแม้กระทั่งจาก terminal แต่นั่นก็ไม่ได้เป็นปัญหา ฉันได้ลองเปลี่ยนค่าพารามิเตอร์ 'C' จาก 1 เป็น 1e3 แล้ว

ฉันกำลังเผชิญปัญหาที่คล้ายกันกับการใช้งาน svm ทั้งหมดโดยใช้ scikit

ฉันไม่ได้รอให้เสร็จหรือไม่ การดำเนินการนี้ควรใช้เวลาเท่าไหร่

จากประสบการณ์ของฉันไม่ควรใช้เวลาสักครู่

นี่คือการกำหนดค่าระบบของฉัน: Ubuntu 14.04, RAM 8GB, หน่วยความจำฟรีมากมาย, โปรเซสเซอร์เจนเนอเรชั่นที่ 4 รุ่นที่ 4

Kernelized SVMs จำเป็นต้องมีการคำนวณของฟังก์ชันระยะห่างระหว่างจุดแต่ละจุดในชุดข้อมูลซึ่งเป็นค่าใช้จ่ายที่มีอำนาจเหนือของ2) การจัดเก็บระยะทางเป็นภาระในหน่วยความจำดังนั้นพวกเขาจึงคำนวณใหม่ได้ทันที โชคดีที่มีเพียงจุดที่ใกล้เคียงที่สุดกับขอบเขตการตัดสินใจเท่านั้น ระยะทางที่คำนวณบ่อยจะถูกเก็บไว้ในแคช หากแคชจะได้รับการตีแล้วเวลาทำงานพัดขึ้นไป3)O ( n คุณสมบัติ × n 3 สังเกต$\mathcal{O}(n_\text{features} \times n_\text{observations}^2)$$\mathcal{O}(n_\text{features} \times n_\text{observations}^3)$

คุณสามารถเพิ่มแคชนี้ได้โดยการเรียก SVR เป็น

model = SVR(cache_size=7000)

โดยทั่วไปสิ่งนี้จะไม่ทำงาน แต่ทั้งหมดจะไม่สูญหาย คุณสามารถตัวอย่างข้อมูลและใช้ส่วนที่เหลือเป็นชุดการตรวจสอบความถูกต้องหรือคุณสามารถเลือกรูปแบบที่แตกต่างกัน เหนือช่วงการสังเกต 200,000 ควรเลือกผู้เรียนเชิงเส้น

Kernel SVM สามารถประมาณค่าได้โดยประมาณเมทริกซ์เคอร์เนลและป้อนให้กับ SVM เชิงเส้น สิ่งนี้ช่วยให้คุณแลกเปลี่ยนระหว่างความแม่นยำและประสิทธิภาพในเวลาเชิงเส้น

วิธีที่ได้รับความนิยมในการบรรลุเป้าหมายนี้คือการใช้ศูนย์คลัสเตอร์ 100 แห่งหรือมากกว่านั้นที่ kmeans / kmeans ++ เป็นพื้นฐานของฟังก์ชันเคอร์เนลของคุณ ฟีเจอร์ที่ได้รับใหม่นั้นจะถูกป้อนเข้าสู่โมเดลเชิงเส้น วิธีนี้ใช้ได้ผลดีในทางปฏิบัติ เครื่องมือเช่นsophia-mlและvowpal wabbitเป็นวิธีที่ Google, Yahoo และ Microsoft ทำเช่นนี้ อินพุต / เอาต์พุตกลายเป็นค่าใช้จ่ายที่มีอำนาจเหนือสำหรับผู้เรียนเชิงเส้นอย่างง่าย

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

อ่านเพิ่มเติม

• วิธีการใช้งานนี้
• วิธีการฝึกอบรมเครือข่ายประสาท ngram ด้วยการออกกลางคันที่ปรับขนาดเชิงเส้น
• การประมาณเคอร์เนล
• เอกสารอย่างเป็นทางการเกี่ยวกับการใช้ kmeans กับเครื่องเคอร์เนลโดยประมาณ

SVM แก้ปัญหาการเพิ่มประสิทธิภาพของคำสั่งกำลังสอง

ฉันไม่มีอะไรเพิ่มที่ยังไม่ได้พูดที่นี่ ฉันแค่ต้องการโพสต์ลิงค์ในหน้า sklearn เกี่ยวกับSVCซึ่งจะอธิบายสิ่งที่เกิดขึ้น:

การใช้งานจะขึ้นอยู่กับ libsvm ความซับซ้อนของเวลาพอดีนั้นมากกว่ากำลังสองที่มีจำนวนตัวอย่างซึ่งทำให้ยากต่อการปรับขนาดไปยังชุดข้อมูลที่มีมากกว่า 10,000 ตัวอย่างสองสามตัวอย่าง

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

สิ่งที่คุณสามารถใช้คือการไล่ระดับสีแบบสุ่มเพื่อแก้ปัญหาการหาค่าเหมาะที่สุด Sklearn มีSGDRegressor คุณต้องใช้loss='epsilon_insensitive'เพื่อให้ได้ผลลัพธ์ที่คล้ายกับ linear SVM ดูเอกสารประกอบ ฉันจะใช้การไล่ระดับสีเป็นทางเลือกสุดท้ายแม้ว่าจะเป็นเพราะมันหมายถึงการปรับเปลี่ยนมากเกินไปของพารามิเตอร์เพื่อหลีกเลี่ยงการติดอยู่ในท้องถิ่นน้อยที่สุด ใช้LinearSVRถ้าคุณสามารถ

คุณรวมมาตราส่วนไว้ในขั้นตอนการประมวลผลล่วงหน้าหรือไม่ ฉันมีปัญหานี้เมื่อใช้งาน SVM ชุดข้อมูลของฉันคือ ~ 780,000 ตัวอย่าง (แถว) ที่มี 20 คุณสมบัติ (สี) ชุดการฝึกอบรมของฉันคือ ~ 235k ตัวอย่าง ปรากฎว่าฉันเพิ่งลืมปรับขนาดข้อมูลของฉัน! หากเป็นกรณีนี้ลองเพิ่มบิตนี้ในรหัสของคุณ:

ปรับขนาดข้อมูลเป็น [-1,1]; เพิ่มความเร็ว SVM:

จาก sklearn.preprocessing การนำเข้า MinMaxScaler
scaling = MinMaxScaler (feature_range = (- 1,1)) พอดี (X_train)
X_train = scaling.transform (X_train)
X_test = scaling.transform (X_test)

ด้วยชุดข้อมูลขนาดใหญ่เช่นนี้ฉันคิดว่าคุณน่าจะดีกว่าด้วยการใช้โครงข่ายประสาทการเรียนรู้ลึกป่าสุ่ม (พวกมันน่าประหลาดใจมาก) เป็นต้น

ดังที่ได้กล่าวไว้ในคำตอบก่อนหน้าเวลาที่ใช้เป็นสัดส่วนกับกำลังงานที่สามของจำนวนตัวอย่างการฝึกอบรม แม้แต่เวลาทำนายก็คือพหุนามในรูปของจำนวนเวกเตอร์ทดสอบ

หากคุณต้องใช้ SVM จริงๆฉันขอแนะนำให้ใช้ความเร็ว GPU หรือลดขนาดชุดข้อมูลการฝึกอบรม ลองใช้ตัวอย่าง (อาจมี 10,000 แถว) ของข้อมูลก่อนเพื่อดูว่าไม่ใช่ปัญหาของรูปแบบข้อมูลหรือการกระจาย

ตามที่กล่าวไว้ในคำตอบอื่น ๆ เมล็ดเชิงเส้นจะเร็วขึ้น

ฉันเพิ่งพบปัญหาที่คล้ายกันเนื่องจากลืมปรับขนาดคุณสมบัติในชุดข้อมูลของฉันซึ่งก่อนหน้านี้ใช้ในการฝึกอบรมประเภทของวงดนตรีชุด ความล้มเหลวในการขยายขนาดข้อมูลอาจเป็นสาเหตุของความเสี่ยงตามที่ Shelby Matlock ชี้ คุณอาจลองใช้เครื่องมือขูดที่มีอยู่ใน sklearn เช่นRobustScaler :

from sklearn.preprocessing import RobustScaler scaler = RobustScaler() X = scaler.fit_transfrom(X)

ตอนนี้ X จะถูกเปลี่ยน / ปรับสัดส่วนและพร้อมที่จะป้อนเข้ากับรุ่นที่คุณต้องการ

มันสมเหตุสมผลแล้ว IIUC ความเร็วของการดำเนินการสนับสนุนเวกเตอร์สนับสนุนนั้นถูกผูกไว้ด้วยจำนวนตัวอย่างไม่ใช่มิติข้อมูล กล่าวอีกนัยหนึ่งมันถูก จำกัด ด้วยเวลาของ CPU และไม่ใช่ RAM ฉันไม่แน่ใจว่าจะต้องใช้เวลาเท่าไร แต่ฉันใช้มาตรฐานเพื่อค้นหา

ปล่อยให้วิ่งข้ามคืนหรือดีกว่าเป็นเวลา 24 ชั่วโมง การใช้งาน CPU ของคุณคืออะไร หากไม่มีแกนใดทำงานอยู่ที่ 100% แสดงว่าคุณมีปัญหา อาจมีหน่วยความจำ คุณได้ตรวจสอบว่าชุดข้อมูลของคุณเหมาะกับ 8GB หรือไม่? คุณลอง SGDClassifier แล้วหรือยัง มันเป็นหนึ่งในรถที่เร็วที่สุด คุ้มค่าที่จะลองดูก่อนหวังว่าจะเสร็จในอีกประมาณหนึ่งชั่วโมง

ลองปรับมาตรฐานข้อมูลเป็น [-1,1] ฉันประสบปัญหาคล้ายกันและเมื่อทุกอย่างทำงานปกติได้ดี คุณสามารถทำให้ข้อมูลกลับสู่ปกติได้อย่างง่ายดายโดยใช้:

from sklearn import preprocessing X_train = preprocessing.scale(X_train) X_test = preprocessing.scale(X_test)

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

อย่างที่คุณทราบSVCและSVRเป็นปัญหาการปรับให้เหมาะสมและจะหยุดเมื่อระยะขอบของข้อผิดพลาดน้อยมาก ดังนั้นจึงมีพารามิเตอร์อื่นในสิ่งเหล่านี้max_iterซึ่งคุณสามารถกำหนดจำนวนการวนซ้ำที่ควรทำ

ฉันใช้sklearnใน python และe1071ใน R และ R นั้นเร็วขึ้นมากโดยไม่ต้องตั้งค่าmax_iterและsklearnใช้เวลานานกว่า 2-4 เท่า max_iterวิธีเดียวที่ฉันจะได้นำมาลงเวลาในการคำนวณสำหรับหลามใช้ มันเป็นญาติกับความซับซ้อนของรูปแบบของคุณจำนวนของคุณสมบัติและเมล็ด hyperparameters แต่สำหรับชุดข้อมูลขนาดเล็กผมใช้ประมาณ 4000 DataPoint และmax_iterเป็น10000ผลที่ได้ก็ไม่ได้แตกต่างกันเลยและมันก็เป็นที่ยอมรับ

ฉันเพิ่งมีปัญหาที่คล้ายกันกับชุดข้อมูลซึ่งมีองค์ประกอบเพียง 115 และคุณลักษณะเดียวเท่านั้น (ข้อมูลสายการบินระหว่างประเทศ) ทางออกคือการปรับขนาดข้อมูล สิ่งที่ฉันไม่ได้รับคำตอบในตอนนี้คือการใช้งาน Pipeline:

from sklearn.svm import SVR
from sklearn.preprocessing import StandardScaler, MinMaxScaler

model = Pipeline([('scaler', StandardScaler()),
                  ('svr', SVR(kernel='linear'))])

คุณสามารถฝึกได้modelเหมือนการจำแนก / ถดถอยแบบปกติและประเมินแบบเดียวกัน ไม่มีการเปลี่ยนแปลงอะไรเลยมีเพียงความหมายของแบบจำลอง

คุณต้องปรับขนาดข้อมูลของคุณ การปรับสเกลจะทำให้มาตรฐานข้อมูลของคุณอยู่ในช่วง -1 ถึง 1 ซึ่งจะช่วยให้เกิดการลู่เข้าที่เร็วขึ้น

ลองใช้รหัสต่อไปนี้:

# X is your numpy data array.

from sklearn import preprocessing

X = preprocessing.scale(X)