गैर-सममितीय लागत फ़ंक्शन के साथ रैखिक प्रतिगमन?

Question

मैं कुछ मूल्य भविष्यवाणी करना चाहता हूं और मैं कुछ भविष्यवाणी प्राप्त करने का प्रयास कर रहा हूं जो कि यथासंभव कम होने के बीच अनुकूलन करता है, लेकिन अभी भी से बड़ा है । दूसरे शब्दों में: $Y(x)$$\hat Y(x)$$Y(x)$

$$\text{cost}\left\{ Y(x) \gtrsim \hat Y(x) \right\} >> \text{cost}\left\{ \hat Y(x) \gtrsim Y(x) \right\}$$

मुझे लगता है कि एक साधारण रेखीय प्रतिगमन पूरी तरह से ठीक करना चाहिए। इसलिए मैं कुछ हद तक इसे मैन्युअल रूप से लागू करना जानता हूं, लेकिन मुझे लगता है कि मैं इस तरह की समस्या वाला पहला व्यक्ति नहीं हूं। क्या कोई पैकेज / लाइब्रेरी (अधिमानतः अजगर) है, जो मैं करना चाहता हूं? मुझे कौन सा कीवर्ड ढूंढना है?

क्या होगा अगर मुझे कोई फ़ंक्शन पता था $Y_0(x) > 0$ जहां $Y(x) > Y_0(x)$ । इन प्रतिबंधों को लागू करने का सबसे अच्छा तरीका क्या है?

Comments

संभवतः, सबसे सरल समाधान यह है कि भविष्यवाणी सकारात्मक या नकारात्मक है, इस आधार पर विभिन्न भार का उपयोग करना है। मुझे पहले ऐसा सोचना चाहिए था।

— asPlankBridge

Answer 1

अगर मैं आपको सही तरीके से समझता हूं, तो आप overestimating के पक्ष में गलती करना चाहते हैं। यदि हां, तो आपको एक उपयुक्त, असममित लागत फ़ंक्शन की आवश्यकता है। एक साधारण उम्मीदवार चुकता नुकसान को मोड़ना है:

$\mathcal L: (x,\alpha) \to x^2 \left( \mathrm{sgn} x + \alpha \right)^2$

जहाँ एक पैरामीटर है जिसे आप ओवरस्टीमेशन के खिलाफ कम करके आंका जा सकता है। सकारात्मक मूल्य overestimation को दंडित करते हैं, इसलिए आप नकारात्मक सेट करना चाहेंगे । अजगर में यह दिखता है$-1 < \alpha < 1$$\alpha$$\alpha$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))

अंत में, हम tensorflowGoogle से एक मशीन लर्निंग लाइब्रेरी में अपना रिग्रेशन करेंगे , जो स्वचालित भेदभाव (ऐसी समस्याओं का ग्रेडिएंट-बेस्ड ऑप्टिमाइज़ेशन को सरल बनाने) का समर्थन करती है। मैं इस उदाहरण का उपयोग प्रारंभिक बिंदु के रूप में करूंगा ।

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स्पष्ट रूप से कम नहीं करने की कोशिश करता है। मैंने अभिसरण के लिए जाँच नहीं की, लेकिन आपको यह विचार मिल गया।

Comments

इस विस्तृत उत्तर के लिए धन्यवाद: acostफ़ंक्शन की परिभाषा के लिए एक प्रश्न । क्या यह मायने रखता है कि आप y_model-Yदो बार गणना करते हैं ?

— asPlankBridge

आप गति के संदर्भ में मतलब है? मुझे नहीं पता; आपको यह देखने के लिए खुद को समय देना होगा कि क्या टेंसोफ़्लो पुनर्गणना से बचा जाता है। यह अन्यथा ठीक है।

— एम्रे

Answer 2

एक असममित हानि फ़ंक्शन चुनें। एक विकल्प मात्रात्मक प्रतिगमन (रैखिक लेकिन सकारात्मक और नकारात्मक त्रुटियों के लिए अलग ढलान के साथ) है।