définir le nœud de départ pour la propagation d'un virus dans un réseau

Question

Je travaille sur la recherche de nœuds influents dans des réseaux complexes en utilisant la programmation R. Je veux utiliser la centralité des degrés, ce qui signifie le nombre de voisins d'un nœud dans un graphique. J'ai un graphique et le degré de centralité de chaque nœud. Maintenant, je veux savoir combien de nœuds seront infectés dans un délai précis lorsque nous commencerons à propager le virus de chaque nœud. selon mes études je devrais utiliser le modèle épidémique SIR (sensible, infecté, récupéré) que j'ai trouvé dans le paquet "igraph", le problème est que je ne peux pas spécifier le noeud de départ. Il semble que cette fonction fonctionne sur la base des équations SIR:

s'= -(beta)SI 
I' = (beta)SI - (gamma)I 
R' = (gamma)I 

où bêta est le paramètre d'infection et gamma est le paramètre de récupération. est ici le code igraph SIR:

function (graph, beta, gamma, no.sim = 100) 
{ 
if (!is_igraph(graph)) { 
    stop("Not a graph object") 
} 
beta <- as.numeric(beta) 
gamma <- as.numeric(gamma) 
no.sim <- as.integer(no.sim) 
on.exit(.Call("R_igraph_finalizer", PACKAGE = "igraph")) 
res <- .Call("R_igraph_sir", graph, beta, gamma, no.sim, 
    PACKAGE = "igraph") 
class(res) <- "sir" 
res 
} 

Il semble que la plupart des travaux sont effectués dans « R_igraph_sir » mais je ne peux pas trouver une telle fonction dans ce paquet. Y a-t-il un moyen de définir le noeud de départ?

Answer 1

Il semble que vous aimeriez avoir un modèle SIR où vous êtes en mesure de définir le noeud initialement infecté en monkeypatching le code R existant. Puisque le paquet R est compilé à partir du code C, cela peut être difficile selon votre expérience de programmation et en général monkeypatching n'est pas recommandé, sinon parce que vous perdrez votre code dès que vous mettez à jour votre paquet igraph. Au lieu de cela vous pouvez relativement facilement implémenter cela vous-même en utilisant le paquet igraph. Ci-dessous est une implémentation non testé en python qui doit être easibly porté à R.

La première étape infecte un noeud du graphe adjacent à un noeud infecté avec une probabilité de beta

Après l'étape d'infection tout noeud infecté peut être supprimé du graphique avec une probabilité de gamma

Après le nombre de timesteps donné, vous trouvez le nombre de nœuds affectés en tant que taille du tableau infected_nodes. Cela ne compte pas les nœuds supprimés, donc si vous voulez que le nombre total de infecté sur toute la simulation que vous mettez dans un compteur qui incrémente chaque fois que vous contaminez un nœud

infected_nodes = [] 
# Set the infection rate 
beta = 0.1 
# Set the removal rate 
gamma = 0.1 
# Set how many timesteps you want to pass through 
n_timesteps = 100 
# Start from the node you have chosen using edge centrality 
infected_nodes.append(chosen_node) 
for _ in n_timesteps: 
    # Infection stage 
    for node in infected_nodes: 
     for neighbor in igraph.neighborhood(graph, node): 
      # random.random simply returns a number between [0,1) 
      if random.random() < beta: 
       infected_nodes.append(neighbor) 
    # Removal stage 
    infected_survivors = [] 
    for node in infected_nodes: 
     if random.random() < gamma: 
      graph = igraph.delete_vertices(graph, node) 
     else: 
      infected_survivors.append(node) 
    infected_nodes = infected_survivors 

Quelques aberdabeis:

• Cela suppose que chaque nœud visite tous ses voisins à chaque étape. Si vous voulez que chaque nœud soit capable d'infecter n voisins par tour, vous devrez prendre un échantillon aléatoire de n de la taille des voisins au lieu de parcourir tous les nœuds.
• Lors de l'étape de suppression, il est possible de supprimer les noeuds nouvellement infectés, ce qui signifie qu'il est possible qu'un noeud n'ait pas l'opportunité d'infecter ses voisins. Si ce n'est pas réaliste dans votre cas, vous devrez stocker les noeuds nouvellement infectés dans un tableau séparé et les ajouter aux noeuds infectés au début de l'infection
• Ceci sera évidemment plus lent que l'implémentation C fournie par le paquet R