Truth-seeking network of agents learning from nature and learning from others : whenTopology trumps ability

Truth-seeking network of agents learning from nature and learning from others : whenTopology trumps ability preview image

1 collaborator

Default-person Henri Galinon (Author)

Tags

(This model has yet to be categorized with any tags)
Visible to everyone | Changeable by everyone
Model was written in NetLogo 6.3.0 • Viewed 59 times • Downloaded 8 times • Run 0 times
Download the 'Truth-seeking network of agents learning from nature and learning from others : whenTopology trumps ability' modelDownload this modelEmbed this model

Do you have questions or comments about this model? Ask them here! (You'll first need to log in.)


Comments and Questions

Please start the discussion about this model! (You'll first need to log in.)

Click to Run Model

extensions [matrix]


turtles-own [
  liste_croyance            ;liste des croyances au cours du temps
  liste_performence         ;liste des performences au cours du temps
  liste_ind_nature          ;liste des indices naturels  au cours du temps représentant la qualité d'énquête
                            ;cette liste suit une gaussienne de moyenne parametre_a_estimer
  liste_estime_direct       ;propre fondement sur l'estimation du paramètre

  liste_conf_epist          ;liste des confiances épistémiques que possèdent un agent envers les autres agents

  expert                    ;renseigne si l'agent est expert ou non 1=expert 0=layman
  x-pos                     ;position x de l'agent
  y-pos                     ;position y de l'agent

  indegree                  ; la somme des poids de liens de confiance pointant vers l'agent
  nb_out_neighboors         ; le nombre de voisins auprès desquels l'agent recueille de l'info
  couple                     ; le couple (dernière perf , nb_out_neighboors)
]

globals [
  list_perf_glob            ;liste des performences globales au cours du temps
  list_perf_expert          ;liste des performences globales des experts au cours du temps
  list_perf_lay             ;liste des performences globales des laymans au cours du temps
  matrice                   ; la matrice du graphe de confiance sour forme de liste des ligne de la matrice
  matrix                    ; la matrice du graphe de confiance sous forme d'objet 'matrix' (extension spéciale)
  coeff_matrix                       ; une valeur pour montrer comment récupérer une cellul
]

to setup
  clear-all
  if ecart_type_expert >= ecart_type_laymen
  [
    clear-output
    output-write "problème d'initialisation des paramètres d'écart-type"
    stop
  ]

  if (number_of_agents < 2) or (number_of_agents > 1000)
  [
    clear-output
    output-write "Le nombre d'agents doit être compris entre 2 et 1000"
    stop
  ]

  random-seed seed-random
  create_turtles
  init
  init_conf_epist
  add_arrow
  set-up-matrice

  reset-ticks
end 




;création des agents

to create_turtles
  let nb_expert ( (round ( proportion_expert * number_of_agents) ) - 1 )
  let nb_tortue number_of_agents

  create-turtles 1
  [
    set x-pos 0 set y-pos 0
    ifelse agent1_expert
    [ set expert true
      set nb_tortue (nb_tortue - 1 )
      set nb_expert (nb_expert - 1 ) ]
    [ set expert false
      set nb_tortue (nb_tortue - 1 ) ]
    ifelse expert
    [ set color blue ]
    [ set color red ]
    set shape "circle"
  ]

  let nb (number_of_agents - 1)
  let radius 20
  let start_radian 0
  let increment_angle (360 / nb)
  let increment_radian (increment_angle * pi)

  while [nb != 0]
  [
    let x (sin(start_radian) * radius)
    let y (cos(start_radian) * radius)
   create-turtles 1
   [
      set x-pos x set y-pos y
      setxy x-pos y-pos
      ifelse random nb_tortue > nb_expert
      [ set expert false
        set nb_tortue (nb_tortue - 1 ) ]
      [ set expert true
        set nb_tortue (nb_tortue - 1 )
        set nb_expert (nb_expert - 1 ) ]
      ifelse expert
      [ set color blue ]
      [ set color red ]
      set shape "circle"
   ]
   set start_radian (start_radian + increment_radian)
   set nb (nb - 1)
  ]
end 



;initialisation des listes des agents

to init
  ask turtles
  [
    set liste_croyance []
    set liste_performence []
    set liste_ind_nature []
    set liste_estime_direct []
    set liste_conf_epist []
    set indegree 0

    set liste_croyance lput (random 100 / 100) liste_croyance
    set liste_ind_nature lput (random 100 / 100) liste_ind_nature
  ]

  set list_perf_glob []
  set list_perf_expert []
  set list_perf_lay []
end 



;initialisation des confiances entre les agents

to init_conf_epist
  let i 0
  let j 0
  if modeles_relations = "master"
  [
    foreach sort turtles
    [
        set j 0
        foreach sort turtles
        [
            ifelse i = j
            [
              ifelse i = 0
              [ask turtle i [ set liste_conf_epist lput 0 liste_conf_epist] ]
              [ask turtle i [ set liste_conf_epist lput (1 / 2) liste_conf_epist] ]
            ]
            [
              ifelse i = 0
              [ask turtle i [ set liste_conf_epist lput (1 / (number_of_agents - 1) ) liste_conf_epist] ]
              [
                ifelse j = 0
                [ask turtle i [ set liste_conf_epist lput (1 / 2) liste_conf_epist] ]
                [ask turtle i [ set liste_conf_epist lput 0 liste_conf_epist] ]
              ]
            ]
            set j (j + 1)
         ]
        set i (i + 1)

    ]
  ]
  if modeles_relations = "circle"
  [
    foreach sort turtles
    [
        set j 0
        foreach sort turtles
        [
            ifelse (i = j) or (abs (i - j) = 1 ) or (abs (i - j) = ( number_of_agents - 1 ) )
            [ask turtle i [ set liste_conf_epist lput ( 1 / 3 ) liste_conf_epist] ]
            [ask turtle i [ set liste_conf_epist lput 0 liste_conf_epist] ]
            set j (j + 1)
        ]
        set i (i + 1)
    ]
  ]
  if modeles_relations = "observer"
  [
    foreach sort turtles
    [
        set j 0
        foreach sort turtles
        [
            ifelse i = j
            [
              ifelse i = 0
              [ask turtle i [ set liste_conf_epist lput 0 liste_conf_epist] ]
              [ask turtle i [ set liste_conf_epist lput 1 liste_conf_epist] ]
            ]
            [
              ifelse i = 0
              [ask turtle i [ set liste_conf_epist lput (1 / (number_of_agents - 1)) liste_conf_epist] ]
              [ask turtle i [ set liste_conf_epist lput 0 liste_conf_epist] ]
            ]
            set j (j + 1)
        ]
        set i (i + 1)
    ]
  ]
  if modeles_relations = "random"
  [
    foreach sort turtles
    [
        let som 0
        set j 0
        foreach sort turtles
        [
          ifelse (random 100 / 100) < random_link_probability
          [
            let rand_number (random 100 / 100)
            ask turtle i [ set liste_conf_epist lput rand_number liste_conf_epist]
            set som (som + rand_number)
          ]
          [
            ask turtle i [ set liste_conf_epist lput 0 liste_conf_epist]
          ]
          set j (j + 1)
        ]
        let k 0
        ask turtle i
        [
          foreach liste_conf_epist
          [ [??1] ->
            ifelse som > 0
            [
              set liste_conf_epist (replace-item k liste_conf_epist (??1 / som))
            ]
            [
              set liste_conf_epist (replace-item i liste_conf_epist 1)
            ]
            set k (k + 1)

          ]
        ]
        set i (i + 1)
    ]
  ]
end 

;pour la matrice de confiance et les les données topologiques des tortues

to set-up-matrice

set matrice []
  let i 0
  foreach sort turtles
  [ [?1] ->
    ask ?1 [set matrice lput liste_conf_epist matrice]
  ]

set matrix matrix:from-row-list matrice

let j 0                                    ;ici la boucle pour fixer le indegree = la somme des poids des liens de confiance pointant sur chaque tortue
  while [j != number_of_agents]
  [let temp matrix:get-column matrix j
    ask turtle j [set indegree sum temp ]

  set j (j + 1)
  ]

  let k 0                                    ;ici la boucle pour fixer le nb_out_neighboors = le nombre d'agents directement accessibles à une totrtue donnée
  while [k != number_of_agents]
  [let l 0
    let temp2 0
    while [l != number_of_agents]
   [ ask turtle k [set temp2 ceiling (item l (item k matrice) ) + temp2   ]
    set l ( l + 1)
    ]
   ask turtle k [set nb_out_neighboors temp2]
  set k (k + 1)
  ]
end 

;où alternativement avec une boucle explicite (pour construire la pré-matrice comme liste de listes
;to set-up-matrice
;set matrice []
; let i 0
;  while [i != number_of_agents]
;  [
;    ask turtle i [set matrice lput liste_conf_epist matrice]
;
;  set i (i + 1)
;  ]
; end



;modelise les relations entre les agents par des flèches

to add_arrow
  let i 0
  let j 0
  let th 0

  foreach sort turtles
  [
    set j 0
    foreach sort turtles
    [
      ask turtle i
      [
          set th (item j liste_conf_epist)
          if th != 0 and i != j
          [ create-link-to turtle j [set thickness th / 4 ] ]
      ]
      set j (j + 1)
    ]
    set i (i + 1)
  ]
  ask links [ set shape "my_link" ]
end 

to go
  if ticks >= number-ticks [ stop ]
  update_ind_nat
  update_estime
  update_croyance
  update_perf
  determine_couple
  tick
end 



;mise à jour des croyances

to update_croyance
  let somme 0
  let temp 0
  let i 0
  let j 0
  let lst_croy_tmp []

  ifelse Nature_update
  [

  foreach sort turtles
 [
    set j 0
    set somme 0
    foreach sort turtles
    [
      ifelse i = j
      [
          ask turtle i [set somme (somme + ( (item i liste_conf_epist) * (last liste_estime_direct) ) ) ]
      ]
      [
          ask turtle i [ set temp (item j liste_conf_epist)]
          ask turtle j [ set somme ( somme + (temp * (last liste_croyance) ) ) ]
      ]
      set j (j + 1)
    ]
    set lst_croy_tmp lput somme lst_croy_tmp
    set i (i + 1)
  ]
  ]

[

  foreach sort turtles
 [
    set j 0
    set somme 0
    foreach sort turtles
    [
      ifelse i = j
      [
          ask turtle i [set somme (somme + ( (item i liste_conf_epist) * (last liste_croyance) ) ) ]
      ]
      [
          ask turtle i [ set temp (item j liste_conf_epist)]
          ask turtle j [ set somme ( somme + (temp * (last liste_croyance) ) ) ]
      ]
      set j (j + 1)
    ]
    set lst_croy_tmp lput somme lst_croy_tmp
    set i (i + 1)
  ]
  ]


  set i 0
  foreach sort turtles
  [ [?1] ->
    ask ?1 [
      set liste_croyance lput ( item i lst_croy_tmp) liste_croyance
    ]
    set i ( i + 1)
  ]
end 




;mise à jour des performances des agents

to update_perf
  let temp 0
  let somme 0
  let somme_expert 0
  let somme_layman 0
  let nb_exp 0
  let nb_lay 0

  foreach sort turtles
  [ [?1] ->
    ask ?1
    [
      set temp ( ((last liste_croyance) - parametre_a_estimer) * ((last liste_croyance) - parametre_a_estimer) )
      set liste_performence lput temp liste_performence
      set somme (somme + temp)
      ifelse expert
      [ set somme_expert (somme_expert + temp)
        set nb_exp (nb_exp + 1)]
      [ set somme_layman (somme_layman + temp)
        set nb_lay (nb_lay + 1)]
    ]
  ]
  set list_perf_glob lput (somme / number_of_agents) list_perf_glob
  if nb_exp > 0
  [ set list_perf_expert lput (somme_expert / nb_exp) list_perf_expert ]
  if nb_lay > 0
  [ set list_perf_lay lput (somme_layman / nb_lay) list_perf_lay ]
end 




;mise à jour de l'indice naturel des agents

to update_ind_nat
  let indice -1
  ask turtles
  [
      ifelse expert
      [
        while [ indice < 0 or indice > 1 ]
        [
          set indice random-normal parametre_a_estimer ecart_type_expert
        ]
        set liste_ind_nature lput indice liste_ind_nature
        set indice -1
      ]
      [
        while [ indice < 0 or indice > 1 ]
        [
          set indice random-normal parametre_a_estimer ecart_type_laymen
        ]
        set liste_ind_nature lput indice liste_ind_nature
      ]
  ]
end 




;mise à jour de l'estimation des agents

to update_estime
  foreach sort turtles
  [ [?1] ->
    ask ?1
    [
      set liste_estime_direct lput ( (sum [ liste_ind_nature ] of ?1) / (length liste_ind_nature) ) liste_estime_direct
    ]
  ]
end 





;artifice pour reporter dans le behaviour space le couple (dernière perf ; nb_out_neighboors)

to determine_couple
      let m 0                                    ; artifice pour pouvoir reporter facilement le couple (performance ; nb_out_neighboors) dans le bahaviour space
  while [m != number_of_agents]

   [ ask turtle m [set couple []]
     ask turtle m [set couple lput last liste_performence couple]
     ask turtle m [set couple lput nb_out_neighboors couple]
  set m (m + 1)
  ]
end 

to-report impact
  let val 0
let val2 0
if ticks > 0
[
foreach sort turtles [ [?1] ->
    set val [ last liste_estime_direct ] of ?1
    set val val - parametre_a_estimer
    set val val * val
    set val2 [ last liste_performence ] of ?1
    set val2 val - val2
    report val2
 ]
]
end 

There is only one version of this model, created about 1 year ago by Henri Galinon.

Attached files

File Type Description Last updated
Truth-seeking network of agents learning from nature and learning from others : whenTopology trumps ability.png preview Preview for 'Truth-seeking network of agents learning from nature and learning from others : whenTopology trumps ability' about 1 year ago, by Henri Galinon Download

This model does not have any ancestors.

This model does not have any descendants.