Archives de catégorie : SMA

Cormas dans container OpenMole

SMA, ,

Je parlais l’autre jour de l’utilisation de Cormas dans Docker et j’avais évoqué la possibilité d’utiliser cette plateforme multi-agent à l’intérieur d’openMole pour pouvoir bénéficier des possibilités de la taupe pour paralléliser le calcul et explorer des modèles.

J’avais profité de Romain pendant le coding-camp 2018 pour qu’on propose une première version de plug-in cormas pour openMole. En plus d’ouvrir des portent au calcul pour Cormas, l’idée était de permettre à l’équipe de développer de se concentrer sur le développement de la plateforme plutôt que sur le redéveloppement des méthodes de calcules.

Etape 1 : un container OpenMole

Pour tester Cormas dans openMole le plus simple est d’utiliser docker. En effet l’équipe openMole propose un joli petit container qui rox les poneys ! Vous pouvez le lancer comme ça :

## telecharger la derniere image
docker pull openmole/openmole:8.0-SNAPSHOT
## cree un conteneur avec les droit décriture sur le dossier monte
docker run -u root  -v /root/openMole_workSpace:/var/openmole openmole/openmole:8.0-SNAPSHOT chown -R openmole:openmole /var/openmole/
## lancer le contener en mode detache
docker run --cap-add=SYS_PTRACE --security-opt seccomp=unconfined -p 8080:8443 -v /root/openMole_workSpace:/var/openmole/ openmole/openmole:8.0-SNAPSHOT

Etape 2 : le plug-in cormas pour OpenMole

Voilà la primitive cormas n’est pas directement intégrée à OpenMole, il faudra donc télécharger le plug-in, et l’importer en utilisant le bouton idoine (la prise électrique) dans la barre d’outils en haut.

Etape 3 : Le script OpenMole

Une fois que le plug-in est installé, il ne reste plus qu’à exécuter un script. Pour se simplifier la vie, on utilisera pour l’exemple un modèle chargé par défaut dans cormas : le modèle des pompiers. Pour ceux qui n’ont pas une petite idée ce que c’est, on a un automate cellulaire dont les cellules passe de arbre à brulé et des agents pompier qui vont essayer d’éteindre l’incendie.

Vous pouvez maintenant crée un script.oms qui sera executable par OpenMole.

// OpenMole Variable definition.
// Those variables will be populated in openMole
// and send in JSON to Pharo/Cormas

val seed = Val[Int]

val numberOfFires = Val[Int]
val numberOfFiremen = Val[Int]
val percentageOfTrees = Val[Double]
val dimensionMin = Val[Int]
val dimensionMax = Val[Int]
val nbTrees = Val[Int]

// The CORMASTask take in parameters the class and method able to
// launch our simulation. In OUr case using the Cormas-Model-FireAutomata
// we run a methods build for OpenMole. You can take a look.
// set() allow you to pass some other thing to your task. You can pass :
// * your model as a file.st
// * inputs from OpenMole Variable
// * outputs as an array
// * defined parameters how doesn't change between simulation.

val model = CORMASTask("CMFireAutomataModel simuOpenMole") set (
//resources += workDirectory / "Cormas-Model-FireAutomata.st",
inputs += seed,
cormasInputs += numberOfFires,
cormasInputs += numberOfFiremen,
cormasInputs += percentageOfTrees,
cormasInputs += dimensionMin,
cormasInputs += dimensionMax,
cormasOutputs += nbTrees,

outputs += (seed, numberOfFires, numberOfFiremen, percentageOfTrees, dimensionMin, dimensionMax),

numberOfFires := 3,
numberOfFiremen := 10,
percentageOfTrees := 0.65,
dimensionMin := 60,
dimensionMax := 80
)

// With the DirectSampling() method you define an easy wait to generate
// a sampling for numberOfFires between 1 to 10.
DirectSampling(
evaluation = model hook CSVHook(workDirectory / "results.csv"),
DirectSampling(
  evaluation = model hook CSVHook(workDirectory / "results.csv"),
  sampling = (numberOfFires in (1 to 10)) x
             (seed in (UniformDistribution[Int]() take 10))
)

Dans ce script la partie propre à Cormas est bien sûr la CORMASTask(). Elle devra contenir l’ensemble des instructions qui seront passées au docker de cormas. Dans l’exemple ici, nous fixons tous les paramètres par défaut. C’est dans la méthode DirectSampling() que l’on va faire varier le nombre de feux a l’initialisation et qu’on définira le nombre de réplications du modèle.

Etape 4 : passer à l’échelle

À l’étape précédente, on utilise un seul thread de l’ordinateur. Pour passer à l’échelle rien de plus simple, il faut simplement modifier la fin du script :

val env = LocalEnvironment(2)

// With the DirectSampling() method you define an easy wait to generate
// a sampling for numberOfFires between 1 to 10.
DirectSampling(
evaluation = model on env hook CSVHook(workDirectory / "results.csv"),
sampling = (numberOfFires in (1 to 10)) x
(seed in (UniformDistribution[Int]() take 10))
)

On définit une variable env qu’on va ensuite appelée dans évaluation. Notre variable env fera alors tourner les modèles en parallèle sur … 2 thread. Si vous avez accès à plus en local, n’hésitez pas à pousser. Enfin si vous avez la chance d’avoir accès à un cluster il ne vous reste plus qu’a explorer les différents environnements pris en charge par OpenMole.

Voilà par exemple sur un cluster SGE, 100 jobs lancés que l’on peut monitor dans l’interface openMole

et que l’on peut voir sur le cluster avec qstat

Références :

Construire un container pour Cormas

geekeries, SMA,

Cormas est une plateforme de modélisation multi-agents développée en SmallTalk. Historiquement le choix de développement s’était porté sur VisualWork mais depuis quelque temps l’équipe regardait en direction de Pharo.

Cormas sous pharo

Le portage se fait petit à petit, et la feuille de route avance assez rapidement. Si le sujet vous intéresse, nous sommes en train de rédiger un manuel d’utilisation de cette nouvelle version de Cormas sous pharo.

Comme c’est le moment des grandes décisions on s’interroge sur les passerelles avec d’autres outils régulièrement utilisés par les communautés de chercheurs utilisant les SMA et plus largement la simulation. Pour le moment l’attention est portée sur les connexions entre cette nouvelle version de cormas et R et cormas/openMole.

Pour cette dernière, openMole intègre un système de conteneur basé sur udocker. Je suis donc en train de fouiller les possibilités de dockerisé cormas/pharo pour dans un futur que j’espère assez proche nous puissions faire l’ensemble de nos explorations en utilisant openMole.

Ecrire un dockerfile

# Set the base image
FROM ubuntu
# Dockerfile author / maintainer
MAINTAINER Etienne  <moi@truc.fr>

# Update software repository
# and install dependencies
run dpkg --add-architecture i386
run apt-get update && apt-get install -y curl unzip libx11-6:i386 libgl1-mesa-glx:i386 libfontconfig1:i386 libssl1.0.0:i386 libcairo2:i386

RUN mkdir cormas && cd cormas
RUN curl https://get.pharo.org | bash
RUN ./pharo Pharo.image config http://ss3.gemstone.com/ss/Cormas --install=development

Construire un conteneur à partir du dockerfile

sudo docker build -t cormas

Lancer un conteneur à partir du build

docker run --name cormas_instance -t cormas

Tester le fonctionnement

Votre conteneur doit être en train de fonctionner. Pour le vérifier, vous pouvez lancer les commandes suivantes.

docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
914f52adbd98 cormas "/bin/bash" About a minute ago Up About a minute cormas_instance
eeba02bea345 mdillon/postgis "docker-entrypoint.s…" 2 weeks ago Exited (0) 2 weeks ago psql-futurSahel

Vous voyez que j’ai deux conteneurs (psql-futurSahel et cormas_instance) et que le conteneur cormas_instance est en cour de fonctionnement.

On peut maintenant essayer d’interagir avec pharo à l’intérieur du conteneur

sudo docker exec -it 914f52adbd98 /pharo Pharo.image eval '1 + 20'

Si tout s’est bien passé, vous constaterez que pharo vous répond de manière aimable 21 !

Note :

Pour pousser un nouveau conteneur

sudo docker tag cormas elcep/cormas
sudo docker push elcep/cormas

 

Références :

ODD song

SMA,

Dans le monde de la modélisation individu centré, l’un des formalismes attendus pour publier une description de modèles s’appelle ODD pour Overview, Design
concepts, and Details. La description de ce formalisme a été publiée en 2006 dans Ecological Modelling.

Grimm, V., U. Berger, F. Bastiansen, S. Eliassen, V. Ginot, J. Giske, J. Goss-Custard, et al. 2006. « A Standard Protocol for Describing Individual-Based and Agent-Based Models ». Ecological Modelling 198 (1–2): 115‑26. doi:10.1016/j.ecolmodel.2006.04.023.
Et bien voila la chanson de l’ODD !

la suite …

Non classé, SMA

soutenance DELAYUn petit billet pour vous annoncer avec fierté mon passage dans le monde des docteurs en géographie. La soutenance s’est déroulée le 10 juin à 14h à la FLSH de Limoges. La thèse soutenue sous la direction de E. Rouvellac, N. Becu et P. Allée s’intitule : « Réflexions géographiques sur l’usage des systèmes multi-agents dans la compréhension des processus d’évolution des territoires viticoles de fortes pentes : le cas de la Côte Vermeille et de la val di Cembra« 

J’ai poussé sur github tout le matériel… la thèse (pour les curieux),  la présentation de la soutenance, les différents modèles à base d’agents. En avant-gout, en voilà le résumé :

En ce début de XXIe siècle, le vin et la vigne constituent une richesse importante pour bon nombre de pays. Les territoires viticoles, tout en conservant leurs qualités d’espace de production, développent des stratégies d’adaptation à la globalisation du marché et aux attentes des consommateurs toujours plus versatiles.
Or en raison de conditions orographiques particulières, les territoires de montagne et de fortes pentes voient leurs marges de manœuvre réduites. En effet, une grosse partie de leurs coûts de production reste bien souvent incompressible par rapport à la viticulture de plaine. Paradoxalement ces paysages viticoles, image du construit social et des équilibres environnementaux, participent à leur reconnaissance internationale.

Le travail présenté ici est né en réponse à la sensibilité croissante de ces vignobles de forte pente. En nous appuyant sur deux territoires d’étude, en France le vignoble de la Côte Vermeille et en Italie le val di Cembra, nous questionnons les spécificités de la viticulture de fortes pentes. Notre approche met l’accent sur les possibilités offertes par des méthodes empiriques de modélisation à base d’agents pour proposer un regard renouvelé sur le rôle des interactions société-environnement dans le maintien et le développement de ces territoires sous contraintes.

A travers une constellation de modèles multi-agents issus des questionnements récurrents des acteurs de la filière, et selon une démarche exploratoire et incrémentale, nous nous intéresserons ici à trois grands types de questions posées aux territoires viticoles de fortes pentes.
Le premier concerne la place du marché et ses conséquences sur les dynamiques de couvert végétal à petite échelle. Le second type de questionnement explore également les dynamiques spatiales du couvert végétal, mais se place à mezzo-échelle, et propose de s’intéresser à la définition des règles socio-économiques simples qui sous-tendent les dynamiques foncières à l’échelle de quelques communes. Enfin le dernier volet de ce travail se place à grande échelle et s’intéresse à des phénomènes très descriptifs.

L’ensemble de ces réflexions nous amènera ensuite à utiliser la modélisation co-construite avec les acteurs pour proposer une vision prospective globale pour les territoires de montagne et de fortes pentes. Cette approche prospective sera conduite en parallèle avec certains acteurs de la filière ce qui nous permettra de délimiter les variables structurelles propres aux systèmes de fortes pentes telles qu’elles sont ou non vécues par les acteurs. Basés sur la délimitation de ces variables, nous proposons enfin quatre scenarii prospectifs pour la viticulture en forte pente.

Un peut d’espace pour openMole

geekeries, SMA,

openmoleSi vous voulez passer un de ces jours à openMole, voilà 2-3 astuces :
openMole va demander beaucoup de ressource à votre ordinateur (d’autant plus s’il tourne en local). Il peut donc s’avérer utilise de de pousser un peut les limites du système. ça se passe dans `/etc/security/limits.conf` vous pouvez coller à la fin du fichier de conf

*               hard    as              110000000
 *               hard    rss             100000000
 *               soft    nproc           20000
 *               hard    nofile          50000
 *               soft    nofile          50000

Les limites soft sont celles qui seront allouées par défaut à votre système et les limites hard sont celles que vous pourrez pousser à la main avec la commande ulimit…

Ensuite vous pourrez si le besoin se fait sentir également déverrouiller certaines limites avec :

ulimit -c unlimited

Voilà on est un peut moins à l’étroit pour jouer avec la mole!