Hồi quy tuyến tính với hàm chi phí không đối xứng?

Tôi muốn dự đoán một số giá trị và tôi đang cố gắng để có được một số dự đoán tối ưu hóa giữa mức thấp nhất có thể, nhưng vẫn lớn hơn . Nói cách khác: $Y(x)$$\hat Y(x)$$Y(x)$

Tôi nghĩ rằng một hồi quy tuyến tính đơn giản nên làm hoàn toàn tốt. Vì vậy, tôi phần nào biết cách thực hiện điều này bằng tay, nhưng tôi đoán tôi không phải là người đầu tiên gặp vấn đề này. Có bất kỳ gói / thư viện (tốt nhất là python) ngoài kia đang làm những gì tôi muốn làm không? Từ khóa tôi cần tìm là gì?

Điều gì xảy ra nếu tôi biết một hàm $Y_0(x) > 0$ trong đó $Y(x) > Y_0(x)$ . Cách tốt nhất để thực hiện những hạn chế này là gì?

Nếu tôi hiểu bạn một cách chính xác, bạn muốn sai lầm khi đánh giá quá cao. Nếu vậy, bạn cần một hàm chi phí không đối xứng thích hợp. Một ứng cử viên đơn giản là điều chỉnh tổn thất bình phương:

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

trong đó $-1 < \alpha < 1$ là tham số bạn có thể sử dụng để đánh đổi hình phạt đánh giá thấp so với đánh giá quá cao. Các giá trị dương của $\alpha$ bị phạt quá mức, vì vậy bạn sẽ muốn đặt $\alpha$ âm. Trong python điều này trông giống nhưdef loss(x, a): return x**2 * (numpy.sign(x) + a)**2

Tiếp theo hãy tạo một số dữ liệu:

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

Cuối cùng, chúng tôi sẽ thực hiện hồi quy của mình tensorflow, một thư viện máy học từ Google hỗ trợ phân biệt tự động (làm cho việc tối ưu hóa dựa trên độ dốc của các vấn đề như vậy trở nên đơn giản hơn). Tôi sẽ sử dụng ví dụ này như một điểm khởi đầu.

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

costlà lỗi bình phương thông thường, trong khi đó acostlà hàm mất bất đối xứng đã nói ở trên.

Nếu bạn sử dụng costbạn nhận được

1.00764 -3.32445

Nếu bạn sử dụng acostbạn nhận được

1.02604 -1.07742

acostrõ ràng cố gắng không đánh giá thấp. Tôi đã không kiểm tra sự hội tụ, nhưng bạn có ý tưởng.

Chọn một hàm mất bất đối xứng. Một lựa chọn là hồi quy lượng tử (tuyến tính nhưng có độ dốc khác nhau cho các lỗi dương và âm).