rendu exercice "ping" + stack overflow 29/04

module3/exo3/exercice_fr.Rmd

 ---
-title: "Votre titre"
-author: "Votre nom"
-date: "La date du jour"
-output: html_document
+title: "ping + Stack Overflow sujet 4 module 3 du MOOC RR"
+author: "Bertrand Muller"
+output:
+  pdf_document: default
+  html_document: default
 ---
+Sujet 4 : Estimation de la latence et de la capacité d’une connexion à partir de mesures asymétriques
+
+ 
+Le premier jeu de données examine une connexion courte à l'intérieur d'un campus : http://mescal.imag.fr/membres/arnaud.legrand/teaching/2014/RICM4_EP_ping/liglab2.log.gz
+
+partie 1 "ping" 
+
+Ayant galéré à rendre les données de base dans un format manipulable, j'ai simplifié le jeu de données dans Excel en transformant les données de date en prenant t=0 pour la première mesure, retirant toutes les colonnes inutiles et ne laissant que les deux colonnes utiles et crée un csv avec 3 colonnes : time, size, duration (of the transfer). 
+
+```{r define path}
+data_path = "C:/Users/muller/Desktop/mooc/rr/mooc-rr/module3/liglab2.csv"
+```
+
+Téléchargement
+```{r import data}
+data = read.csv2(data_path, sep=(';'), dec = ",", header = TRUE)
+head(data)
+
+```
+
+exploration des données sur un échantillon de graphes (4) représentant 1% du jeu de données et à peu près lisibles :
+```{r explore data}
+max(data$time)
+interval_size <- 25
+number_plot <- round(max(data$time)/interval_size, digit=0)/100
+for (i in 0:number_plot) {
+plot(data$time, data$size, type="l", xlim = c(interval_size*i*100,interval_size*(i*100+1)))
+}
+
+```
+
+relation entre taille et durée du transfert..
+```{r observe duration vs size}
+plot (data$size, data$duration, type = "p")
+```
+
+
+
+Une rupture apparait un peu en dessous de 1500 octet. On coupe les données en deux.On laisse volontairement un vide entre 1400 et 1500 pour ne pas empiéter sur l'intervalle voisin
+```{r compute regression on subset}
+data_low <- subset(data, data$size<1400)
+data_high <- subset(data, data$size>=1500)
+
+
+reg <- lm(duration ~ size, data = data_low)
+coeff=coefficients(reg)
+# Equation de la droite de regression : 
+eq = paste0("C = ", round(1/coeff[2],1), "  octet/msec  ", "L=", round(coeff[1],2), "  msec")
+# Graph
+plot(data_low$size, data_low$duration, type = "p", main = eq, ylim=c(0,5))
+abline(reg=reg, col="blue")
+
+
+reg <- lm(duration ~ size, data = data_high)
+coeff=coefficients(reg)
+# Equation de la droite de regression : 
+eq = paste0("C = ", round(1/coeff[2],1), "  octet/msec  ", "L=", round(coeff[1],2), "  msec")
+plot(data_high$size, data_high$duration, type = "p", main = eq, ylim=c(0,10))
+abline(reg=reg, col="red")
+
+
+```
+
+On utilise la régression quantile pour donner moins de poids aux outlier. Le principal effet concerne l'abscisse à l'origine (et pas la pente) 
+
+```{r compute regression on 50 quantile}
+
+library(quantreg)
+# regression against 50% quantile in the lower part
+###############
+rqfit <- rq(duration ~ size, data = data_low, tau = 0.5)
+coeff=coefficients(rqfit)
+
+# Equation de la droite de regression quantile : 
+eq = paste0("C = ", round(1/coeff[2],1), "  octet/msec  ", "L=", round(coeff[1],2), "  msec")
+
+plot(duration ~ size, data = data_low, pch = 16, main = eq, ylim=c(1,5))
+abline(rq(duration ~ size, data = data_low), col = "blue", lty = 2, ylim=c(1,5))
+
+#plotting again the regression on the same graph
+reg <- lm(duration ~ size, data = data_low)
+abline(reg, col="red", lty = 1, ylim=c(1,5))
+
+## regression against 50% quantile in the higher part
+###############
+rqfit <- rq(duration ~ size, data = data_high, tau = 0.5)
+coeff=coefficients(rqfit)
+
+# Equation de la droite de regression quantile : 
+eq = paste0("C = ", round(1/coeff[2],1), "  octet/msec  ", "L=", round(coeff[1],2), "  msec")
+
+plot(duration ~ size, data = data_high, pch = 16, main = eq, ylim=c(1,12))
+abline(rq(duration ~ size, data = data_high), col = "blue", lty = 2, ylim=c(1,12))
+
+#plotting again the regression on the same graph
+reg <- lm(duration ~ size, data = data_high)
+abline(reg, col="red", lty = 1, ylim=c(1,12))
+
+
+
+```
+On voit que les vitesses sont très proches dans les deux jeux de données
+
+Par curiosité, on peut  observer les régressions sur les différents quantiles.
+```{r compute mutlple quantile regression}
+
+multi_rqfit <- rq(duration ~ size, data = data_low, tau = seq(0, 1, by = 0.2))
+
+# plotting different quantiles
+colors <- c("red", "red","#ff3333", "#cc0000", "red")
+plot(duration ~ size, data = data_low, pch = 16, main = "duration ~ size", ylim=c(1,2))
+for (j in 1:ncol(multi_rqfit$coefficients)) {
+    abline(coef(multi_rqfit)[, j], col = colors[j])
+}
+
+multi_rqfit <- rq(duration ~ size, data = data_high, tau = seq(0, 1, by = 0.2))
+
+# plotting different quantiles
+colors <- c("red", "red","#ff3333", "#cc0000", "red")
+plot(duration ~ size, data = data_high, pch = 16, main = "duration ~ size", ylim=c(2,3))
+for (j in 1:ncol(multi_rqfit$coefficients)) {
+    abline(coef(multi_rqfit)[, j], col = colors[j])
+}
+```
+
+
+
+Pour finir, on peut s'intéresser à la régression sur les 10% de messages les plus rapides pour une taille données (10ème centile)
+```{r compute 10 quantile regression low}
+library(quantreg)
+# regression against 10% quantile in the lower part
+###############
+rqfit <- rq(duration ~ size, data = data_low, tau = 0.1)
+coeff=coefficients(rqfit)
+
+# Equation de la droite de regression quantile : 
+eq = paste0("C = ", round(1/coeff[2],1), "  octet/msec  ", "L=", round(coeff[1],2), "  msec")
+
+plot(duration ~ size, data = data_low, pch = 16, main = eq, ylim=c(1,2))
+abline(rq(duration ~ size, data = data_low), col = "blue", lty = 2, ylim=c(1,2))
+
+```
+
+Les résultats sont pour la partie basse de la taille (<1400 octet)
+C = `r round(1/coeff[2],1)` octet/msec
+L =  `r round(coeff[1],2)` msec
+
+```{r compute 10 quantile regression high}
+## regression against 10% quantile in the higher part
+###############
+rqfit <- rq(duration ~ size, data = data_high, tau = 0.1)
+coeff=coefficients(rqfit)
+
+# Equation de la droite de regression quantile : 
+eq = paste0("C = ", round(1/coeff[2],1), "  octet/msec  ", "L=", round(coeff[1],2), "  msec")
+
+plot(duration ~ size, data = data_high, pch = 16, main = eq, ylim=c(2,3))
+abline(rq(duration ~ size, data = data_high), col = "blue", lty = 2, ylim=c(2,3))
+
+```
+
+Les résultats sont pour la partie haute de la taille (>1500 octet)
+C = `r round(1/coeff[2],1)` octet/msec
+L =  `r round(coeff[1],2)` msec
+
+######
+######
+
+------------------
+Le deuxième jeu de données mesure la performance d'une connexion vers un site Web éloigné assez populaire et donc chargé : http://mescal.imag.fr/membres/arnaud.legrand/teaching/2014/RICM4_EP_ping/stackoverflow.log.gz
+
+Partie 2 : Stack Overflow
+---
+
+Ayant galéré à rendre les données de base dans un format manipulable, j'ai simplifié le jeu de données dans Excel en transformant les données de date en prenant t=0 pour la première mesure, retirant toutes les colonnes inutiles et ne laissant que les deux colonnes utiles et crée un csv avec 3 colonnes : time, size, duration (of the transfer). 
+
+```{r define path}
+data_path = "C:/Users/muller/Desktop/mooc/rr/mooc-rr/module3/stackoverflow.csv"
+```
+
+Téléchargement
+```{r import data}
+data = read.csv2(data_path, sep=(';'), dec = ",", header = TRUE)
+head(data)
+
+```
+
+exploration des données sur un échantillon de graphes (4) représentant 1% du jeu de données et à peu près lisibles :
+```{r explore data}
+max(data$time)
+interval_size <- 25
+number_plot <- round(max(data$time)/interval_size, digit=0)/20
+for (i in 0:number_plot) {
+plot(data$time, data$size, type="l", xlim = c(interval_size*i*20,interval_size*(i*20+1)))
+}
+
+```
+
+relation entre taille et durée du transfert..
+```{r observe duration vs size}
+plot (data$size, data$duration, type = "p")
+```
+
+
+
+Une rupture apparait un peu en dessous de 1500 octet. On coupe les données en deux.On laisse volontairement un vide entre 1400 et 1500 pour ne pas empiéter sur l'intervalle voisin
+```{r compute regression on subset}
+data_low <- subset(data, data$size<1400)
+data_high <- subset(data, data$size>=1500)
+
+
+reg <- lm(duration ~ size, data = data_low)
+coeff=coefficients(reg)
+# Equation de la droite de regression : 
+eq = paste0("C = ", round(1/coeff[2],1), "  octet/msec  ", "L=", round(coeff[1],2), "  msec")
+# Graph
+plot(data_low$size, data_low$duration, type = "p", main = eq, ylim=c(110,160))
+abline(reg=reg, col="blue")
+
+
+reg <- lm(duration ~ size, data = data_high)
+coeff=coefficients(reg)
+# Equation de la droite de regression : 
+eq = paste0("C = ", round(1/coeff[2],1), "  octet/msec  ", "L=", round(coeff[1],2), "  msec")
+plot(data_high$size, data_high$duration, type = "p", main = eq, ylim=c(110,160))
+abline(reg=reg, col="red")
+
+
+```
+
+On utilise la régression quantile pour donner moins de poids aux outlier. Le principal effet concerne l'abscisse à l'origine (et pas la pente) 
+
+```{r compute regression on 50 quantile}
+
+library(quantreg)
+# regression against 50% quantile in the lower part
+###############
+rqfit <- rq(duration ~ size, data = data_low, tau = 0.5)
+coeff=coefficients(rqfit)
+
+# Equation de la droite de regression quantile : 
+eq = paste0("C = ", round(1/coeff[2],1), "  octet/msec  ", "L=", round(coeff[1],2), "  msec")
+
+plot(duration ~ size, data = data_low, pch = 16, main = eq, ylim=c(110,160))
+abline(rq(duration ~ size, data = data_low), col = "blue", lty = 2, ylim=c(110,160))
+
+#plotting again the regression on the same graph
+reg <- lm(duration ~ size, data = data_low)
+abline(reg, col="red", lty = 1, ylim=c(110,160))
+
+## regression against 50% quantile in the higher part
+###############
+rqfit <- rq(duration ~ size, data = data_high, tau = 0.5)
+coeff=coefficients(rqfit)
+
+# Equation de la droite de regression quantile : 
+eq = paste0("C = ", round(1/coeff[2],1), "  octet/msec  ", "L=", round(coeff[1],2), "  msec")
+
+plot(duration ~ size, data = data_high, pch = 16, main = eq, ylim=c(110,160))
+abline(rq(duration ~ size, data = data_high), col = "blue", lty = 2, ylim=c(110,160))
+
+#plotting again the regression on the same graph
+reg <- lm(duration ~ size, data = data_high)
+abline(reg, col="red", lty = 1, ylim=c(110,160))
+
 
 
-```{r setup, include=FALSE}
-knitr::opts_chunk$set(echo = TRUE)
 ```
+On voit que les vitesses ainsi calculées n'ont pas de sens car le temps dépend très peu de la taille
+
+
+Par curiosité, on peut  observer les régressions sur les différents quantiles.
+```{r compute mutlple quantile regression}
 
-## Quelques explications
+multi_rqfit <- rq(duration ~ size, data = data_low, tau = seq(0, 1, by = 0.2))
 
-Ceci est un document R markdown que vous pouvez aisément exporter au format HTML, PDF, et MS Word. Pour plus de détails sur R Markdown consultez <http://rmarkdown.rstudio.com>.
+# plotting different quantiles
+colors <- c("red", "red","#ff3333", "#cc0000", "red")
+plot(duration ~ size, data = data_low, pch = 16, main = "duration ~ size", ylim=c(110,160))
+for (j in 1:ncol(multi_rqfit$coefficients)) {
+    abline(coef(multi_rqfit)[, j], col = colors[j])
+}
 
-Lorsque vous cliquerez sur le bouton **Knit** ce document sera compilé afin de ré-exécuter le code R et d'inclure les résultats dans un document final. Comme nous vous l'avons montré dans la vidéo, on inclue du code R de la façon suivante:
+multi_rqfit <- rq(duration ~ size, data = data_high, tau = seq(0, 1, by = 0.2))
 
-```{r cars}
-summary(cars)
+# plotting different quantiles
+colors <- c("red", "red","#ff3333", "#cc0000", "red")
+plot(duration ~ size, data = data_high, pch = 16, main = "duration ~ size", ylim=c(110,160))
+for (j in 1:ncol(multi_rqfit$coefficients)) {
+    abline(coef(multi_rqfit)[, j], col = colors[j])
+}
 ```
 
-Et on peut aussi aisément inclure des figures. Par exemple:
 
-```{r pressure, echo=FALSE}
-plot(pressure)
+
+Pour finir, on peut s'intéresser à la régression sur les 10% de messages les plus rapides pour une taille données (10ème centile)
+```{r compute 10 quantile regression low}
+library(quantreg)
+# regression against 10% quantile in the lower part
+###############
+rqfit <- rq(duration ~ size, data = data_low, tau = 0.1)
+coeff=coefficients(rqfit)
+
+#summary(rqfit)
+
+
+# Equation de la droite de regression quantile : 
+eq = paste0("C = ", round(1/coeff[2],1), "  octet/msec  ", "L=", round(coeff[1],2), "  msec")
+
+plot(duration ~ size, data = data_low, pch = 16, main = eq, ylim=c(110,160))
+abline(rq(duration ~ size, data = data_low), col = "blue", lty = 2, ylim=c(110,160))
+
+
+
 ```
 
-Vous remarquerez le paramètre `echo = FALSE` qui indique que le code ne doit pas apparaître dans la version finale du document. Nous vous recommandons dans le cadre de ce MOOC de ne pas utiliser ce paramètre car l'objectif est que vos analyses de données soient parfaitement transparentes pour être reproductibles. 
+Les résultats sont pour la partie basse de la taille (<1400 octet)
+L =  `r round(coeff[1],2)` msec
+et il n'y a aucun lien entre taille et durée
+
+```{r compute 10 quantile regression high}
+## regression against 10% quantile in the higher part
+###############
+rqfit <- rq(duration ~ size, data = data_high, tau = 0.1)
+coeff=coefficients(rqfit)
+
+# Equation de la droite de regression quantile : 
+eq = paste0("C = ", round(1/coeff[2],1), "  octet/msec  ", "L=", round(coeff[1],2), "  msec")
+
+plot(duration ~ size, data = data_high, pch = 16, main = eq, ylim=c(110,160))
+abline(rq(duration ~ size, data = data_high), col = "blue", lty = 2, ylim=c(110,160))
+
+```
 
-Comme les résultats ne sont pas stockés dans les fichiers Rmd, pour faciliter la relecture de vos analyses par d'autres personnes, vous aurez donc intérêt à générer un HTML ou un PDF et à le commiter.
+Les résultats sont pour la partie haute de la taille (>1500 octet)
+L =  `r round(coeff[1],2)` msec
+et il n'y a aucun lien entre taille et durée
 
-Maintenant, à vous de jouer! Vous pouvez effacer toutes ces informations et les remplacer par votre document computationnel.