1. #1
    Membre éclairé

    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    septembre 2007
    Messages
    200
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Santé

    Informations forums :
    Inscription : septembre 2007
    Messages : 200
    Points : 714
    Points
    714

    Par défaut Comparaison des performances

    Bonjour à tous,

    Il est clair que R n'est pas très rapide, mais étant donnée notre objectif, il faudrait le montrer de manière un peu plus formelle. Pour cela, je pense qu'il faudrait comparer les performances relatives des différents langages. Un moyen simple serait de programmer le mini pseudo code suivant :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    ### Lecture des données
    A <- read.file("matrix5.csv") 
    
    ### Moyenne de chaque colonne, retourne un vecteur
    meanCol(A) 
    
    ### Ecart type de chaque colonne, retourne un vecteur
    sdCol(A) 
    
    ### Régression linéaire, la première colonne en fonction de toutes les autres
    lm(A[,1]~A[,2]+A[,3]+A[,4]+A[,5]) 
    
    ### Régression linéaire, manuelle (détail dans le post suivant)
    inv( t(B)*B ) * ( t(B)*a )
    Voila pour l'idée générale. En pratique, ce qui nous intéresse est le temps d'exécution. De plus, on va faire REROLL=100 essais a chaque fois. Donc le code est :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    ### Lecture des données
    A <- read.file("matrix5.csv") 
    
    ### REROLL essais pour chaque opération.
    tableauTemps <- matrice vide(4 colonnes et REROLL lignes)
    boucle i variant de 1 à REROLL
       tableauTemps[i,1] <- temps de l'instruction( meanCol(A) )
       tableauTemps[i,2] <- temps de l'instruction( sdCol(A) )
       tableauTemps[i,3] <- temps de l'instruction( lm(A[,1]~A[,2]+A[,3]+A[,4]+A[,5]) )
       tableauTemps[i,4] <- temps de l'instruction( inv( t(B)*B ) * ( t(B)*a ) )
    finBoucle
    Et comme il est possible, pour les petites matrices, que cela soit trop rapide, on ajoute une boucle qui fait faire ITER fois chaque opération :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    ### Lecture des données
    A <- read.file("matrix5.csv") 
    
    ### 100 essais pour chaque opération.
    tableauTemps <- matrice vide (4 colonnes et REROLL lignes)
    boucle i variant de 1 à REROLL
       tableauTemps[i,1] <- temps de l'instruction(for(j variant de 1 à ITER) faire meanCol(A))
       tableauTemps[i,2] <- temps de l'instruction(for(j variant de 1 à ITER) faire sdCol(A))
       tableauTemps[i,3] <- temps de l'instruction(for(j variant de 1 à ITER) faire lm(A[,1]~A[,2]+A[,3]+A[,4]+A[,5]) )
       tableauTemps[i,4] <- temps de l'instruction(for(j variant de 1 à ITER) faire inv( t(B)*B ) * ( t(B)*a ) )
    finBoucle
    
    tableauTemps <- tableauTemps / ITER

    Le but est de faire un code optimisé. Idéalement, il faudrait un exemple pour :
    • R (Christophe)
    • SAS(Laurent Orsy)
    • SPSS
    • STATA (Virginie)
    • R, avec pqr (Mamoun, Christophe)
    • R, avec compiler (Mamoun, Christophe)
    • R, avec parallel (Mamoun, Christophe)
    • C
    • C++
    • Calm
    • Java (Malek)
    • Phyton



    A priori, il vous faut juste écrire le code, le tester sur 3 ou 4 matrices pour être sur qu'il marche, puis le poster ici. Les matrices sont là, soit en format wide (t colonnes, t² lignes), soit long (t² colonnes, t lignes) :


    Dans tous les cas, CA N'EST PAS LA PEINE de faire tous les tests puisque je referais tout moi-même sur ma machine (histoire de faire les comparaisons a machine constante).

    Des volontaires ? Qui fait quoi ?.

    Christophe

  2. #2
    Membre éclairé

    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    septembre 2007
    Messages
    200
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Santé

    Informations forums :
    Inscription : septembre 2007
    Messages : 200
    Points : 714
    Points
    714

    Par défaut

    Quelque précision sur la régression linéaire :

    • Soit A une matrice
    • Soit a la première colonne de A
    • Soit B la matrice A dans laquelle la première colonne est remplacée par des 1
    • soit inv, la fonction inverse de matrice
    • soit t, la fonction transposée de matrice
    • soit *, la multiplication matricielle

    Alors, la régression linéaire de la première colonne de A par toutes les autres colonnes de A est :

    lm(A) = inv( t(B)*B ) * ( t(B)*a )


    Exemple (avec le résultat des calculs pour vérification) :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
             (1 2 5) 
    Soit A = (4 3 6) 
             (7 8 9) 
    
    alors 
    
      (1) 
    a=(4) 
      (7) 
    
        (1 2 5) 
    B = (1 3 6) 
        (1 8 9) 
    
           (1 1 1) 
    t(B) = (2 3 8) 
           (5 6 9) 
    
             ( 3   13   20) 
    t(B)*B = (13   77  100) 
             (20  100  142) 
    
                  (233.5  38.5 -60.0) 
    inv(t(B)*B) = ( 38.5   6.5 -10.0) 
                  (-60.0 -10.0  15.5) 
    
             (12) 
    t(B)*a = (78) 
             (90) 
    
                           (-23) 
    inv(t(B)*B)*(t(B)*a) = ( -3) 
                           (  6)
    Donc le résultat de la fonction lm(A) doit être (-23,-3,6)

  3. #3
    Membre éclairé

    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    septembre 2007
    Messages
    200
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Santé

    Informations forums :
    Inscription : septembre 2007
    Messages : 200
    Points : 714
    Points
    714

    Par défaut

    Pour R, voila le résultat :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    test <- function(A,reroll,iter){
        tabTemps <- matrix(NA,reroll,4)
        colnames(tabTemps) <- c("colMeans","sdMean","lm")
    
        a = A[,1]
        B = A
        B[,1] = 1
    
        for(j in 1:reroll){
           tabTemps[j,1] <- system.time(for(i in 1:iter)apply(A,1,mean))["elapsed"]
           tabTemps[j,2] <- system.time(for(i in 1:iter)apply(A,1,sd))["elapsed"]
           tabTemps[j,3] <- system.time(for(i in 1:iter)lm(A[,1]~A[,-1]))["elapsed"]
           tabTemps[j,4] <- system.time(for(i in 1:iter)solve(t(B)%*%B)%*%(t(B)%*%a))["elapsed"]
        }
        return(tabTemps/iter)
    }
    
    ### Pour matrix0
    A0 <- as.matrix(read.csv2("matrix0.csv"))
    temps0 <- test(A0,nbReroll=1000,nbIter=1000)
    
    ### Pour matrix2
    A2 <- as.matrix(read.csv2("matrix2.csv"))
    temps2 <- test(A2,nbReroll=1000,nbIter=1000)
    
    ### Pour matrix3
    A3 <- as.matrix(read.csv2("matrix3.csv"))
    temps3 <- test(A3,nbReroll=1000,nbIter=1000)
    
    ...

  4. #4
    Inactif
    Profil pro
    Inscrit en
    août 2013
    Messages
    29
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : août 2013
    Messages : 29
    Points : 38
    Points
    38

    Par défaut

    Salut

    Ton code me semble problématique. Pour moi, un for en R est très coûteux en termes de temps. Donc lorsque tu écris :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    for(i in 1:iter)apply(A,1,mean)
    J'imagine qu'une grande partie du temps sera "dépensé" par le for et non apply. Donc le calcul sera faussé, ce n'est pas une mesure moyenne de apply mais de for+apply
    Idem pour les autres

    Il n'y a pas de fonctions de benchmark en R ? Si ce n'est pas le cas, il faut en créer une directement en bas niveau dans un module C

  5. #5
    Membre éclairé

    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    septembre 2007
    Messages
    200
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Santé

    Informations forums :
    Inscription : septembre 2007
    Messages : 200
    Points : 714
    Points
    714

    Par défaut

    Bonjour cher visiteur !

    C'est une bonne remarque. Ceci étant dit, dans R, certaines boucles sont pénalisantes mais pas toutes (j'avais appris ça sur le GuR, le "Groupe des Utilisateurs de R"). Ici, si je remplace le for par un sapply ou un lapply, j'obtiens la même chose :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    > system.time(for(i in 1:10000)apply(A,1,mean))["elapsed"]
    elapsed 
       0.76 
    > system.time(sapply(1:10000,function(x)apply(A,1,mean)))["elapsed"]
    elapsed 
       0.77 
    > system.time(lapply(1:10000,function(x)apply(A,1,mean)))["elapsed"]
    elapsed 
       0.78 
    > f <- function(x)apply(A,1,mean)
    > system.time(sapply(1:10000,f))["elapsed"]
    elapsed 
       0.78
    Qu'entends tu par "fonction de benchmark" ?

    Christophe

  6. #6
    Inactif
    Profil pro
    Inscrit en
    août 2013
    Messages
    29
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : août 2013
    Messages : 29
    Points : 38
    Points
    38

    Par défaut

    Pour ça que je disais "semble", sans benchmark sur le benchmark (), difficile de dire quelle est l'importance du coût du for.
    Mais comme on voit souvent des benchmarks faussés parce que les évaluations posent problèmes, je suis très méfiant.

    Pour fonctions de benchmark dans R, je pensais à des choses comme http://cran.r-project.org/web/packag...ark/index.html ou http://cran.r-project.org/web/packag...ark/index.html

  7. #7
    Membre habitué
    Homme Profil pro
    Étudiant
    Inscrit en
    juillet 2013
    Messages
    75
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Santé

    Informations forums :
    Inscription : juillet 2013
    Messages : 75
    Points : 191
    Points
    191

    Par défaut Résultats avec la fonction mcapply , package parallel

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    require(parallel)
    require(MASS)
    RNGkind("L'Ecuyer-CMRG")
    data <- read.csv('~/Projet-comparaison-pakage-calclul-parallel/R/matrix69.csv')
    REROLL <- 1000
    time <- matrix(REROLL, ncol = 1)
    system.time(for(i in 1:REROLL) colMeans(data))  # 8.147 
    utilisateur     système      écoulé 
          7.872       0.316       8.209 
    system.time(lapply(1:REROLL, function(x) colMeans(data))) #  8.196
    utilisateur     système      écoulé 
          7.956       0.308       8.284 
    system.time( mclapply(1:REROLL, function(x) colMeans(data), mc.cores = 2))
    utilisateur     système      écoulé 
          7.108       0.296       4.874 
    mc.cores <- detectCores() # 8
    system.time( mclapply(1:REROLL, function(x) colMeans(data), mc.cores = mc.cores))
    utilisateur     système      écoulé 
         22.028       1.172       3.232
    Le gain de temps est significatif, mais n'est pas à la hauteur de nos espérances.
    Si le temps écoulé est divisé par 2 avec 2 cœurs, ce n'est pas le cas avec 8.

    De plus toutes les fonctions ne sont visiblement pas parallélisables.
    Par exemple la fonction 'sqrt' est plus rapide en utilisant un simple 'appply'.

    A noter que cette fonction n'est utilisable que sur les systèmes POSIX.

  8. #8
    Membre habitué
    Homme Profil pro
    Étudiant
    Inscrit en
    juillet 2013
    Messages
    75
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Santé

    Informations forums :
    Inscription : juillet 2013
    Messages : 75
    Points : 191
    Points
    191

    Par défaut Test des fonctions 'cmpfun' et 'compile' du package compiler

    Le package R compiler doit compiler le code écrit en R pour le rendre plus rapide à l'exécution.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    require(compiler) # permet de compiler le code R
    data <- read.csv('./matrix69.csv')
    REROLL <- 10
    iter <- 100
    mat <- matrix(0, nrow = REROLL, ncol = 1)
    fc <- function(data, REROLL, iter,  mat) {
      for (i in 1:REROLL) {
        mat[i,1] <- system.time(for(j in 1:iter) { colMeans(data) })['elapsed']
      }
      return(mat)
    }
    fc.cmp <- cmpfun(fc) # compile le code R
    fc.compile <- eval(compile(fc)) # compile le code R
     require(rbenchmark) # affiche les 
     benchmark(fc(data = data, REROLL = REROLL, iter = iter, mat = mat),
              fc.cmp(data = data, REROLL = REROLL, iter = iter, mat = mat),
               fc.compile(data = data, REROLL = REROLL, iter = iter, mat = mat),
               columns=c("test", "replications",
               "elapsed", "relative"),
               order="relative", replications = 1)
    
    3 fc.compile(data = data, REROLL = REROLL, iter = iter, mat = mat)            1
    2     fc.cmp(data = data, REROLL = REROLL, iter = iter, mat = mat)            1
    1         fc(data = data, REROLL = REROLL, iter = iter, mat = mat)            1
      elapsed relative
    3   7.428    1.000
    2   7.458    1.004
    1   7.641    1.029
    Les fonctions compilées sont légèrement plus rapides, mais le gain n'est vraiment pas significatif, la fonction de base est 3% de temps plus longue.

  9. #9
    Membre habitué
    Homme Profil pro
    Étudiant
    Inscrit en
    juillet 2013
    Messages
    75
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Santé

    Informations forums :
    Inscription : juillet 2013
    Messages : 75
    Points : 191
    Points
    191

    Par défaut Test de pqR (pretty quick R) avec le même exemple.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    benchmark(fc(data = data, REROLL = REROLL, iter = iter, mat = mat),
              fc.cmp(data = data, REROLL = REROLL, iter = iter, mat = mat),
               fc.compile(data = data, REROLL = REROLL, iter = iter, mat = mat),
               columns=c("test", "replications",
               "elapsed", "relative"),
               order="relative", replications = 1)
      elapsed relative
    3   4.420    1.000
    1   4.715    1.067
    2   4.735    1.071
    C'est presque 2 fois plus rapide qu'avec la version 3.0.1 de R.

  10. #10
    Candidat au Club
    Profil pro
    Inscrit en
    octobre 2013
    Messages
    1
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : octobre 2013
    Messages : 1
    Points : 4
    Points
    4

    Par défaut temps sous Stata

    Voilà ci-dessous les 2 fonctions créées pour Stata, à enregistrer au format ".ado"
    a) temps_execution_sans_affichage : réalise les calculs stats et affiche les temps d’exécution pour REROLL opérations. Mais ça n’affiche pas les valeurs
    des moyennes, écarts-types ni les résultats des modèles de régression
    b) temps_execution_avec_affichage : pareil sauf qu’en plus ça
    affiche les résultats de toutes les stats demandées.


    COMMENT UTILISER LES FONCTIONS CREEES :
    1. Enregistrer les 2 fonctions dans un fichier à leur nom
    2. dans stata :
    adopath + "chemin_d’accès_où_tu_as_rangé_les_fonctions"
    3. Pour lancer les fonctions, voici des exemples:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    temps_execution_sans_affichage , reroll(100) iter(1000)  /// chemin("F:\Documents\") donnees("matrix3.csv") 
    
    temps_execution_avec_affichage , reroll(100) iter(25) /// chemin("F:\Documents\") donnees("matrix10.csv")
    ///////////////////////////////////////////

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    capture program drop temps_execution_sans_affichage
    
    program define temps_execution_sans_affichage
    	version 11
    
    ***** Syntaxe de la commande	
    	/* Paramètres d'entrée
    		chemin=chemin d'accès aux données 
    		donnees=base de données
    		ITER nombre de fois pour chaque opération
    		REROLL nombre d'essais de l'ensemble des opérations
    	*/	
    	syntax  [, reroll(real 1) iter(real 1) chemin(string) donnees(string)]
    
    di _n _n _n "La fonction temps_execution_sans_affichage calcule les temps d'éxécution mais n'affiche pas les résultats des calculs statistiques." _n _n _n
    
    ***** Ouverture de la base de données
    	set more off
    	clear 
    	clear matrix
    	clear mata
    	cd "`chemin'"
    	insheet using "`donnees'"
    
    ***** Création matrice vide qui contiendra les temps estimés
    	matrix tableauTemps = J(`reroll',4,.)
    	gen cons = 1 /* variable qui sera utilisée pour la régression linéaire à la main */
    
    ***** Opération et temps d'éxécution
    	forvalues  num_reroll=1/`reroll' {
    		* 1. Calcul moyennes des variables
    			timer clear 1
    			timer on 1 /* Début du timer */
    			forvalues num_iter=1/`iter' {
    				quietly tabstat v* , stats(mean)
    			}
    			* Enregistrement du temps d'éxécution
    			timer off 1
    			quietly timer list 1
    			matrix tableauTemps[`num_reroll', 1] = r(t1)
    		* 2. Calcul écarts-types des variables
    			timer clear 1
    			timer on 1/* Début du timer */
    			forvalues num_iter=1/`iter' {
    				quietly tabstat v* , stats(sd)
    			}
    			* Enregistrement du temps d'éxécution
    			timer off 1
    			quietly timer list 1
    			matrix tableauTemps[`num_reroll', 2] = r(t1)
    		* 3. Régression linéaire avec v1 comme variable à expliquer et toutes les autres comm variables explicatives
    			timer clear 1
    			timer on 1 /* Début du timer */
    			forvalues num_iter=1/`iter' {
    				quietly regress v*  
    			}
    			* Enregistrement du temps d'éxécution
    			timer off 1
    			quietly timer list 1
    			matrix tableauTemps[`num_reroll', 3] = r(t1)
    		* 4. Régression linéaire sous forme de matrices
    			timer clear 1
    			timer on 1 /* Début du timer */
    			forvalues num_iter=1/`iter' {
    				mkmat v2 -  cons, mat(X)
    				mkmat v1, mat(a)
    				matrix b = syminv(X'*X)*X'*a
    				*matrix list b
    			}
    			* Enregistrement du temps d'éxécution
    			timer off 1
    			quietly timer list 1
    			matrix tableauTemps[`num_reroll', 4] = r(t1)
    	}
    	
    ***** Affichage des temps estimés
    	di "Temps d'éxécution calculés : " _n _n
    	matlist tableauTemps
    	di _n "c1 = opération -moyenne- ; c2 = opération -sd- ; c3 = opération -rég linéaire- ; c4 = opération -rég lin manuelle-"
    
    end
    
    //////////////////////////////////////////
    capture program drop temps_execution_avec_affichage
    
    program define temps_execution_avec_affichage
    	version 11
    
    ***** Syntaxe de la commande	
    	/* Paramètres d'entrée
    		chemin=chemin d'accès aux données 
    		donnees=base de données
    		ITER nombre de fois pour chaque opération
    		REROLL nombre d'essais de l'ensemble des opérations
    	*/	
    	syntax  [, reroll(real 1) iter(real 1) chemin(string) donnees(string)]
    
    di _n _n _n "temps_execution_sans_affichage calcule les temps d'éxécution et affiche les résultats des calculs statistiques." _n _n 
    
    ***** Ouverture de la base de données
    	set more off
    	clear 
    	clear matrix
    	clear mata
    	cd "`chemin'"
    	insheet using "`donnees'"
    
    ***** Création matrice vide qui contiendra les temps estimés
    	matrix tableauTemps = J(`reroll',4,.)
    	gen cons = 1 /* variable qui sera utilisée pour la régression linéaire à la main */
    
    ***** Opération et temps d'éxécution
    	forvalues  num_reroll=1/`reroll' {
    		* 1. Calcul moyennes des variables
    			timer clear 1
    			timer on 1 /* Début du timer */
    			forvalues num_iter=1/`iter' {
    				tabstat v* , stats(mean)
    			}
    			* Enregistrement du temps d'éxécution
    			timer off 1
    			quietly timer list 1
    			matrix tableauTemps[`num_reroll', 1] = r(t1)
    		* 2. Calcul écarts-types des variables
    			timer clear 1
    			timer on 1/* Début du timer */
    			forvalues num_iter=1/`iter' {
    				tabstat v* , stats(sd)
    			}
    			* Enregistrement du temps d'éxécution
    			timer off 1
    			quietly timer list 1
    			matrix tableauTemps[`num_reroll', 2] = r(t1)
    		* 3. Régression linéaire avec v1 comme variable à expliquer et toutes les autres comm variables explicatives
    			timer clear 1
    			timer on 1 /* Début du timer */
    			forvalues num_iter=1/`iter' {
    				regress v*  
    			}
    			* Enregistrement du temps d'éxécution
    			timer off 1
    			quietly timer list 1
    			matrix tableauTemps[`num_reroll', 3] = r(t1)
    		* 4. Régression linéaire sous forme de matrices
    			timer clear 1
    			timer on 1 /* Début du timer */
    			forvalues num_iter=1/`iter' {
    				mkmat v2 -  cons, mat(X)
    				mkmat v1, mat(a)
    				matrix b = syminv(X'*X)*X'*a
    				matrix list b
    			}
    			* Enregistrement du temps d'éxécution
    			timer off 1
    			quietly timer list 1
    			matrix tableauTemps[`num_reroll', 4] = r(t1)
    	}
    	
    ***** Affichage des temps estimés
    	di "Temps d'éxécution calculés : " _n _n
    	matlist tableauTemps
    	di _n "c1 = opération -moyenne- ; c2 = opération -sd- ; c3 = opération -rég linéaire- ; c4 = opération -rég lin manuelle-"
    
    end
    
    /////////////////////////////////////////

  11. #11
    Membre habitué
    Homme Profil pro
    Étudiant
    Inscrit en
    juillet 2013
    Messages
    75
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Santé

    Informations forums :
    Inscription : juillet 2013
    Messages : 75
    Points : 191
    Points
    191

    Par défaut

    Voici un lien vers le site du langage Julia http://julialang.org/

    Il y a un récapitulatif des performances entre différents langages.

  12. #12
    Futur Membre du Club
    Homme Profil pro
    Inscrit en
    novembre 2013
    Messages
    2
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Etats-Unis

    Informations forums :
    Inscription : novembre 2013
    Messages : 2
    Points : 8
    Points
    8

    Par défaut

    Citation Envoyé par mamounMob Voir le message
    Voici un lien vers le site du langage Julia http://julialang.org/

    Il y a un récapitulatif des performances entre différents langages.
    A mon avis Julia a les objectifs les plus proches de ceux de R++, du genre strong typing, haute performance. Je ne sais pas beaucoup de Julia, mais j'ai l'impression que c'est parfait, sauf que c'est pas compatible avec R et qu'il n'y a pas encore beaucoup de packages. C'est là ou je vois une opportunité pour R++.

Discussions similaires

  1. Comparaison des performances D2010..XE6
    Par SergioMaster dans le forum EDI
    Réponses: 0
    Dernier message: 01/11/2014, 07h55
  2. Comparaison des performances des algorithmes de tri
    Par biba13 dans le forum Pascal
    Réponses: 2
    Dernier message: 09/05/2007, 21h28
  3. Réponses: 8
    Dernier message: 21/11/2005, 07h59
  4. Audit des performances d'une application Web
    Par jpg dans le forum Développement Web en Java
    Réponses: 3
    Dernier message: 16/09/2004, 11h45

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo