Regressione lineare con funzione di costo non simmetrica?

Voglio prevedere un valore e sto cercando di ottenere una previsione che ottimizzi tra l'essere il più basso possibile, ma che sia comunque maggiore di . In altre parole: Y ( x ) Y ( x ) costo { Y ( x ) ≳ Y ( x ) } > > costo { Y ( x ) ≳ Y ( x ) $Y(x)$$\hat Y(x)$$Y(x)$

Penso che una semplice regressione lineare dovrebbe fare del tutto bene. Quindi so in qualche modo come implementarlo manualmente, ma credo di non essere il primo con questo tipo di problema. Ci sono pacchetti / librerie (preferibilmente python) là fuori che fanno quello che voglio fare? Qual è la parola chiave che devo cercare?

E se conoscessi una funzione $Y_0(x) > 0$ dove $Y(x) > Y_0(x)$ . Qual è il modo migliore per attuare queste restrizioni?

Se ti capisco correttamente, vuoi sbagliare dal punto di vista della sopravvalutazione. In tal caso, è necessaria una funzione di costo asimmetrica appropriata. Un semplice candidato è quello di modificare la perdita quadrata:

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

dove è un parametro che è possibile utilizzare per compensare la penalità di sottovalutazione e sovrastima. I valori positivi di penalizzano la sovrastima, quindi vorrai impostare negativo. In Python sembra$-1 < \alpha < 1$$\alpha$$\alpha$def loss(x, a): return x**2 * (numpy.sign(x) + a)**2

Quindi generiamo alcuni dati:

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

Infine, faremo la nostra regressione in tensorflowuna libreria di apprendimento automatico di Google che supporta la differenziazione automatizzata (semplificando l'ottimizzazione basata su gradiente di tali problemi). Userò questo esempio come punto di partenza.

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è l'errore quadratico regolare, mentre acostè la funzione di perdita asimmetrica sopra menzionata.

Se lo usi costottieni

1.00764 -3.32445

Se lo usi acostottieni

1.02604 -1.07742

acostcerca chiaramente di non sottovalutare. Non ho verificato la convergenza, ma hai avuto l'idea.

Scegli una funzione di perdita asimmetrica. Un'opzione è la regressione quantile (lineare ma con pendenze diverse per errori positivi e negativi).