การถดถอยเชิงเส้นพร้อมฟังก์ชันต้นทุนที่ไม่สมมาตร


13

ฉันต้องการที่จะทำนายค่าบางและฉันพยายามที่จะได้รับบางทำนายที่เพิ่มประสิทธิภาพระหว่างการเป็นที่ต่ำที่สุดเท่าที่เป็นไปได้ แต่ยังคงความมีขนาดใหญ่กว่า(x) กล่าวอีกนัยหนึ่ง: Y ( x ) Y ( x ) ค่าใช้จ่าย{ Y ( x ) Y ( x ) } > > ค่าใช้จ่าย{ Y ( x ) Y ( x ) }Y(x)Y^(x)Y(x)

cost{Y(x)Y^(x)}>>cost{Y^(x)Y(x)}

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

เกิดอะไรขึ้นถ้าผมรู้ว่าฟังก์ชั่นY0(x)>0ที่Y(x)>Y0(x)(x) วิธีที่ดีที่สุดในการใช้ข้อ จำกัด เหล่านี้คืออะไร


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

คำตอบ:


11

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

L:(x,α)x2(sgnx+α)2

โดยที่เป็นพารามิเตอร์ที่คุณสามารถใช้เพื่อแลกเปลี่ยนกับบทลงโทษของการดูถูกดูแคลนต่อการประเมินค่าสูงไป ค่าบวกของลงโทษการประมาณค่าสูงเกินไปดังนั้นคุณจะต้องตั้งค่าเชิงลบ ในภาษาไพ ธ อนดูเหมือนว่าα α1<α<1ααdef loss(x, a): return x**2 * (numpy.sign(x) + a)**2

ฟังก์ชันการสูญเสียสำหรับสองค่าของ

ต่อไปเรามาสร้างข้อมูลกัน:

import numpy
x = numpy.arange(-10, 10, 0.1)
y = -0.1*x**2 + x + numpy.sin(x) + 0.1*numpy.random.randn(len(x))

ฟังก์ชั่นโดยพลการ

ในที่สุดเราจะทำการถดถอยของเราtensorflowซึ่งเป็นไลบรารี่การเรียนรู้ของเครื่องจาก Google ที่สนับสนุนการสร้างความแตกต่างโดยอัตโนมัติ ฉันจะใช้ตัวอย่างนี้เป็นจุดเริ่มต้น

import tensorflow as tf

X = tf.placeholder("float") # create symbolic variables
Y = tf.placeholder("float") 

w = tf.Variable(0.0, name="coeff")
b = tf.Variable(0.0, name="offset")
y_model = tf.mul(X, w) + b

cost = tf.pow(y_model-Y, 2) # use sqr error for cost function
def acost(a): return tf.pow(y_model-Y, 2) * tf.pow(tf.sign(y_model-Y) + a, 2)

train_op = tf.train.AdamOptimizer().minimize(cost)
train_op2 = tf.train.AdamOptimizer().minimize(acost(-0.5))

sess = tf.Session()
init = tf.initialize_all_variables()
sess.run(init)

for i in range(100):
    for (xi, yi) in zip(x, y): 
#         sess.run(train_op, feed_dict={X: xi, Y: yi})
        sess.run(train_op2, feed_dict={X: xi, Y: yi})

print(sess.run(w), sess.run(b))

costเป็นข้อผิดพลาดกำลังสองปกติในขณะacostที่ฟังก์ชันการสูญเสียไม่สมมาตรดังกล่าวข้างต้น

ถ้าคุณใช้costคุณจะได้รับ

1.00764 -3.32445

ราคา

ถ้าคุณใช้acostคุณจะได้รับ

1.02604 -1.07742

acost

acostพยายามอย่างชัดเจนที่จะไม่ประมาท ฉันไม่ได้ตรวจสอบการบรรจบกัน แต่คุณได้รับความคิด


ขอบคุณสำหรับคำตอบโดยละเอียดนี้: หนึ่งคำถามถึงคำจำกัดความของacostฟังก์ชัน มันสำคัญไหมที่คุณคำนวณy_model-Yสองครั้ง?
asPlankBridge

คุณหมายถึงในแง่ของความเร็ว? ฉันไม่รู้ คุณจะต้องใช้เวลาด้วยตัวคุณเองเพื่อดูว่า tensorflow หลีกเลี่ยงการคำนวณซ้ำหรือไม่ มันไม่เป็นไร
Emre

0

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

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.