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

1 collaborator

Henri Galinon (Author)

AUTHORS

DENIS Alexandre (ISIMA) & CALIME Adrien (ISIMA) sous la direction de Henri Galinon (UCA, PHIER)

TITLE

Network of truth-seeking agents : when topology trumps ability

WHAT IS IT?

This model allows to study how the existence and structure of relations of epistemic trust in a group of truth-seeking agents might affect the epistemic performance of the agents taken individually and as a group. At each step, each agent independently receive from nature a noisy signal pointing to the real value of a certain parameter in [0,1], and balance this information with indirect information about the parameter he obtains by observing the beliefs of his trusted fellows. Agents are taken to be boundedly rational and update their belief following a version of DeGroot model of update (also known as Lehrer-Wagner rule). The agents' abilities to extract information from nature can be differentiated between expert abilities and laymen abilities. These abilities can in turn be varied in the model, in the form of a variation of the standard deviation of the normal law followed by the random signals that experts and layman respectively receive from nature as indication pointing to the real value of the parameter. The structures of epistemic trust can be choosen amongst 4 possibilities : a so-called "master" structure, an "observer" structure, an "circle" structure and a form of random structure which can be used for control purposes in experiments. Epistemic performance is measured as the distance of the believed value to the true value of the parameter.

HOW IT WORKS

In order to observe effectively the evolution of agents, many rules has been created :

All agents have a specific type which are expert or laymen. An expert better has a better view of the parameter to estimate.
An agent will receive at each instant T a natural index which follows a random normal low with the parameter to estimate as average and a specific value of the type of agents as standard deviation.
All agents have a trust toward other agents concerning the value to determine. This trust depends on the style of a group. Four styles has been implemented : ->Master : There is one master who listens all the other agents. An other agent believes himselves at 50% and the master at 50%. ->Circle : All agents are the same. One agent believes himself at 33% and two neighbors at 33% each one. ->Observer : There is one observer who listens all the other agents. An other agent believes himselves at 100%. ->Random : All agents have a belief created randomly.
At each instant T, an agent has an estimation of the value to determine calculating with natural indexes he received.
At each instant T, an agent calculates his belief with the help of the calculated beliefs of the other agents and his own estimation of the value.
All agents have a performance which is calculated by comparing his belief and the value to determine.
Other kinds of performance have been implemented as the global performance, the laymen performance and the expert performance.

HOW TO USE IT

There are many parameters to use in this project for the use of it :

The value to determine which is a number between 0 and 1
The percentage of expert in the model to simulate
An other parameter allows users to force the first agent to be an expert or a layman
The standard deviation for an expert
The standard deviation for a layman
The type of relation the user wants (master, observer, circle, random)
The random seed which allows the programm to be reproducible
The number of ticks represents the time to observe
The number of agents can be modified
The probability to create a link between two agents in the random model

THINGS TO NOTICE

The main things to notice are the four monitors in the main screen of the program. It informs users of the performance of the agents. We can see performances that show if we are near to the value to estimate (if the performance equals 0 the belief equals the value to determine). We can also notice the value of the beliefs for each agents over time.

THINGS TO TRY

You can try what you want by moving all parameters available on the main sceen.

EXTENDING THE MODEL

A possible extension is to create link between agents which can be changed during the simulation. An other extension is to create a list of parameters to estimate.

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 over 2 years 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'	over 2 years ago, by Henri Galinon	Download

This model does not have any ancestors.

This model does not have any descendants.

NetLogo