Discussion :

[Serpentard]

Bonjour,
je souhaite coder cette partie d'un algorithme en R.
Voilà ce que j'ai fait, mais ça ne marche pas. Pouvez-vous m'aider?

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
E_maxWth=80
#Function RandUni
RandUni <- function (S)
{
S= sample(1:E_maxWth, 1, replace=FALSE)
}
print(S)
#{Add initial within edges}
for (v in C)
{
  for (i in 1:E_maxWth)
  {
  E_wth[i] <- RandUni(S)
  print(E_wth)
  }
  for(i in 1:E_wth) 
{
  C<-C[-which(C==v)]
  v_prim <- RandUni(C)
 
  #vec<-c(v,v_prim) # il y a un pb
  #epsilon <- c(epsilon, vec) #il y a un pb
}
print(v_prim)
}

Ps: RandUni(S) est une fonction qui retourne un élément de S sélectionné aléatoirement et uniformément.
C c'est un cluster
v est un entier tiré aléatoirement d'un Sample V

Je vous remercie

[A. D.]

Bonjour,

Je ne suis pas rentrée dans le détail de votre algorithme mais je pense déjà qu'il y a un problème de syntaxe dans l'écriture de votre fonction "RandUni".
En effet, vous passez un élément S en paramètre de la fonction "RandUni", puis au sein de cette fonction vous stockez un résultat dans un élément S, et enfin la fonction ne retourne rien.

Est-ce que quelque chose comme ce qui suit ne correspond pas mieux pour la première partie de votre code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
E_maxWth=80
 
RandUni <- function(E)
{
  S = sample(1:E, 1, replace=FALSE)
  return(S)
}
 
print(RandUni(E=E_maxWth))

En espérant que cela vous aide à y voir plus clair sur la structure d'une fonction en R.
Il faut ensuite reprendre les étapes suivantes unes à unes et voir où cela pose encore des problèmes. N'hésitez pas à poster à la suite les autres problèmes rencontrés, en les détaillant autant que possible ("ça ne marche pas" est un peu trop faible comme indication par exemple... ).


Cordialement,


A.D.

[Serpentard]

Bonjour,

Je vous remercie pour votre réponse.

[Serpentard]

Bonjour, quand j'essaie d'utiliser la fonction que vous m'avez donnée, j'ai cette erreur affichée:
Error in 1:E : NA/NaN argument

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
E_maxWth=80
#Function RandUni
 
RandUni <- function(E)
{
  S = sample(1:E, 1, replace=FALSE)
  return(S)
}
 
print(RandUni(E=E_maxWth))
 
#{Add initial within edges}
 
for (v in C)
{
  for (i in 1:E_maxWth)
  {
  E_wth[i] <- RandUni(E=i)
   }
print(E_wth)
  for(i in 1:length(E_wth)) 
{
 
 v_prim<- RandUni(C[-which(C==v)][i])
 
 
  epsilon <- data.frame(Nodes_V=Node, Nodes_V_prim=v_prim)
}
}

[juliatheric]

Bonjour,
Et si vous montriez le code complet ? Car la valeur contenue dans la variable C manque, ce qui bloque toute tentative de débogage de votre code. Voici tout de même une petite restructuration du code :

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
RandUni <- function(E) {
  S <- sample(1:E, 1, replace = FALSE)
  return(S)
}
 
print(RandUni(80))
 
testRandUni <- function(C, E_maxWth = 80) {
  singleIteration <- function(x) {
    E_wth <- sapply(E_maxWth, RandUni)
 
    print(E_wth)
 
    lapply(seq_along(E_wth), function(y) {
      v_prim <- RandUni(C[-which(C == x)][y])
      data.frame(Nodes_V = Node, Nodes_V_prim = v_prim)
    })
  }
 
  lapply(C, singleIteration)
}
 
# epsilon <- testRandUni(C)

Cela dit, au départ, vous cherchiez à implémenter un algorithme ; vous avez omis d'en donner des détails alors qu'il est d'accès public. Par ailleurs, les auteurs en fournissent une implémentation elle aussi libre d'utilisation. Leur code est écrit en Scala, donc tourne sur la JVM et pourrait être utilisée en R grâce aux paquets qui sont capables de dialoguer avec la JVM. Si vous tenez à ré-implémenter l'algorithme, chose somme toute louable, pourquoi ne pas partir de l'implémentation de référence ? C.-à.-d. étudier le code Scala et le « traduire » en R.

[Serpentard]

Bonjour, je vous remercie pour votre réponse. Voici le code que j'ai essayé de traduire.(J'ai ajouté les instructions que vous avez données)

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
#{Algorithm 1}
#{Vertices and Attributes generation}
N <- 100
V <- sample(1:N, N, replace=FALSE) #V-> an arbitrary set of N Vertices
print(V)
 
#Choisir une valeur au hasard entre 1 et 100
for (i in 1:80)
{
v[i]=sample(1:100, 1, replace=FALSE)
}
Node<-v
 
# Vector of 100 values with a uniform distribution between 0 and 1
V_a=runif(100,0,1) 
print(V_a)
 
# Creation of data frame Nodes-Mass
resultats <- data.frame(Nodes=V, Mass=V_a)
print(resultats)
#-----------------------------------------------------------------------
#{Community Inatialization}
#Algorithm 2
#{Build initial communities}
K=4 
NbRep=8 
V_init <- sample(V, K*NbRep, replace=FALSE)
print(V_init)
#data1 <- resultats[c(1:length(V_init)),] #Sous-dataframe de resultats
 
 
library(cluster)
P <-pam(V_init, K) #Custering des noeuds sans les attributs
#P <-pam(data1, K) #Clustering des noeuds avec les attributs
summary(P)
plot(silhouette(P),  col = 2:5)
 
 
for (C in P)
  MinRep <- min (length(C))
print(MinRep)
#{Resize the communities}
{
  g <- (P$medoids) #Les centroides des clusters
  print(g)
 
  cc <-(P$clustering) #Le vecteur du clustering
  print(cc)
 
 
  #Fnction qui retourne les éléments du cluster  
  cluster<- function(cc,i)
  {
    a<- which(cc==i)
    return (a)
  }
 
 
  for (i in 1:K)
  {
    print(cluster(cc,i))
 
  } 
 
 
  library(fields)
  #Fonction qui retourne la distance entre les éléments des clusters et les
  #centroides
  distance<- function(cc,i,g)
  {
    b<- rdist(which(cc==i),g)
    return (b)
  }
 
  for (i in 1:K)
  {
 
    print(distance(cc,i,g))
  }
 
  #Fonction qui retourne la somme des distances dans chaque cluster  
  sum_distance<- function(cc,i,g)
  {
    d<- sum(rdist(which(cc==i),g))
    return (d)
  }
 
  rslt<- matrix(NA,ncol=1,nrow=K)
 
 
  for (i in 1:K)
  {
    rslt[i,]<- sum_distance(cc,i,g)
  }
  print(rslt)
 
  dd<-which.min(rslt) #retourne l'indice du cluster ayant la somme des 
  #distances minimale
  print(dd)
 
  C <- which(cc==dd) #C contiendra les éléments du cluster ayant la somme
  #des distances minimale
  print(C)
 
RandUni <- function(E) {
  S <- sample(1:E, 1, replace = FALSE)
  return(S)
}
 
print(RandUni(80))
 
testRandUni <- function(C, E_maxWth = 80) {
  singleIteration <- function(x) {
    E_wth <- sapply(E_maxWth, RandUni)
 
    print(E_wth)
 
    lapply(seq_along(E_wth), function(y) {
      v_prim <- RandUni(C[-which(C == x)][y])
      data.frame(Nodes_V = Node, Nodes_V_prim = v_prim)
    })
  }
 
  lapply(C, singleIteration)
}
 
#epsilon <- testRandUni(C)

Merci encore une fois