# Networks with R

In order to practice with network data with R, we have been playing with the Padgett (1994) Florentine’s wedding dataset (discussed in the lecture). The dataset is available from

```> library ( network ) > data(flo) > nflo plot(nflo, displaylabels = TRUE, + boxed.labels = + FALSE)```

The next step was to move from the network package to igraph. Since we have the adjacency matrix, we can use it

```> iflo=graph_from_adjacency_matrix(flo, + mode = "undirected") > plot(iflo)```

The good thing is that a lot of functions are available, for instance we can get shortest paths, between two specific nodes. And we can give appropriate colors to the nodes that we’ll cross

```> AP=all_shortest_paths(iflo, + from="Peruzzi", + to="Ginori") > L=AP\$res[[1]] > V(iflo)\$color="yellow" > V(iflo)\$color[L[2:4]]="light blue" > V(iflo)\$color[L[c(1,5)]]="blue" > plot(iflo)```

We can also visualize edges, but I found it slightly more complicated (to extract edges from the output)

```> liens=c(paste(as.character(L)[1:4], + "--", + as.character(L)[2:5],sep=""), + paste(as.character(L)[2:5], + "--", + as.character(L)[1:4],sep="")) > df=as.data.frame(ends(iflo,E(iflo))) > names(df)=c("src","target") > lstn=sort(unique(c(as.character(df[,1]),as.character(df[,2]),"Pucci"))) > Eliens=paste(as.numeric(factor(df[,1],levels=lstn)),"--", + as.numeric(factor(df[,2],levels=lstn)),sep="") > EU=unlist(lapply(Eliens,function(x) x%in%liens)) > E(iflo)\$color=c("grey","black")[1+EU] > plot(iflo)```

But it works. It is also possible to use some D3js visualization

```> library( networkD3 ) > simpleNetwork (df)```

Then the next question was to add a vertice to the network. The most simple way to do it is probability through the adjacency matrix

```> flo2=flo > flo2["Pucci","Bischeri"]=1 > flo2["Bischeri","Pucci"]=1 > nflo2 plot(nflo2, displaylabels = TRUE, + boxed.labels = + FALSE)```

Then, we’ve been playing with centrality measures.

`> plot(iflo,vertex.size=betweenness(iflo))`

The goal was to see how related they were. Here, for all of them, “Medici” is the central node. But what about the others?

```> B=betweenness(iflo) > C=closeness(iflo) > D=degree(iflo) > E=eigen_centrality(iflo)\$vector > base=data.frame(betw=B,close=C,deg=D,eig=E) > cor(base) betw close deg eig betw 1.0000000 0.5763487 0.8333763 0.6737162 close 0.5763487 1.0000000 0.7572778 0.7989789 deg 0.8333763 0.7572778 1.0000000 0.9404647 eig 0.6737162 0.7989789 0.9404647 1.0000000```

Those measures are quite correlated. It is also possible to use a hierarchical graph to visualize how close those centrality measures can be

```> H=hclust(dist(t(base)), + method="ward") > plot(H)```

Instead of looking at values of centrality measures, it is possible to looks are ranks

```> rbase=base > for(i in 1:4) rbase[,i]=rank(base[,i]) > H=hclust(dist(t(rbase)), + method="ward") > plot(H)```

Here the eigenvector measure is very close to the degree of vertices.

Finally, it is possible to seek clusters (in the context of coalition here, in case a war should start between those families)

`> kc <- fastgreedy.community ( iflo )`

Here we have 3 classes (+1 for the node that is disconnected from the other families)

```> V(iflo)\$color=c("yellow","orange", + "light blue")[membership ( kc )] > plot(iflo)```

`> plot(kc,iflo)`

# Introduction to Graphs and Networks

This week, we will start the first graduate course on graphs and networks. Slides are available online.

Later on, we will see additional applications, in the context of flows, matching, transportation, etc.

# Advanced Econometrics: Quantiles and Expectiles

Next Thursday, I will give the fourth lecture of the PhD course on advanced tools for econometrics, on quantile and expectile regressions. Slides are available online.

On Thursday, March 23rd, I will give the third lecture of the PhD course on advanced tools for econometrics, on model selection and variable selection, where we will focus on ridge and lasso regressions . Slides are available online.

The first part was on on Nonlinearities in Econometric models, and the second one on Simulations.

On Thursday, March 9nd, I will give the second lecture of the PhD course on advanced tools for econometrics, on simulation techniques (and bootstrap). Slides are available online.

The first part is this Thurdays, on Nonlinearities in Econometric models.

On Thursday, March 2nd, I will give the first lecture of the PhD course on advanced tools for econometrics, on nonlinearities. Slides are available online.

# Install R Packages on the Ubuntu Virtual Machine

For the (Advanced) R Crash Course of the Data Science for Actuaries program, we will use the Ubuntu virtual machine. There might be some issues when installing some packages… One trick can be to open a terminal

and then to use the sudo command, to install some packages,

(after entering the password). Just type (or copy/paste)

```sudo apt-get install libcurl4-openssl-dev sudo apt-get install libxml2-dev sudo apt-get install openjdk-8-* update-alternatives --config java sudo apt-get install aptitude sudo aptitude install libgdal-dev sudo aptitude install libproj-dev sudo apt-get install build-essential libcurl4-gnutls-dev libxml2-dev libssl-dev sudo apt-get install curl sudo apt-get build-dep r-cran-rgl sudo apt-get install r-cran-plyr r-cran-xml r-cran-reshape r-cran-reshape2 r-cran-rmysql sudo apt-get install r-cran-rjava sudo apt-get install r-cran-glmnet sudo apt-get build-dep r-cran-boot sudo apt-get build-dep r-cran-class sudo apt-get build-dep r-cran-cluster sudo apt-get build-dep r-cran-codetools sudo apt-get build-dep r-cran-foreign sudo apt-get build-dep r-cran-kernsmooth sudo apt-get build-dep r-cran-lattice sudo apt-get build-dep r-cran-mass sudo apt-get build-dep r-cran-matrix sudo apt-get build-dep r-cran-mgcv sudo apt-get build-dep r-cran-nlme sudo apt-get build-dep r-cran-nnet sudo apt-get build-dep r-cran-rpart sudo apt-get build-dep r-cran-spatial sudo apt-get build-dep r-cran-survival sudo apt-get build-dep r-cran-rodbc sudo apt-get build-dep ```

Then, in RStudio, enter

```install.packages("RCurl") install.packages("xml") install.packages("rJava") install.packages("rgdal") install.packages("xlsx") install.packages("devtools") ```

It should be fine…

# Material for the Course on Inequality

Here is the video that we discussed during the first course,

References for the course are the following,

For similar course lectures notes, see Emmanuel Flachaire’s ECON-473 webpage, as well as Michel Lubrano’s notes.

For the project, some references in French,

and in English

There is also the following report (one can focus only on a chapter of the report)

I will give a short graduate course for PhD students, in Rennes, on Thurday mornings, in March (2nd, 9th, 23rd and 30th). The agenda will be

1. Nonlinear Regression Models and Smoothing Techniques

2. Bootstrapping and Regression

3. Penalized Regression Models and LASSO

4. Quantile Regression and Expectiles

There will be slides available by the end of February.

# Inequality, Welfare and Poverty

The short graduate course on Inequality, Welfare and Poverty will start next week. Slides available are online.

# (Advanced) R Crash Course, for Actuaries

In two weeks, the third year of the Data Science for Actuaries program will start. I will be there for the introduction to R. The slides are available online (created with slidify)

A markdown is also available. I have to thank Ewen for his help on slidify (especially for the online quizz, and the integration of leaflet maps or the rgl animated graph….)

# Examen de Statistique

Qui dit fêtes de fin d’année dit correction de copies… Avant les vacances, il y avait l’examen final du cours de statistique, de Master. L’énoncé est en ligne, ainsi que des éléments de correction.

# De la Statistique Descriptive à la Statistique Mathématique

J’ai l’impression que la principale difficulté pour rentrer dans un cours de stat(istique) math(ématique) est de comprendre de quoi on parle. Que les grandeurs qui étaient évoquées dans le cours de stat(istique) des(criptive) deviennent aléatoires. On peut alors calculer l’espérance d’une moyenne, ou sa variance, ou la variance d’une variance. Dans mon cours, j’ai toujours pris soin de distinguer les minuscules (correspondant aux observations, aux réalisations de variables aléatoires) des majuscules (correspondant aux variables aléatoires sous-jacentes). Il y a quelques mois, Terry Tao suggérait d’aller un cran plus loin, en notant qu’une variable aléatoire était justement aléatoire. Par exemple, si on considère un tirage de Bernoulli, on a l’échantillon suivant

que l’on peut voir comme une réalisation des variables aléatoires suivantes

Pareil, une statistique peut être soit une fonction construit sur notre échantillon,

ou alors être à son tour une variable aléatoire,

Et comme la moyenne est maintenant vue comme une variable aléatoire, on peut regarder sa loi, sa moyenne, sa variance, etc.

Depuis quelques années, je m’efforçais de faire le cours au tableau, mais je me demande si des slides – avec des animations dès qu’on parle de grandeurs aléatoires – n’auraient pas plus de sens…. A suivre donc (on verra ma motivation à la rentrée).

# ENSAE, Devoir 3

Pour le dernier devoir du cours d’actuariat de l’assurance dommage, comme annoncé, je demande de faire un calcul de provisions, sur les données du fichier triangle_ensae.ods.

Je veux un rapport, de 5 pages, proposant un montant de provisions pour les 14 années passées, mais aussi pour la dernière année en cours (pour laquelle 103 733 € ont déjà été payés), avec deux méthodes différentes (montant dit best estimate). Dans un second temps, il faudra utiliser une méthode de simulations pour estimer le quantile à 99.5% des paiements à venir, toutes années confondues. Autrement dit, on veut savoir combien de provisions il convient de constituer pour pouvoir indemniser intégralement les assurés dans 99.5% des cas.

# Cartographier le vote pour le Brexit

Je suis, ces temps-ci plongé dans les projets de R que j’avais donnés pour la formation Data Science pour l’Actuariat. Comme j’ai eu plein de choses intéressantes, je me suis dit que je pourrais tenter de reprendre dans des billets sur le blog (en plus, ça me permet de vérifier au passage que les codes tournent).

Pour commencer la série (oui, il y en aura d’autres), Flavien Thery a proposé une cartographie du vote pour le Brexit. La première étape était de récupérer un fond de carte (on va utiliser la seconde zone administrative ici)

```library(sp) library(raster) download.file("http://biogeo.ucdavis.edu/data/gadm2.8/rds/GBR_adm2.rds","GBR_adm2.rds") UK=readRDS("GBR_adm2.rds") UK@data[159,"HASC_2"]="GB.NR" plot(UK, xlim = c(-4,-2), ylim = c(50, 59), main="UK areas")```

Cette carte est un peu surprenante… parce qu’on est sur le Royaume uni, ce qui inclu l’Angleterre, le Pays de Galles, l’Ecosse et l’Irlande du Nord. Et l’Irlande du Sud n’est pas sur la carte… Autant la rajouter (ça sera plus joli si on met du bleu pour l’eau)

```download.file("http://biogeo.ucdavis.edu/data/gadm2.8/rds/IRL_adm0.rds","IRL_adm0.rds") IRL=readRDS("IRL_adm0.rds") plot(IRL,add=TRUE)```

Mais on commence à rajouter l’Irlande, pourquoi pas la France, qui est juste en bas à droite, et qu’on devrait voir un peu…

```download.file("http://biogeo.ucdavis.edu/data/gadm2.8/rds/FRA_adm0.rds","FRA_adm0.rds") FR=readRDS("FRA_adm0.rds") plot(FR,add=TRUE)```

Bon, arrêtons là….

On peut ensuite récupérer les données du référendum sur le Brexit (que je stocke sur le blog histoire de gagner un peu de temps)

```loc="https://f.hypotheses.org/wp-content/blogs.dir/253/files/2016/12/EU-referendum-result-data.csv" referendum=read.csv(loc,header=TRUE,dec=".",sep=",",stringsAsFactors = FALSE) referendum=referendum[c(3,6,13,14)] library(plyr) referendum=ddply(referendum,.(Region,HASC_code),summarise,Remain=sum(Remain),Leave=sum(Leave))```

On peut retrouver que le Brexit a gagné, avec 51,89% des votes exprimés (ce qui est conforme à ce que dit wikipedia)

```> sum(referendum\$Leave)/(sum(referendum\$Leave)+sum(referendum\$Remain)) [1] 0.5189184```

On peut regarder, région par région, si c’est le leave ou le remain qui a gagné, en utilisant

```referendum=referendum[c(referendum\$Region!="Northern Ireland"),] referendum=referendum[c(referendum\$HASC_code!="Gibraltar"),] row.names(referendum)=seq(1,nrow(referendum),1) leave_or_remain=cbind(referendum,"Brexit?"=0) leave_or_remain[,"Brexit?"]=ifelse(leave_or_remain\$Remain<leave_or_remain\$Leave,rgb(1,0,0,.7),rgb(0,0,1,.7)) map_data=data.frame(UK@data) map_data=cbind(map_data,"Brexit"=0) for (i in 1:nrow(map_data)){ if(map_data[i,"NAME_1"]=="Northern Ireland"){ map_data[i,"Brexit"]="blue"}else{ map_data[i,"Brexit"]=as.character(leave_or_remain[leave_or_remain\$HASC_code==map_data\$HASC_2[i],'Brexit?']) } } plot(UK, col = map_data\$Brexit, border = "gray1", xlim = c(-4,-2), ylim = c(50, 59), main="How the UK has voted?", bg="#A6CAE0") plot(IRL, col = "lightgrey", border = "gray1",add=TRUE) plot(FR, col = "lightgrey", border = "gray1",add=TRUE)```

`legend(-1,59,c("Leave","Remain"),fill=c("red","blue"),bty="n")`

(on rajoute une petite légende pour être plus clair). Mais on peut aller plus loin en représentant le pourcentage obtenu, par région, par le camp du leave. Pour ça, on peut utiliser le package cartography

```library(cartography) cols <- carto.pal(pal1 = "red.pal",n1 = 5,pal2="green.pal",n2=5) map_data=data.frame(UK@data) map_data=cbind(map_data,"Percentage_Remain"=0) for (i in 1:nrow(map_data)){ if(map_data[i,"NAME_1"]=="Northern Ireland"){ map_data[i,"Percentage_Remain"]=55.78}else{         map_data[i,"Percentage_Remain"]=100*leave_or_remain[leave_or_remain\$HASC_code==map_data\$HASC_2[i],"Remain"]/(leave_or_remain[leave_or_remain\$HASC_code==map_data\$HASC_2[i],"Remain"]+leave_or_remain[leave_or_remain\$HASC_code==map_data\$HASC_2[i],"Leave"]) } } plot(UK, col = "grey", border = "gray1", xlim = c(-4,-2), ylim = c(50, 59),bg="#A6CAE0") plot(IRL, col = "lightgrey", border = "gray1",add=TRUE) plot(FR, col = "lightgrey", border = "gray1",add=TRUE) choroLayer(spdf = UK, df = map_data, var = "Percentage_Remain", breaks = seq(0,100,10), col = cols, legend.pos = "topright", legend.title.txt = "", legend.values.rnd = 2, add = TRUE)```

(là encore, une légende permet d’aider à lire la carte). Amusant, n’est ce pas ?