Introduction à NetLogo

Introduction à NetLogo

Alvaro Gil

Jean-Marc Frayret, Ph.D.

M.A. Économie
Étudiant M.Sc. Génie Industriel
alvaro.gil@polymtl.ca

Professeur agrégé
École Polytechnique de Montréal
jean-marc.frayret@polymtl.ca

Le 7 février 2012
1

Modélisation à base d’agents
• L’étude des systèmes complexes par la simulation (à
base d’agents) nécessite l’utilisation d’ordinateurs ainsi
que de logiciels spécialisés pour modéliser et faire des
expérimentations
• Bien que la simulation à base d’agents (ABS) est
relativement nouvelle, de nombreuses plateformes
existent sur le marché
• Quelques-unes sont très populaires cependant, il n’y a
pas beaucoup d’exemples encore développés dans le
domaine de l’ingénierie
2

Quel logiciel utiliser?
• Plusieurs variables:
– Complexité du problème
– Discipline (Biologie, Sociologie, Système d’information géographique,
Économie, Finances, Ingénierie, etc.)

– Topologie de l’environnement de l’agent et communication entre
agents
– Sophistication de la solution (visualisation, algorithmes, libraires,
etc.)

• Plus de 70 logiciels spécialisés connus dans le marché;
• Wikipedia a un tableau comparatif avec une liste
détaillée
– http://en.wikipedia.org/wiki/Comparison_of_agent-based_modeling_software
3

Topologie
• Les agents existent dans un environnement dont
la nature peut être très différente en fonction des
modèles
• Il existe donc différentes façons de représenter cet
environnement et de connecter les agents.

Blackboard

4

Topologie : Représentation euclidienne
• On utilise la représentation
Euclidienne lorsqu’on veut
simuler des agents en
mouvement.
• Exemples:
–
–
–
–

Populations
Ateliers
Trafique et Piétons
Design d’installations
(comportement des foules)
Quelques exemples en vidéo :
http://www.youtube.com/watch?v=lF_RoSlofyA&feature=related
http://www.youtube.com/watch?v=zV7LDPXIaSU
http://www.youtube.com/watch?v=LGWi1b9yY4k

5

Topologie : Représentation par grilles
• On utilise la représentation
des grilles lorsqu’on veut
simuler des « agents
statiques » (des états) et
leur interaction avec leur
environnement.
• Exemples :
– Modèle de ségrégation de
Schelling
– Modèles de perception
http://www.youtube.com/watch?v=A_XtboyO8jc&feature=related
http://www.youtube.com/watch?v=PAzkHC5sUsk&feature=related
http://www.youtube.com/watch?v=Wg2EpbDSbKM

6

Topologie : Représentation par réseaux
• La représentation en utilisant des
réseaux est beaucoup utilisée.
• Avec les réseaux, on peut
représenter des phénomènes
comme la propagation et la
communication entre autres.
• Exemples:
– Réseaux sociaux
– Chaîne d’approvisionnement
– Réseau de quelque service
(électricité, téléphonie, etc.)
http://www.youtube.com/watch?v=pgUT4F8mskQ&feature=related
http://www.youtube.com/watch?v=XX5rRF6uxow&feature=related
http://www.youtube.com/watch?v=IylatdeowRQ

7

Topologie : Représentation par GIS
• Il existe la représentation à partir des
systèmes d’information
géographiques.
• Ici on peut utiliser l’information des
cartes géographiques standards et
les convertir en vecteurs de données
pour créer une grille plus complexe.
Chaque cellule de la grille
représenter une partie de la carte
originale.
• Ce type de modélisation est utile
dans certains modèles de transport
et trafique.

Plusieurs exemples (articles et vidéos) se trouvent dans le site:
http://gisagents.blogspot.com

8

Topologie : Blackboard
• L’environnement des agents peut finalement
n’avoir qu’une nature purement
informationnelle.
• Les agents ne peuvent percevoir qu’une
partie des informations disponibles (droit
d’accès)
• Il peut exister des règles d’utilisation des
données (coordination de l’accès et du
traitement des données)
• Un agent peut même être responsable de la
coordination de l’accès aux données.

Blackboard

9

Topologie : Remarques finales
• Il est possible aussi d’utiliser
plusieurs topologies dans le même
modèle, cela peut permettre de
construire des modèles plus
complexes et avancés.
• Souvent, on trouve des
combinaisons entre l’approche
euclidienne et le GIS ou entre
l’approche des Réseaux et le GIS.

10

Quelques exemples de logiciels de
modélisation à base d’agents
• Feuilles de calcul (Excel – avec
VBA)
– N’est pas très populaire
– Cependant, il est possible de générer des
simulations avec Excel dans lesquelles le
niveau de complexité est relativement bas.
– Il est nécessaire d’utiliser VBA pour
concaténer les actions et représenter le
comportement des agents.
– Dans le livre de North et Macal (2007), il y a
un bon exemple d’un modèle de simulation à
bas d’agents avec Excel et VBA
11

• Langages de programmation orientées
objets (C++, Java, Python, Pearl, etc.) et
pseudo langages (Mathematica, Matlab,
etc.)
– Très puissant et polyvalent.
– Il exige un fort background en programmation
– On peut aussi utiliser des librairies spécialisées
pour augmenter la complexité des certaines
opérations (Estimation, Métaheuristiques, etc.)
– Un bon exemple est développé par Isaac (2011)
en utilisant Python.
http://jasss.soc.surrey.ac.uk/14/2/5.html
12

• Logiciels spécialisés :
– Swarm: Premier logiciel spécialisé créé.
– Développé dans l’institut Santa Fe aux
États-Unis en 1996.
– Les premières versions ont été faites en
C et puis en JAVA
– Il est très populaire, cependant il
demande une très forte connaissance de
la programmation.
– http://wiki.swarm.org/
– Gratuite

13

• Mason («Multi-Agent Simulator Of
Neighborhoods») :
– Développé en 2004 par le laboratoire
d’informatique évolutive à l'Université George
Masson et le centre de recherche pour la
complexité sociale GMU.
– Le développement est basé sur la simulation à
événements discrets avec les bibliothèques Java
multiusages.http://cs.gmu.edu/~eclab/projects/mason/
– Permet la génération des Applets
– Gratuite

14

• Repast «Recursive Porous Agent Simulation
Toolkit» (.Net, J, Py):
– Développé en 2000 par le laboratoire ARGONNE aux
Etats-Unis
– Entièrement développé en Java, base une grande partie
de son architecture sur les bibliothèques SWARM.
– Il a des bibliothèques de classes qui permettent de
manipuler l'information des agents, ainsi qu’une grande
collection de bibliothèques graphiques qui peuvent
produire des simulations plus réalistes
– http://repast.sourceforge.net/
15
– Gratuite

• Repast (.Net, J, Py):

16

• AnyLogic
– Logiciel commercial développé entièrement en
JAVA par la compagnie Russe XJ Technologies
– Très puissante et polyvalente.
– Très bons graphiques et animations
– Permet la génération des Applets
– http://www.xjtek.com/

17

• NetLogo
– On parlera plus à profondeur de lui dans
quelques diapositives.

18

Comparaison de certains outils pour
la simulation à base d’agents

North et Macal 2006
19

Introduction à Netlogo
• Logiciel développé à l’université Northwestern aux ÉtatsUnis en 1999.
• Il est gratuit, peut être téléchargé à l’adresse:
– http://ccl.northwestern.edu/netlogo/

• Plusieurs versions (la 4.2 est la plus stable)
• Systèmes d’exploitation Windows et Mac OS
• Langage simple et primitif (évolution du langage Logo et
StarLogo)
• Polyvalente et puissante
• Grande communauté de chercheurs et des groupes
d’utilisateurs (google groups)
21

• Que ce qu’on peut faire avec NetLogo?
–
–
–
–
–
–

Création des agents
Négociation
Collaboration
Apprentissage
Décisions autonomes
Expérimentation (statistiques de différentes configurations du
même modèle)
– Importation et exportation des données
– Animation
– Génération des Applets

22

Points d’intérêts de Netlogo:
1.
2.
3.
4.
5.
6.
7.

Présentation du logiciel
Librairie des modèles
Menus, Environnement,
Buttons et Onglets
Génération des Applets
Édition des couleurs
Édition des agents
Expérimentation

23

• Développement d’un modèle de chaîne
d’approvisionnement étape par étape
– Par la suite, on présentera 10 modèles qui nous
aideront à mieux comprendre les concepts
fondamentaux de la simulation à base d’agents en
utilisant NetLogo.
– Chaque modèle sera noté par
«Artificial Market vXX.nlogo»

24

Modèle de chaîne
d’approvisionnement en NetLogo
• Modèle 1: Modèle de base avec une quantité variable
de clients, chaque client a une demande variable
distribuée normalement avec moyenne et déviation
standard établies par l’utilisateur.
• On a une quantité fixe de points de vente («Retailers»)
• La figure des détaillants est personnalisée en utilisant
l’outil d’édition des tortues.
• On utilise un graphique pour tracer l’évolution des stocks
des détaillants et des clients.

Artificial Market v01.nlogo

25

Modèle de chaîne
• Modèle 2: On utilise la régression linéaire pour
l’estimation (les prévisions) des ventes.
• Les entrées sont les ventes et les ruptures de stock
to update_forecast
ifelse (length(sales) > 2) and (max(temp_demand) != 0)
[set forecast matrix:forecast-linear-growth (temp_demand)
set ds standard-deviation temp_demand]
[set forecast lput(round(demand / 7)) forecast
set forecast lput(round(demand / 7)) forecast
set forecast lput(0) forecast
set forecast lput(0) forecast]
let b item 1 forecast
let a item 2 forecast
let t length(sales)
let i 1
while [i <= 7] [
set forecasting lput(t * a + b) forecasting
set i i + 1
set t t + 1]
set demand round(sum(forecasting))
if demand < 0 [set demand 0]
let dailyd demand / 7
set reorder_point round(dailyd * 7)

Procédure pour faire
l’estimation des ventes
avec régression linéaire


26

Modèle de chaîne
• Modèle 3: On ajoute maintenant certains éléments de la
théorie des inventaires pour faire l’estimation des points
de commande et les quantités à commander.
Paramètres ajoutés

to update_forecast
…
let z table:get safety_values SS_%
set EOQ round(sqrt(2 * demand * 52 * K / (HC * Product_cost)))
set reorder_point round(dailyd * Lead_Time + z * ds)

Commandes ajoutées
à la procédure d’estimation


27

Modèle de chaîne
• Modèle 3: Théorie des inventaires
set safety_values table:make
table:put safety_values 0.50 0
table:put safety_values 0.55 0.125661347

to place_orders
set comande round(EOQ - stock)

Tableau des valeurs
de la distribution normale

Lignes ajoutées
à la procédure des
commandes des produits


28

Modèle de chaîne
• Modèle 3: Théorie des inventaires
to update_costs
set holding_cost lput (HC * stock * Product_cost) holding_cost
if (length(placed_orders) = 0) OR (length(placed_orders) != length(holding_cost))
[set placed_orders lput 0 placed_orders]
ifelse last(placed_orders) = 0
[set order_cost lput 0 order_cost]
[set order_cost lput K order_cost]
set total_cost lput (last(order_cost) + last(holding_cost)) total_cost
end
to evaluate_results
let l []
set l lput (word ticks "-Reg") l
set l lput(sum([stock] of customers)) l
set l lput(sum([stock] of retailers)) l
set stocks_h l
set l []
let s 0
foreach ([total_cost] of retailers) [set s s + (last(?))]
set l lput(s) l
set costs_h l
end

Procédure d’estimation
et de mis à jour des
coûts de stockage


29

Modèle de chaîne
• Modèle 4: On peut essayer aussi en utilisant le
déplacements dans les agents. Dans notre cas, ce type
des procédures réduit la vitesse de la simulation. Il est
mieux de l’implémenter lorsque cela est nécessaire.
to transit
ask customers [
let flag 0
while [flag = 0] [
let val (random 5) / 10
let t random 2
;let t 0
if t = 0
[fd val]
if t = 1
[right val]
if t = 2
[fd -1 * val]
if t = 3
[right -1 * val]
ifelse (xcor <= max-pxcor and ycor <= max-pycor and xcor >= min-pxcor
and ycor >= min-pycor) [set flag 1]
[rt random 90]]
]
end


30

Modèle de chaîne
• Modèle 5: On efface la sous-routine de déplacements,
et on ajoute deux procédures pour optimiser le modèle
(réduire les vecteurs d’information et effacer les agents
sans demande)
to update_market
ask retailers with [clients = []] [die]
end

to purge
ask retailers
[if length(sales) > 100
[let l length(sales)
set sales sublist sales (l - 100) l
]]
end


31

Modèle de chaîne
• Modèle 6: On ajoute les distributeurs (fournisseurs des
détaillants).
breed [distributors distributor]
distributors-own [
EOQ
reorder_point
orders
available_stock
suppliers
supplier_score
supplier0
clients
daily_sales
sales
lost_sales
forecast
placed_orders
holding_cost
order_cost
total_cost]

to send_products
ask distributors
[let list1 map [last ?] orders
let list2 filter [? = ticks] list1
if length(list2) > 0 and max(list2) > 0
[let attending filter [last ? = ticks] orders
set list2 []
let list3 []
foreach attending [
set list2 lput(item (position ? orders) clients) list2
set list3 lput(first(item(position ? orders) orders)) list3]
let i 0
while [i < length(list2)] [
ask turtle (item i list2) [
set stock (stock + item i list3)]
set i i + 1]
set i 0
while [i < length(orders)]
[if last(item i orders) = ticks
[set orders replace-item i orders [0 0]]
set i i + 1]]]


32

Modèle de chaîne
• Modèle 7: On ajoute les usines (fournisseurs des
distributeurs).
breed [factories factory]
Factories-own [
production_rate
reorder_point
orders
available_stock
clients
daily_sales
sales
lost_sales
forecast
holding_cost
order_cost
total_cost
]


33

Modèle de chaîne
• Modèle 8: On peut aussi utiliser différentes politiques
des inventaires, ainsi que différentes stratégies de
consommation (clients)
turtles-own [strategy]
distributors-own & retailers-own & customers-own
next_review
Create-factories & distributors & retailers
let s read-from-string first(Inventory_Policy)
ifelse s = 4
[set strategy (random 3) + 1]
[set strategy s]
let s read-from-string first(Inventory_Policy)
ifelse s = 4
[set strategy s]
create-customers
let s read-from-string first(Customers_Strategy)
ifelse s = 3
[set strategy s]


34

Modèle de chaîne
• Modèle 9: Maintenant, on peut visualiser un réseau des
agents (client-fournisseur).
to create_network
ask links [die]
ifelse Show_Network = true [
ask customers [
if supplier0 != nobody
[create-link-to retailer supplier0
[set color gray + 3]]]
ask retailers [
create-link-to distributor supplier0
[set color green]]
ask distributors [
create-link-to factory supplier0
[set color blue]]
set ret_list sort([who] of retailers)
let dd []
foreach ret_list
[set dd lput(count(links with [end2 = retailer ?])) dd]
set-current-plot "Clients per Retailer »
foreach dd
[plot ?]]
[ask links [die]
set-current-plot "Clients per Retailer"
clear-plot]
end


35

Modèle de chaîne
• Modèle 10: On peut aussi créer des promotions des
produits. Cela peut mener à recréer l’effet coup de fouet
Globals [promotion]
To Setup [set promotion [0 0 0] ]
to buy_products
if promotion != [0 0 0] and member? who [clients] of retailer supplier0
[set dem round(dem * random-float (item 1 promotion))]
To evaluate_results
ifelse first(promotion) = 0
[set l lput (word ticks "-Reg") l]
[set l lput (word ticks "-P-" item 0 promotion "-" item 1 promotion) l]
to create_promotion
let list1 read-from-string user-input "Create a promotion [a b c] (retailer a, impact b (1 to 10), during c periods"
ifelse is-list? list1 and length(list1) = 3
[let p item 0 list1
let i item 1 list1
let c (item 2 list1) + ticks
let l []
set l lput(p) l
set l lput(i) l
set l lput(c) l
set promotion l
user-message (word "Today a promotion will occur at store " p)]
[user-message (word "The array doen't have a valid format, pleas try again")]
end

36


Modèle de chaîne
• Modèle 11: Finalement, les clients peuvent ajuster ses
attentes en choisissant le fournisseur selon l’expérience
d’achat.
En purchase products
if Score_Retailers? = true
[score_supplier who -0.01]
if Score_Retailers? = true
[score_supplier who 2 ]
to score_supplier [a b]
;agent A, score B
ask turtle a [
let list1 map [first ?] suppliers
let p position supplier0 list1
if item p supplier_score + b >= 0
[set supplier_score replace-item p supplier_score (item p supplier_score + b)]
]
end


37

Sites d’intérêt
• Site du NetLogo
– http://ccl.northwestern.edu/netlogo/

• Communauté de NetLogo
– http://ccl.northwestern.edu/netlogo/models/community/index.cgi

• Modeling Commons:
– http://modelingcommons.org/account/login

• Modèles pour l’intelligence artificielle et l’aprentissage:
– http://files.bookboon.com/ai/index.html

• D’autres sites:
– http://www.turtlezero.com/models/index.php
– http://jmvidal.cse.sc.edu/netlogomas/
38

Réferences
•
•
•

•

•
•
•

•

Bersini, Hugues (2012) 'UML for ABM' Journal of Artificial Societies and
Social Simulation 15 (1) 9 http://jasss.soc.surrey.ac.uk/15/1/9.html
Gilbert et Troitzsch (2005) Simulation for the social scientist
Huget, Marc-Philippe (2002) An Application of Agent UML to Supply Chain
Management. Technical Report, Department of Computer Sciences,
University of Liverpool.
Isaac, Alan G. (2011) 'The ABM Template Models: A Reformulation with
Reference Implementations' Journal of Artificial Societies and Social
Simulation 14 (2) 5 http://jasss.soc.surrey.ac.uk/14/2/5.html
Macal, North (2006) Introduction to Agent-based Modeling and Simulation.
Center for Complex Adaptive Agent Systems Simulation.
North et Macal (2007) Managing Business Complexity, Discovering
Strategic Solutions with ABM.
Naldi et al. 2010. Mathematical Modeling of Collective Behavior in SocioEconomic and Life Sciences.
Vidal, José (2010) Fundamentals of Multiagent Systems with NetLogo
examples.
39

Introduction à NetLogo

Contenu connexe

Tendances (20)

Similaire à Introduction à NetLogo (20)

Plus de Alvaro Gil (18)

Introduction à NetLogo