โครงข่ายประสาท: ฟังก์ชั่นค่าใช้จ่ายที่จะใช้?

ฉันใช้TensorFlowสำหรับการทดลองกับเครือข่ายประสาทเป็นหลัก แม้ว่าตอนนี้ฉันได้ทำการทดลองบ้างแล้ว (XOR-Problem, MNIST, Regression บางอย่าง, ... ) ตอนนี้ฉันต่อสู้กับการเลือกฟังก์ชั่นต้นทุนที่ "ถูกต้อง" สำหรับปัญหาเฉพาะเพราะโดยรวมแล้วฉันถือว่าเป็นมือใหม่

ก่อนที่จะมาที่ TensorFlow ฉันเขียนรหัส MLP ที่เชื่อมต่ออย่างเต็มที่และเครือข่ายที่เกิดขึ้นเองด้วยPythonและNumPyแต่ส่วนใหญ่ฉันมีปัญหาที่ข้อผิดพลาดยกกำลังสองง่ายและการไล่ระดับสีอย่างง่ายนั้นเพียงพอ

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

ในการให้ตัวอย่าง:

cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(y_output, y_train))

ฉันเดาว่ามันใช้ฟังก์ชั่น softmax กับทั้งสองอินพุตเพื่อให้ผลรวมของเวกเตอร์หนึ่งเท่ากับ 1 แต่ไขว้เอนโทรปีของการบันทึกคืออะไร ฉันคิดว่ามันสรุปค่าและคำนวณค่าเอนโทรปีของการไขว้ ... ดังนั้นการวัดบางอย่าง?! นี่จะไม่เหมือนกันหรือไม่ถ้าฉันเอาท์พุทเป็นปกติ, หาผลรวมมันออกมา นอกจากนี้เหตุใดจึงใช้สิ่งนี้เช่นสำหรับ MNIST (หรือปัญหาที่ยากกว่า) เมื่อฉันต้องการที่จะจัดเช่น 10 หรือแม้กระทั่ง 1000 เรียนไม่ได้ข้อสรุปถึงค่าที่สมบูรณ์ทำลายข้อมูลใด ๆ เกี่ยวกับการที่ชั้นเป็นจริงการส่งออกหรือไม่

cost = tf.nn.l2_loss(vector)

นี่มีไว้เพื่ออะไร? ฉันคิดว่าการสูญเสีย l2 นั้นเป็นข้อผิดพลาดกำลังสอง แต่ API ของ TensorFlow บอกว่าอินพุตของมันเป็นเพียงเทนเซอร์เดียว ไม่ได้รับความคิดเลยหรือ!

นอกจากนี้ฉันเห็นนี้สำหรับเอนโทรปีข้ามสวยบ่อย:

cross_entropy = -tf.reduce_sum(y_train * tf.log(y_output))

... แต่ทำไมถึงใช้งาน ไม่ใช่การสูญเสียในเอนโทรปีของการคำนวณทางคณิตศาสตร์:

-1/n * sum(y_train * log(y_output) + (1 - y_train) * log(1 - y_output))

เป็นที่(1 - y_train) * log(1 - y_output)มีส่วนร่วมในตัวอย่าง TensorFlow มากที่สุด? มันหายไปเหรอ?

คำตอบ:ฉันรู้ว่าคำถามนี้เปิดค่อนข้างมาก แต่ฉันไม่คาดหวังว่าจะได้รับเหมือน 10 หน้ากับทุกปัญหา / ฟังก์ชั่นค่าใช้จ่ายที่ระบุไว้ในรายละเอียด ฉันต้องการสรุปสั้น ๆ เกี่ยวกับเวลาที่จะใช้ฟังก์ชั่นค่าใช้จ่าย (โดยทั่วไปหรือใน TensorFlow ไม่สำคัญกับฉันมากนัก) และคำอธิบายบางอย่างเกี่ยวกับหัวข้อนี้ และ / หรือแหล่งที่มาบางส่วนสำหรับผู้เริ่มต้น;)

คำตอบนี้อยู่ในด้านทั่วไปของฟังก์ชั่นค่าใช้จ่ายซึ่งไม่เกี่ยวข้องกับ TensorFlow และส่วนใหญ่จะกล่าวถึง "คำอธิบายบางส่วนเกี่ยวกับหัวข้อนี้" ในคำถามของคุณ

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

หากคุณต้องการคำตอบเกี่ยวกับ Cross-Entropy, Logit, L2 norms หรืออะไรก็ตามที่เฉพาะเจาะจงฉันแนะนำให้คุณโพสต์คำถามที่เฉพาะเจาะจงมากกว่านี้ สิ่งนี้จะเพิ่มโอกาสในการที่คนที่มีความรู้เฉพาะจะเห็นคำถามของคุณ

การเลือกฟังก์ชั่นค่าใช้จ่ายที่เหมาะสมเพื่อให้ได้ผลลัพธ์ที่ต้องการเป็นจุดสำคัญของปัญหาการเรียนรู้ของเครื่อง วิธีการพื้นฐานหากคุณไม่ทราบว่าสิ่งที่คุณต้องการออกจากวิธีการของคุณคือการใช้Mean Square Error (Wikipedia)สำหรับปัญหาการถดถอยและร้อยละของข้อผิดพลาดสำหรับปัญหาการจำแนก อย่างไรก็ตามหากคุณต้องการผลลัพธ์ที่ดีออกมาจากวิธีการของคุณคุณต้องกำหนดสิ่งที่ดีและกำหนดฟังก์ชันต้นทุนที่เพียงพอ สิ่งนี้มาจากความรู้ทั้งโดเมน (ข้อมูลของคุณคืออะไรคุณพยายามทำอะไร) และความรู้เกี่ยวกับเครื่องมือต่างๆ

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

เพื่อแสดงให้เห็นความแตกต่างระหว่างการทำงานต่าง ๆ ค่าใช้จ่ายให้เราใช้ตัวอย่างของปัญหาการจัดหมวดหมู่ไบนารีที่เราต้องการสำหรับแต่ละตัวอย่างชั้น\}$x_n$$f(x_n) \in \{0,1\}$

เริ่มต้นด้วยคุณสมบัติการคำนวณ ; ฟังก์ชั่นสองอย่างที่วัด "สิ่งเดียวกัน" สามารถนำไปสู่ผลลัพธ์ที่ต่างกันได้อย่างไร ทำหน้าที่ดังต่อไปนี้ฟังก์ชั่นค่าใช้จ่ายอย่างง่าย ร้อยละของข้อผิดพลาด หากคุณมีตัวอย่างเป็นคลาสที่ทำนายไว้และเป็นคลาสจริงคุณต้องการย่อขนาดเล็กสุด$N$$f(y_n)$$y_n$

• $\frac{1}{N} \sum_n \left\{ \begin{array}{ll} 1 & \text{ if } f(x_n) \not= y_n\\ 0 & \text{ otherwise}\\ \end{array} \right. = \sum_n y_n[1-f(x_n)] + [1-y_n]f(x_n)$(x_n)

ฟังก์ชันต้นทุนนี้มีประโยชน์ในการตีความได้อย่างง่ายดาย อย่างไรก็ตามมันไม่ราบรื่น หากคุณมีเพียงสองตัวอย่างฟังก์ชัน "กระโดด" จาก 0 ถึง 0.5 ถึง 1 สิ่งนี้จะนำไปสู่ความไม่ลงรอยกันถ้าคุณพยายามใช้การไล่ระดับสีลงบนฟังก์ชันนี้ วิธีหนึ่งที่จะหลีกเลี่ยงคือเปลี่ยนฟังก์ชั่นราคาเพื่อใช้ความน่าจะเป็นของการมอบหมาย x_n) ฟังก์ชั่นจะกลายเป็น$p(y_n = 1 | x_n)$

• $\frac{1}{N} \sum_n y_n p(y_n = 0 | x_n) + (1 - y_n) p(y_n = 1 | x_n)$x_n)

ฟังก์ชั่นนี้ราบรื่นและจะทำงานได้ดีขึ้นด้วยวิธีการไล่ระดับสี คุณจะได้รับโมเดล 'ละเอียดกว่า' อย่างไรก็ตามมีปัญหาอื่น ๆ ถ้าคุณมีตัวอย่างที่ไม่ชัดเจนก็ขอให้บอกว่าคุณไม่ได้มีข้อมูลมากพอที่จะพูดอะไรดีกว่า0.5 จากนั้นการใช้การไล่ระดับสีลงบนฟังก์ชั่นต้นทุนนี้จะนำไปสู่รูปแบบที่เพิ่มความน่าจะเป็นนี้ให้มากที่สุด$p(y_n = 1 | x_n) = 0.5$

อีกปัญหาของฟังก์ชั่นนี้คือถ้าในขณะที่คุณมั่นใจว่าถูกต้อง แต่คุณผิด เพื่อหลีกเลี่ยงปัญหานี้คุณสามารถใช้เข้าสู่ระบบของความน่าจะเป็นที่x_n) Asและ , ฟังก์ชั่นต่อไปนี้ไม่มีปัญหาอธิบายไว้ในย่อหน้าก่อนหน้า:$p(y_n = 1 | x_n) = 1$$y_n = 0$$\log p(y_n | x_n)$$\log(0) = \infty$$\log(1) = 0$

• $\frac{1}{N} \sum_n y_n \log p(y_n = 0 | x_n) + (1 - y_n) \log p(y_n = 1 | x_n)$x_n)

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

มันเป็นไปได้สำหรับฟังก์ชั่นค่าใช้จ่ายและในการวัดแนวคิดเดียวกันแต่อาจนำไปสู่วิธีการของคุณเพื่อผลลัพธ์ที่ดีกว่าB$A$$B$$A$$B$

ทีนี้มาดูกันว่าฟังก์ชั่นค่าใช้จ่ายต่าง ๆ สามารถวัดแนวคิดที่แตกต่างกันได้อย่างไร ในบริบทของการดึงข้อมูลเช่นเดียวกับในการค้นหาของ Google (ถ้าเราไม่สนใจการจัดอันดับ) เราต้องการผลลัพธ์ที่ส่งคืน

• มีความแม่นยำสูงไม่ส่งคืนข้อมูลที่ไม่เกี่ยวข้อง
• มีการเรียกคืนสูงส่งคืนผลลัพธ์ที่เกี่ยวข้องมากที่สุด
• ความแม่นยำและการเรียกคืน (Wikipedia)

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

เพื่อที่จะตัดสินขั้นตอนวิธีการเช่นฟังก์ชั่นค่าใช้จ่ายเหมือนกันคือ -score (วิกิพีเดีย) กรณีที่เหมือนกันคือ -score ซึ่งจะช่วยให้น้ำหนักเท่ากับความแม่นยำและการเรียกคืน แต่กรณีทั่วไปมัน -score และคุณสามารถปรับแต่งที่จะได้รับ$F$$F_1$$F_\beta$$\beta$

• การเรียกคืนที่สูงขึ้นหากคุณใช้$\beta > 1$
• ความแม่นยำที่สูงขึ้นถ้าคุณใช้<1$\beta < 1$

ในสถานการณ์เช่นนี้การเลือกฟังก์ชั่นค่าใช้จ่ายจะเลือกสิ่งที่การออกอัลกอริทึมของคุณควรจะทำอย่างไร

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

• คนที่มีสุขภาพมากขึ้นที่ถูกจำแนกว่าป่วย (แต่แล้วเราอาจรักษาคนที่มีสุขภาพดีซึ่งมีราคาแพงและอาจทำร้ายพวกเขาหากพวกเขาไม่ป่วยจริง ๆ )
• คนที่ป่วยมากกว่านั้นถูกจำแนกว่ามีสุขภาพดี (แต่แล้วพวกเขาก็อาจตายโดยไม่ได้รับการรักษา)

โดยสรุปการกำหนดฟังก์ชั่นค่าใช้จ่ายเป็นการกำหนดเป้าหมายของอัลกอริทึมของคุณ อัลกอริทึมกำหนดวิธีการเดินทาง

หมายเหตุด้านข้าง: ฟังก์ชั่นค่าใช้จ่ายบางอย่างมีอัลกอริทึมที่ดีในการเข้าถึงเป้าหมายของพวกเขา ตัวอย่างเช่นมีวิธีที่ดีในการลดการสูญเสียบานพับ (Wikipedia)ขั้นต่ำโดยการแก้ไขปัญหาสองอย่างในSVM (Wikipedia)

ในการตอบคำถามของคุณเกี่ยวกับ Cross Entropy คุณจะสังเกตได้ว่าทั้งสองสิ่งที่คุณพูดถึงเป็นสิ่งเดียวกัน

$-\frac{1}{n} \sum(y\_train * \log(y\_output) + (1 - y\_train) \cdot \log(1 - y\_output))$

ที่คุณกล่าวถึงเป็นเพียงการสูญเสียเอนโทรปีของไบนารีไขว้โดยที่คุณสมมติว่าเป็นสเกลาร์ 0/1 และเป็นสเกลาร์อีกครั้งที่บ่งบอกถึงความน่าจะเป็นของผลลัพธ์ที่เป็น 1$y\_train$$y\_output$

สมการอื่น ๆ ที่คุณกล่าวถึงเป็นตัวแปรทั่วไปที่ขยายไปถึงหลายคลาส

-tf.reduce_sum(y_train * tf.log(y_output)) เป็นสิ่งเดียวกับการเขียน

$-\sum_n train\_prob \cdot \log (out\_prob)$

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

BLUF: การทดลองและข้อผิดพลาดซ้ำพร้อมชุดย่อยของข้อมูลและ matplotlib

คำตอบยาว:

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

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

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

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

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

กระบวนการทดลองและข้อผิดพลาดซ้ำ ๆ แบบนี้ทำงานได้ค่อนข้างดีสำหรับฉันและทีมงานนักวิทยาศาสตร์ด้านข้อมูลเริ่มต้นและให้เรามุ่งเน้นไปที่การหาคำตอบสำหรับคำถามของเราโดยไม่ต้องดำน้ำลึกลงไปในทฤษฎีคณิตศาสตร์ การเพิ่มประสิทธิภาพแบบจำลอง

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

หวังว่าคำตอบนี้จะช่วยให้ผู้เริ่มต้นใช้งานคนอื่น ๆ โดยไม่ต้องง่ายและชัดเจนเกินไป

ลงทะเบียนคำถามของคุณใหม่

ส่วน (1 - y_train) * บันทึก (1 - y_output) อยู่ที่ไหนในตัวอย่าง TensorFlow ส่วนใหญ่ มันหายไปเหรอ?

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

ตัวอย่างเช่น:

ก่อนที่จะปรับให้เหมาะสม

y_output = [0.2, 0.2, 0.6] และ y_train = [0, 0, 1]

หลังจากการเพิ่มประสิทธิภาพ

y_output = [0.15, 0.15, 0.7] และ y_train = [0, 0, 1]

ที่นี่สังเกตว่าแม้ว่าเราเพิ่งจะเพิ่มระยะที่สามเงื่อนไขอื่น ๆ ทั้งหมดลดลงโดยอัตโนมัติ