Quantilregression als lineares Programmierproblem formulieren?

Wie formuliere ich die Quantilregression als lineares Programmierproblem? Wenn ich mir das mittlere Quantilproblem anschaue, weiß ich, dass es das ist

$$\begin{align} \text{minimize } & \sum_{i=1}^n |\beta_0 + X_i \beta_1-Y_i|\\ \text{transforms into } & \\ \text{minimize } & \sum_{i=1}^n e_i\\ \text{s.t.} & \\ & e_i\geq \beta_0 + X_i\beta_{1}-Y_i\\ & e_i\geq -(\beta_0 + X_i\beta_{1}-Y_i) \end{align}$$ aber wie transformiere ich die Minimierung für andere Quantile?

Sie verwenden den Quantilregressionsschätzer

$$\hat \beta(\tau) := \arg \min_{\theta \in \mathbb R^K} \sum_{i=1}^N \rho_\tau(y_i - \mathbf x_i^\top \theta).$$

Dabei ist $\tau \in (0,1)$ eine Konstante, nach der das Quantil geschätzt werden muss, und die Funktion $\rho_\tau(.)$ ist definiert als

$$\rho_\tau(r) = r(\tau - I(r<0)).$$

Um den Zweck von betrachten Sie zunächst, dass die Residuen als Argumente verwendet werden, wenn diese als . Die Summe im Minimierungsproblem kann daher umgeschrieben werden als$\rho_\tau(.)$$\epsilon_i =y_i - \mathbf x_i^\top \theta$

$$\sum_{i=1}^N \rho_\tau(\epsilon_i) =\sum_{i=1}^N \tau \lvert \epsilon_i \lvert I[\epsilon_i \geq 0] + (1-\tau) \lvert \epsilon_i \lvert I[\epsilon_i < 0]$$

so dass positive Residuen, die mit der Beobachtung oberhalb der vorgeschlagenen Quantilregressionslinie assoziiert sind, das Gewicht von während negative Residuen, die mit Beobachtungen unterhalb der vorgeschlagenen Quantilregressionslinie assoziiert sind werden mit gewichtet .$y_i$$\mathbf x_i^\top \theta$$\tau$$y_i$$\mathbf x_i^\top \theta$$(1-\tau)$

Intuitiv:

Mit positive und negative Residuen mit dem gleichen Gewicht "bestraft" und eine gleiche Anzahl von Beobachtungen befindet sich optimal über und unter der "Linie", so dass die Linie die mittlere Regression ist "Linie".$\tau=0.5$$\mathbf x_i^\top \hat \beta$

Wenn jedes positive Residuum 9-mal so gewichtet wie das eines negativen Residuums mit einem Gewicht von und somit optimal für jede Beobachtung über der "Linie" ungefähr 9 unter der Linie platziert werden. Daher repräsentiert die "Linie" das 0,9-Quantil. (Für eine genaue Aussage siehe THM. 2.2 und Korollar 2.1 in Koenker (2005) "Quantile Regression")$\tau=0.9$$1-\tau= 0.1$$\mathbf x_i^\top \hat \beta$

Die beiden Fälle sind in diesen Darstellungen dargestellt. Linkes Feld und rechtes Feld .$\tau=0.5$$\tau=0.9$

Lineare Programme werden überwiegend mit dem Standardformular analysiert und gelöst

$$(1) \ \ \min_z \ \ c^\top z \ \ \mbox{subject to } A z = b , z \geq 0$$

Um zu einem linearen Programm in Standardform zu gelangen, besteht das erste Problem darin, dass in einem solchen Programm (1) alle Variablen, über die die Minimierung durchgeführt wird, positiv sein sollten. Um dies zu erreichen, werden Residuen unter Verwendung von Slack-Variablen in positive und negative Teile zerlegt:$z$

$$\epsilon_i = u_i - v_i$$

wobei positiver Teil und ist der negative Teil. Die Summe der Residuen, denen durch die Prüffunktion Gewichte zugewiesen wurden, wird dann als gesehen$u_i = \max(0,\epsilon_i) = \lvert \epsilon_i \lvert I[\epsilon_i \geq 0]$$v_i = \max(0,-\epsilon_i) =\lvert \epsilon_i \lvert I[\epsilon_i < 0]$

$$\sum_{i=1}^N \rho_\tau(\epsilon_i) = \sum_{i=1}^N \tau u_i + (1-\tau) v_i = \tau \mathbf 1_N^\top u + (1-\tau)\mathbf 1_N^\top v,$$

Dabei ist und und Vektor alle Koordinaten gleich .$u = (u_1,...,u_N)^\top$$v=(v_1,...,v_N)^\top$$\mathbf 1_N$$N \times 1$$1$

Die Residuen müssen die Bedingungen erfüllen, die$N$

$$y_i - \mathbf x_i^\top\theta = \epsilon_i = u_i - v_i$$

Dies führt zur Formulierung als lineares Programm

$$\min_{\theta \in \mathbb R^K,u\in \mathbb R_+^N,v\in \mathbb R_+^N}\{ \tau \mathbf 1_N^\top u + (1-\tau)\mathbf 1_N^\top v\lvert y_i= \mathbf x_i\theta + u_i - v_i, i=1,...,N\},$$

wie in Koenker (2005) "Quantile Regression", Seite 10, Gleichung (1.20) angegeben.

Es fällt jedoch auf, dass immer noch nicht darauf beschränkt ist, positiv zu sein, wie es im linearen Programm auf Standardform (1) erforderlich ist. Daher wird wieder eine Zerlegung in einen positiven und einen negativen Teil verwendet$\theta\in \mathbb R$

$$\theta = \theta^+ - \theta^-$$

wobei wiederum ein positiver Teil und ein negativer Teil ist. Die Bedingungen können dann geschrieben werden als$\theta^+=max(0,\theta)$$\theta^- = \max(0,-\theta)$$N$

$$\mathbf y:= \begin{bmatrix} y_1 \\ \vdots \\ y_N\end{bmatrix} = \begin{bmatrix} \mathbf x_1^\top \\ \vdots \\ \mathbf x_N^\top \end{bmatrix}(\theta^+ - \theta^-) + \mathbf I_Nu - \mathbf I_Nv ,$$

Dabei ist .$\mathbf I_N = diag\{\mathbf 1_N\}$

Definieren Sie als nächstes und die Entwurfsmatrix der Daten für unabhängige Variablen als gespeichert werden$b:=\mathbf y$$\mathbf X$

$$\mathbf X := \begin{bmatrix} \mathbf x_1^\top \\ \vdots \\ \mathbf x_N^\top \end{bmatrix}$$

So schreiben Sie die Einschränkung neu:

$$b= \mathbf X(\theta^+ - \theta^-) + \mathbf I_N u- \mathbf I_N v= [\mathbf X , -\mathbf X , \mathbf I_N ,\mathbf - \mathbf I_N] \begin{bmatrix} \theta^+ \\ \theta^- \\ u \\ v\end{bmatrix}$$

Definieren Sie die Matrix$(N \times 2K + 2N )$

$$A := [\mathbf X , -\mathbf X , \mathbf I_N ,\mathbf - \mathbf I_N]$$ und und als Variablen ein, über die minimiert werden soll, damit sie Teil von , um zu erhalten$\theta^+$$\theta^-$$z$

$$b = A \begin{bmatrix} \theta^+ \\ \theta^- \\ u \\ v\end{bmatrix} = Az$$

Da und das Minimierungsproblem nur durch die Bedingung beeinflussen, muss a der Dimension als Teil des Koeffizientenvektors , der entsprechend definiert werden kann als$\theta^+$$\theta^-$$\mathbf 0$$2K\times 1$$c$

$$c = \begin{bmatrix}\mathbf 0 \\ \tau \mathbf 1_N \\ (1-\tau) \mathbf 1_N \end{bmatrix},$$

Dadurch wird sichergestellt, dass$c^\top z = \underbrace{\mathbf 0^\top(\theta^+ - \theta^-)}_{=0}+\tau \mathbf 1_N^\top u + (1-\tau)\mathbf 1_N^\top v = \sum_{i=1}^N \rho_\tau(\epsilon_i).$

Daher werden dann und definiert und das in angegebene Programm vollständig spezifiziert.$c,A$$b$$(1)$

Dies wird wahrscheinlich am besten anhand eines Beispiels verdaut. Um dies in R zu lösen, verwenden Sie das Paket quantreg von Roger Koenker. Hier sehen Sie auch, wie Sie das lineare Programm einrichten und mit einem Löser für lineare Programme lösen:

base=read.table("http://freakonometrics.free.fr/rent98_00.txt",header=TRUE)
attach(base)
library(quantreg)
library(lpSolve)
tau <- 0.3


# Problem (1) only one covariate
X <- cbind(1,base$area)
K <- ncol(X)
N <- nrow(X)

A <- cbind(X,-X,diag(N),-diag(N))
c <- c(rep(0,2*ncol(X)),tau*rep(1,N),(1-tau)*rep(1,N))
b <- base$rent_euro
const_type <- rep("=",N)

linprog <- lp("min",c,A,const_type,b)
beta <- linprog$sol[1:K] -  linprog$sol[(1:K+K)]
beta
rq(rent_euro~area, tau=tau, data=base)


# Problem (2) with 2 covariates
X <- cbind(1,base$area,base$yearc)
K <- ncol(X)
N <- nrow(X)

A <- cbind(X,-X,diag(N),-diag(N))
c <- c(rep(0,2*ncol(X)),tau*rep(1,N),(1-tau)*rep(1,N))
b <- base$rent_euro
const_type <- rep("=",N)

linprog <- lp("min",c,A,const_type,b)
beta <- linprog$sol[1:K] -  linprog$sol[(1:K+K)]
beta
rq(rent_euro~ area + yearc, tau=tau, data=base)

Ich habe den Code von Jesper Hybel in Python mit cvxopt umgeschrieben. Ich poste es hier, falls jemand anderes dies auch in Python benötigt.

import pandas as pd
import io
import requests
import numpy as np
url="http://freakonometrics.free.fr/rent98_00.txt"
s=requests.get(url).content
base=pd.read_csv(io.StringIO(s.decode('utf-8')), sep='\t')


tau = 0.3

from cvxopt import matrix, solvers

X = pd.DataFrame(columns=[0,1])
X[1] = base["area"] #data points for independent variable area
X[2] = base["yearc"] #data points for independent variable year
X[0] = 1 #intercept

K = X.shape[1]
N = X.shape[0]

# equality constraints - left hand side

A1 = X.to_numpy() # intercepts & data points - positive weights
A2 = X.to_numpy() * - 1 # intercept & data points - negative weights
A3 = np.identity(N) # error - positive
A4 = np.identity(N)*-1 # error - negative

A = np.concatenate((A1,A2,A3,A4 ), axis= 1) #all the equality constraints 

# equality constraints - right hand side
b = base["rent_euro"].to_numpy()

#goal function - intercept & data points have 0 weights
#positive error has tau weight, negative error has 1-tau weight
c = np.concatenate((np.repeat(0,2*K), tau*np.repeat(1,N), (1-tau)*np.repeat(1,N) ))

#converting from numpy types to cvxopt matrix

Am = matrix(A)
bm = matrix(b)
cm = matrix(c)

# all variables must be greater than zero
# adding inequality constraints - left hand side
n = Am.size[1]
G = matrix(0.0, (n,n))
G[::n+1] = -1.0

# adding inequality constraints - right hand side (all zeros)
h = matrix(0.0, (n,1))

#solving the model
sol = solvers.lp(cm,G,h,Am,bm, solver='glpk')

x = sol['x']

#both negative and positive components get values above zero, this gets fixed here
beta = x[0:K] - x[K :2*K]

print(beta)
```