Introduction à NetLogo

Introduction à NetLogo

Alvaro GilM.A. Économie

Étudiant M.Sc. Génie Industriel

[email protected]

1

Jean-Marc Frayret, Ph.D.Professeur agrégé

École Polytechnique de Montréal

[email protected]

Le 7 février 2012

mailto:[email protected]





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

http://en.wikipedia.org/wiki/Comparison_of_agent-based_modeling_software



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.

4

Blackboard

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)

5

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


















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

6


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











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.)

7


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

















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. 8

Plusieurs exemples (articles et vidéos) se trouvent dans le site:

http://gisagents.blogspot.com

http://gisagents.blogspot.com

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.

9

Blackboard

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 VBA11



• 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.html12

http://jasss.soc.surrey.ac.uk/14/2/5.html











• 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

http://wiki.swarm.org/



• 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

multi-

usages.http://cs.gmu.edu/~eclab/projects/mason/

– Permet la génération des Applets

– Gratuite14

http://cs.gmu.edu/~eclab/projects/mason/

http://cs.gmu.edu/~eclab/projects/mason/



• 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/

– Gratuite15

http://repast.sourceforge.net/

http://repast.sourceforge.net/



• 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

http://www.xjtek.com/

http://www.xjtek.com/



• 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 États-

Unis 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

http://ccl.northwestern.edu/netlogo/

• 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. Présentation du logiciel

2. Librairie des modèles

3. Menus, Environnement,

Buttons et Onglets

4. Génération des Applets

5. Édition des couleurs

6. Édition des agents

7. 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.

25Artificial Market v01.nlogo

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

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

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

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

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

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

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]]]

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

]

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]

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

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

36

Artificial Market v10.nlogo

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

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.

37

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

Artificial Market v11.nlogo

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



http://ccl.northwestern.edu/netlogo/models/community/index.cgi

http://ccl.northwestern.edu/netlogo/models/community/index.cgi

http://modelingcommons.org/account/login

http://files.bookboon.com/ai/index.html

http://www.turtlezero.com/models/index.php

http://jmvidal.cse.sc.edu/netlogomas/

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 Socio-

Economic and Life Sciences.

• Vidal, José (2010) Fundamentals of Multiagent Systems with NetLogo

examples. 39

















Introduction à NetLogo

Documents

Transcript of Introduction à NetLogo