Lineare Regression mit unsymmetrischer Kostenfunktion?

Ich möchte einen Wert vorhersagen und ich versuche, eine Vorhersage zu erhalten, bei der so niedrig wie möglich ist, aber immer noch größer als . Mit anderen Worten: Y ( x ) , Y ( x ) Kosten { Y ( x ) ≳ Y ( x ) } > > Kosten { Y ( x ) ≳ Y ( x ) $Y(x)$$\hat Y(x)$$Y(x)$

Ich denke, eine einfache lineare Regression sollte völlig in Ordnung sein. Ich weiß also etwas, wie man dies manuell implementiert, aber ich glaube, ich bin nicht der erste, der mit dieser Art von Problem konfrontiert ist. Gibt es Pakete / Bibliotheken (vorzugsweise Python), die das tun, was ich tun möchte? Nach welchem ​​Schlüsselwort muss ich suchen?

Was wäre, wenn ich eine Funktion wüsste, wobei . Wie können diese Einschränkungen am besten umgesetzt werden?Y ( x ) > Y 0 ( x $Y_0(x) > 0$$Y(x) > Y_0(x)$

Wenn ich dich richtig verstehe, willst du auf der Seite der Überschätzung irren. In diesem Fall benötigen Sie eine entsprechende asymmetrische Kostenfunktion. Ein einfacher Kandidat besteht darin, den quadratischen Verlust zu optimieren:

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

Dabei ist $-1 < \alpha < 1$ ein Parameter, mit dem Sie die Strafe der Unterschätzung gegen die Überschätzung austauschen können. Positive Werte von $\alpha$ beeinträchtigen die Überschätzung, daher sollten Sie $\alpha$ negativ setzen. In Python sieht das so ausdef loss(x, a): return x**2 * (numpy.sign(x) + a)**2

Als nächstes generieren wir einige Daten:

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))

Schließlich werden wir unsere Regression in tensorfloweiner maschinellen Lernbibliothek von Google durchführen, die die automatisierte Differenzierung unterstützt (wodurch die gradientenbasierte Optimierung solcher Probleme einfacher wird). Ich werde dieses Beispiel als Ausgangspunkt verwenden.

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))

costist der reguläre quadratische Fehler, während acostdie oben erwähnte asymmetrische Verlustfunktion ist.

Wenn Sie verwenden, erhalten costSie

1.00764 -3.32445

Wenn Sie verwenden, erhalten acostSie

1,02604 -1,07742

acostversucht eindeutig nicht zu unterschätzen. Ich habe nicht auf Konvergenz geprüft, aber Sie haben die Idee.

Wählen Sie eine asymmetrische Verlustfunktion. Eine Option ist die Quantilregression (linear, jedoch mit unterschiedlichen Steigungen für positive und negative Fehler).