[PYTHON] [Statistiques] [R] Essayez d'utiliser la régression par points de division.

Ceci est une introduction à une méthode appelée régression des points de division.

Une droite de régression normale peut être interprétée comme une espérance conditionnelle (moyenne) de $ y $ étant donné $ x $, mais dans une régression à points fractionnaires, un point fractionnaire de 25% ou 95%. Trouvons une droite de régression basée sur le "point de division" utilisé dans, etc.

Quoi qu'il en soit, tout d'abord, je vais dessiner un graphique en utilisant ceci et essayer de le visualiser.

1. Exemple de distribution normale dans laquelle la variance de l'erreur dépend des variables explicatives

Dans ce cas, la variance d'erreur est petite lorsque la variable explicative $ x $ est petite et la variance d'erreur est grande lorsque la variable explicative $ x $ est grande. J'essaye de générer de telles données.

Dans la régression des points de division, un $ \ beta $ différent est défini pour chaque point de division, donc chacun a une pente différente.

** Résultat de l'exécution de la régression des points de division ** À partir du bas, 5%, 10%, 25%, 75%, 90%, 95% de la ligne de régression du point de division et de la droite de régression normale. Quantile_Reg_line-compressor.png

Commencez par générer des données et dessinez un diagramme de dispersion.

#S'il n'est pas installé, installez-le.
#install.packages('quantreg')
library(quantreg)

b <- -5   #Inclinaison en ligne droite
a <- 35   #Section droite

data_x <- runif(500, 0, 5)    # 0-Nombre aléatoire uniforme entre 5
data_y <- rep(0, length(data_x))
for (i in 1:length(data_x)){
    #Section:a,Inclinaison:Un modèle avec une erreur dans la ligne droite de b
    data_y[i] <- b*data_x[i] + a + rnorm(1, mean=0, sd=1+ data_x[i])  #Définir la distribution en fonction de la taille de la variable explicative
}

#Dessinez un diagramme de dispersion
plot(data_x, data_y, xlab="Random Variable", ylab="Random Variable", 
        type = "n", cex=.5, xlim=c(0, 5), ylim=c(0, 40))
points(data_x, data_y, cex=.5, col="blue")

Pour ces données générées, une régression du point de division a été effectuée à 5%, 10%, 25%, 75%, 90% et 95%, respectivement, et une ligne droite a été tracée. Dans le même temps, le résultat de la régression linéaire normale est également dessiné et comparé. Dans cet exemple, une distribution normale est utilisée pour la distribution d'erreur, et comme elle est bilatéralement symétrique, le résultat de la droite de régression du point de division de la valeur centrale et de la régression linéaire normale représentant la valeur moyenne sont presque identiques.

taus <- c(.05, ,.95, .10, .90, .25, .75)    #Définir le point de division
cols <- c(4, 3, 2, 2, 3, 4)                 #Colorez les lignes droites séparément
xx <- seq(min(data_x), max(data_x), .1)
f  <- coef(rq( (data_y) ~ (data_x), tau=taus) )    #Exécution du calcul de régression des points de division
yy <- cbind(1,xx) %*% f

#Dessin de la ligne de régression du point de division
for(i in 1:length(taus)){
    lines(xx, yy[,i], col=cols[i]))
}
abline(lm(data_y ~ data_x), col="red", lty = 2, lw=2)    #Tracez une ligne de régression normale
abline(rq(data_y ~ data_x), col="black", lw=2)           #Médian(median)Tracez une ligne de régression du point de division

legend(0, 8, c("mean (LSE) fit", "median (LAE) fit"), col = c("red","black"),lty = c(2, 1), lw=c(1, 2))

2. Exemple de distribution exponentielle des erreurs

Dans le cas d'une distribution bilatérale symétrique, c'est moins intéressant, alors essayez de générer des données en utilisant une distribution exponentielle avec une longue queue vers la droite et appliquez une régression par point de division.

Ensuite, une ligne droite est tracée à une position plus plausible dans la régression du point de division de la valeur médiane, qui est divisée par la ligne droite noire, que la ligne droite de la méthode du carré minimum représentée par la ligne pointillée rouge. En raison de la distribution de l'ourlet long, les divisions inférieures sont denses et les divisions supérieures sont plus éloignées.

Quantile_Reg_exp-compressor.png

Générez des données avec une distribution exponentielle des erreurs et dessinez un diagramme de dispersion.

#S'il n'est pas installé, installez-le.
#install.packages('quantreg')
library(quantreg)

# b      :Inclinaison en ligne droite
# lambda :Paramètres de distribution exponentielle
# taus   :Liste ex définissant les points de division: c(.05, .95, .10, .90, .25,.75) 
quant_reg_exp <- function(b, lambda, taus){
    Dat   <- NULL
    Dat$x <- rnorm(100, mean=50, sd=7)   #Les variables explicatives sont moyennes:50,écart-type:Généré avec une distribution normale de 7
    Dat$y <- rep(0, 100)

    for (i in 1:length(Dat$x)){
        Dat$y[i] <- b * Dat$x[i] + rexp(1, lambda)    #Générer une erreur selon la distribution exponentielle
    }
    data_x = Dat$x
    data_y = Dat$y
    
    #Dessinez un diagramme de dispersion
    plot(data_x, data_y ,xlab="Random Variable", ylab="Random Variable", type="n", cex=.5) 
    points(data_x, data_y ,cex=.5, col="blue")

    xx <- seq(min(data_x), max(data_x), .1)
    f  <- coef(rq((data_y)~(data_x), tau=taus))     #Exécution du calcul de régression des points de division
    yy <- cbind(1,xx)%*%f

    #Tracez une ligne droite
    cols <- c(2, 2, 3, 3, 4, 4)
    for(i in 1:length(taus)){
        lines(xx, yy[,i], col=cols[i]) 
    }
    abline(lm(data_y ~ data_x), col="red", lty=2)    #Tracez une ligne de régression normale
    abline(rq(data_y ~ data_x), col="black", lw=2)   #Médian(median)Tracez une ligne de régression du point de division
    legend(min(data_x), max(data_y), c("mean (LSE) fit", "median (LAE) fit"), 
                 col=c("red","black"), lty=c(2,1), lw=c(1,2))
}

# param: b, lambda, taus
quant_reg_exp(.5, .5, c(.05, .95, .10, .90, .25,.75))

3. Touchez simplement la chose théorique

C'est juste une touche, mais j'aimerais décrire les points qui sont différents de la méthode du carré minimum. Pour plus de détails, consultez les références ci-dessous.

La ligne bleue ci-dessous est un dessin de la fonction $ 1/2 x ^ 2 $ et représente la fonction qui évalue l'erreur utilisée dans la méthode des moindres carrés.

La ligne rouge trace une fonction de valeur absolue asymétrique selon $ \ tau $, qui est utilisée comme fonction pour évaluer l'erreur de régression du point de division. La fonction d'évaluation des erreurs change en fonction du point de division $ \ tau $.

Les deux sont des fonctions pour évaluer la distance de 0 à partir de 0. Le point principal est de changer la distance dans la direction négative en positive. En rendant cette asymétrie, la régression du point de division essaie de représenter le point de division spécifié $ \ tau $ au lieu de s'appuyer sur le milieu.

err_func_quantile_reg-compressor.gif (Le code de dessin est ici. Ceci est écrit en Python ...)

La ligne de régression du point de division $ \ hat {g_ {\ tau}} $ au point de division $ \ tau $ peut être définie comme suit. Le problème est de trouver $ g (\ cdot) $ qui minimise l'erreur évaluée par la fonction $ \ psi_ {\ tau} (\ cdot) $.

\hat{g_{\tau}} = \arg\min_{g \in \mathcal{G}} \sum_{i=1}^{n} \psi_{\tau} \{ y_i - g(x_i) \} 

À ce stade, dans le cas de la méthode des moindres carrés, la fonction $ \ psi (\ cdot) $ (ligne bleue) est

\psi_{\tau}(r) = {1 \over 2} r^2

Cependant, dans la régression du point de division, la fonction de valeur absolue asymétrique suivante (ligne rouge) est utilisée pour évaluer l'erreur.

\psi_{\tau}(r) = 
\begin{cases}
    (\tau − 1)\ r & {\rm if}\ \ r \le 0\\
    \tau r & {\rm if}\ \ 0 < r
 \end{cases}

Maintenant, en supposant une fonction linéaire pour $ g (\ cdot) $,

g(x_i) = \alpha + \beta x_i

Par conséquent, le problème est de trouver $ \ alpha, \ beta $ qui minimise la valeur de la fonction d'erreur dans l'équation ci-dessus.

Soit le montant estimé de $ y $ $ \ hat {y} = g (x_i) $.

Aussi, laissez la fonction de densité d'erreur et la fonction de densité cumulée être $ f (y), \ F (y) $. L'image ci-dessous est illustrée.

gamma_plot2-compressor.png

gamma_pdf_cdf-compressor.png

La fonction d'erreur $ L () $ est définie ci-dessous.

L(\hat{y}) = E[\psi_{\tau} \{ y_i - \hat{y} \} ] 
= (\tau -1) \int_{-\infty}^{\hat{y}} (y-\hat{y})\ f(y) \ dy 
+ \tau \int^{\infty}_{\hat{y}} (y-\hat{y})\ f(y)\ dy

Si la fonction d'erreur $ L (\ cdot) $ est différenciée par $ \ hat {y} $ et mise à 0,

{\partial L \over \partial \hat{y}} = 
(\tau -1) \int_{-\infty}^{\hat{y}} (-1)\ f(y) \ dy 
+ \tau \int^{\infty}_{\hat{y}} (-1)\ f(y) \ dy       \\
= \int_{-\infty}^{\hat{y}}\ f(y) \ dy - \tau\  \left( \int_{-\infty}^{\hat{y}}\ f(y) \ dy + \int^{\infty}_{\hat{y}}\ f(y) \ dy \right)   \\
= F(\hat{y}) - \tau = 0

Donc,

F(\hat{y}) = \tau 

Est vrai, et $ \ tau $ est égal au point de division $ F (\ hat {y}) $ en $ \ hat {y} $.

4. Références, etc.

[1] ‘quantreg’ manual   https://cran.r-project.org/web/packages/quantreg/quantreg.pdf

[2] Wikipedia "Quantile Regression"   https://en.wikipedia.org/wiki/Quantile_regression

[3] Etude sur l'analyse de régression adaptative des points de division [Hiroyuki Moriguchi]   http://miuse.mie-u.ac.jp/bitstream/10076/10813/1/M2008288.pdf

[4] Université de Kyoto 2013 Note de la conférence sur l'économie micrométrique 8e minute de retour [Ryo Okui]   http://www.okui.kier.kyoto-u.ac.jp/doc/quantile.pdf

[5] Vérification de l'hypothèse du salaire d'efficacité par régression par points de division [Kazutoshi Nakamura]   http://reposit.sun.ac.jp/dspace/bitstream/10561/746/1/v43n4p87_nakamura.pdf

Recommended Posts

[Statistiques] [R] Essayez d'utiliser la régression par points de division.
Essayez d'obtenir des statistiques en utilisant e-Stat
Essayez d'utiliser Tkinter
Essayez d'utiliser docker-py
Essayez d'utiliser Cookiecutter
Essayez d'utiliser PDFMiner
Essayez d'utiliser des géopandas
Essayez d'utiliser Selenium
Essayez d'utiliser scipy
Essayez d'utiliser pandas.DataFrame
Essayez d'utiliser django-swiftbrowser
Essayez d'utiliser matplotlib
Essayez d'utiliser tf.metrics
Essayez d'utiliser PyODE
Essayez d'utiliser une classe orientée objet dans R (méthode R6)
Retour en utilisant le processus gaussien
Essayez d'utiliser virtualenv (virtualenvwrapper)
[Azure] Essayez d'utiliser Azure Functions
Essayez d'utiliser virtualenv maintenant
Essayez d'utiliser W & B
Essayez d'utiliser Django templates.html
[Kaggle] Essayez d'utiliser LGBM
Essayez d'utiliser l'analyseur de flux de Python.
Essayez d'utiliser Tkinter de Python
Essayez la régression avec TensorFlow
Essayez d'utiliser Tweepy [Python2.7]
Essayez d'utiliser collate_fn de Pytorch
Essayez d'implémenter la régression linéaire à l'aide de Pytorch avec Google Colaboratory
Régression de processus gaussien utilisant GPy
Essayez d'utiliser PythonTex avec Texpad.
[Python] Essayez d'utiliser le canevas de Tkinter
Essayez d'utiliser l'image Docker de Jupyter
Essayez d'utiliser scikit-learn (1) - Clustering K par méthode moyenne
Essayez l'optimisation des fonctions à l'aide d'Hyperopt
Essayez d'utiliser matplotlib avec PyCharm
Essayez d'utiliser Azure Logic Apps
Essayez d'utiliser Kubernetes Client -Python-
[Kaggle] Essayez d'utiliser xg boost
Essayez d'utiliser l'API Twitter
Essayez d'utiliser OpenCV sur Windows
Essayez d'utiliser Jupyter Notebook de manière dynamique
Essayez d'utiliser AWS SageMaker Studio
Essayez de tweeter automatiquement en utilisant Selenium.
Essayez d'utiliser SQLAlchemy + MySQL (partie 1)
Essayez d'utiliser l'API Twitter
Essayez d'utiliser SQLAlchemy + MySQL (partie 2)
Essayez d'utiliser la fonction de modèle de Django
Méthode de régression linéaire utilisant Numpy
Essayez d'utiliser l'API PeeringDB 2.0
Essayez d'utiliser la fonction de brouillon de Pelican
Essayez d'utiliser pytest-Overview and Samples-
Essayez d'utiliser le folium avec anaconda