🎧 🤰🏿 🐋 Modèle Predator-Prey sur Node.js 🛠️ 👐🏼 👩🏼‍🤝‍👨🏿

Récemment, une vague de références au jeu Life a traversé le réseau , principalement en raison du décès de son créateur.

Il est maintenant temps que tout le monde s'intéresse à la biologie, partout dans ces programmes de survie, eh bien, j'ai soudainement sorti des poubelles de la mémoire un modèle intéressant, selon lequel j'ai écrit une fois un article de terminologie.

Le modèle est similaire à la vie en ce sens qu'il s'agit du même processus cyclique qui peut être considéré comme un feu, méditer sans fin et réfléchir sur l'éternel.

Il s'agit d'un Predator-victime , un modèle très sérieux des mathématiques appliquées (Predator-proie dans le monde anglophone).

L'essence du processus est que dans une certaine forêt vit un troupeau de cerfs (dans la version alternative - des lapins, mais pas l'essence), qui mangent dans la nature et se reproduisent de manière incontrôlable, et remplissent tôt ou tard tout le territoire.

Cependant, dans la même forêt, il y a aussi des prédateurs qui se nourrissent de ces cerfs (loups, mais pour les lièvres, généralement les renards).

Une paire de prédateurs qui se trouvent dans cette forêt abondante se multiplie de façon exponentielle vigoureusement conformément à la loi de Malthus , mais à un moment donné, les ressources des cerfs commencent à s'assécher, les loups commencent à mourir de faim et à mourir, l'exposant vole rapidement vers le bas et seuls les plus persistants y survivent.

Le cerf, conduit dans un coin, lève la tête, allume son exposant et commence à dominer la forêt, mais les loups survivants avec de la viande fraîche trouvent leur force pour une nouvelle vague de fertilité ... et ainsi de suite en cercles et à l'infini.

Voici le graphique (tiré de Wikipedia): Le

modèle mathématique de ce processus a été décrit au début du 20ème siècle par Lotka et Volterra et nommé d'après eux.

Pourquoi ce modèle existe-t-il depuis cent ans et est-il toujours d'actualité?

Il y a deux raisons principales: il est très simple et décrit le processus de façon assez réaliste.

Le modèle n'a que quatre paramètres:

alpha) taux de reproduction des cerfs
bêta) les cerfs mangent la vitesse des loups
gamma) le taux d'extinction des loups affamés
delta) taux de reproduction des loups bien nourris

Le modèle contient une non-linéarité minimale et est considéré analytiquement. Avec des paramètres bien choisis, il est stable (ni cerfs ni loups ne meurent jusqu'au bout) et décrit de façon réaliste la dynamique des fluctuations des populations.

Au cours des cent dernières années, il y a eu de nombreuses tentatives pour rendre quelque chose de plus réaliste - mais toute augmentation de la complexité conduit à un système non linéaire d'un niveau supérieur, puis tout repose sur des équations intégrales impénétrables qui ne peuvent être résolues que par des méthodes numériques.

Il existe une autre méthode - il suffit de programmer ce processus comme un jeu.

En fait, cette approche est appelée modélisation multi-agents et est tout à fait appropriée pour réussir le cours.

Choisir une technologie

J'aimerais que le programme soit visualisé, non seulement sur la machine de l'auteur, mais sur le plus grand public possible, et qu'il devrait être tout seul, avec un minimum d'effort et tout cela.
Il est logique que la solution soit d'exécuter le programme dans un navigateur et, par conséquent, vous devrez l'écrire en javascript.

Eh bien, afin de ne pas produire de zoo technologique, nous allons également y écrire un serveur.

Les étapes standard pour installer node.js et tout ce dont vous avez besoin sont décrites sur le github .

Modèle de croissance des cerfs

Nous passons à la plus intéressante - la reproduction. Sans prédateurs, nous avons un modèle malthusien dans des conditions de ressources limitées (dans le monde des mathématiques, il est décrit par une fonction logistique ou l'équation de Verhulst ), maintenant il doit d'une manière ou d'une autre être appliqué aux agents.

Il est possible de sélectionner des coefficients probabilistes pour chaque cerf et tout devrait fonctionner.
Mais la modélisation d'agent d'agent est bonne - vous pouvez spécifier le comportement sans vous limiter à quelques facteurs.

En général, le modèle de vie du cerf ressemble à ceci:

les cerfs ont besoin de bouger. Un cerf qui ne pouvait pas bouger par unité de temps meurt (et il ne pouvait pas bouger juste parce que toutes les cages voisines sont occupées par ses amis).
, , .

  breed(u) {
    var spots = MapUtil.get_adj(u.point, this.W, this.H)
    if (!spots || spots.length < 1)
      return false
    var free = spots.filter(p => !this.GM.get(p))
    if (free.length < spots.length)
      return false
    var spot = _.sample(spots)
    if (!spot)
      return false
    var born = new Wild(u.kind)
    born.move(spot)
    this.add_wild(born)
    this.born.push(born)
  }

Ensuite, nous allons créer une application de test légère qui crée un monde forestier de 20 x 20, se déroule au centre même du cerf et exécute 100 cycles, imprimant à chaque fois l'état en csv.

Nous allons conduire le fichier csv résultant dans la feuille de calcul Google et générer un graphique:

c'est tout à fait un exposant. Nous voyons que le nombre se stabilise pour plus de 200 cerfs, cela peut facilement s'expliquer par le fait que le besoin de mouvement nécessite au moins deux cages pour le cerf, et la superficie de la forêt entière est de 400. La

croissance maximale se produit assez tôt - au mouvement 14-15 et aux 20 derniers mouvements reste immobile avec de légères fluctuations.

En général, je tiens à souligner que le modèle d'agent le plus simple se comporte de manière très réaliste, assez similaire à une courbe logistique diluée avec un léger bruit.

Mais nous sommes venus ici non pas tant pour les chiffres que pour les photos que vous pouvez regarder et vous détendre.

Il est donc temps de créer une page avec une carte et des graphiques et de transférer le modèle exécuté sur le serveur.

Nous mettons express et socket.io, et nous allons dessiner directement sur le canvas html5 (je ne connais pas les moteurs js, et la tâche n'est pas très difficile).

Nous regardons et devenons nerveux à propos de la façon dont les cerfs inondent littéralement la forêt en quelques itérations, puis fluctuent asymptotiquement autour du maximum.

D'une part, ce n'est qu'un modèle, mais à certains endroits, c'est un vrai problème - juste la surpopulation de cerfs google et soyez surpris de l'abondance de matériel sur ce sujet.

Ce modèle ne prend pas en compte la dégradation des forêts, mais en réalité les cerfs sont des consommateurs plutôt gourmands - ils mangent des pousses, piétinent le sol et détruisent généralement leurs forêts.

Que doit faire le propriétaire forestier dans ce cas?

Il achète des loups, accroche un capteur GPS sur chacun et prie pour qu'ils ne disparaissent pas.

loups

Il est temps d'introduire le loup dans notre modèle.

Deux choses doivent être décidées - comment le loup mange et se multiplie.

Il est facile de chasser quand il y a quelqu'un - s'il y a un cerf dans une cage voisine - il suffit de le manger.

S'il n'y a pas de cerf, vous pouvez survivre pendant un certain temps.

Pour commencer, disons qu'il peut y avoir un loup à chaque mouvement, mais si en deux mouvements ce n'était pas possible - du côté de l'évolution.

Avec la multiplication de plus d'options.

Pour commencer - nous supprimons la délicatesse, laissons les loups se multiplier toujours quand il y a de l'espace libre.

Et ajoutez une restriction - les loups affamés ne se reproduisent pas.

Première crêpe

Laissez le cerf se multiplier un peu et jetez le loup dans la foule: le

modèle s'est avéré, pour le dire doucement, instable - les loups ont fauché instantanément tous les cerfs et se sont rapidement éteints.

Une frustration, pas zen.

Deuxième essai

Quelque chose doit être changé.

Cela fait mal à l'œil à quel point les loups se reproduisent.

Compliquons un peu leur vie - nous posons la condition qu'il n'est possible de se reproduire que s'il y a plus de cerfs que de loups sur les cellules voisines.

    var preys = spots.map(p => this.GM.get(p)).filter(u => u && u.kind == Wilds.DEER)
    var preds = spots.map(p => this.GM.get(p)).filter(u => u && u.kind == Wilds.WOLF)
    if (preys.length <= preds.length)
      return false

Et abandonner les loups lorsque la population de cerfs atteint son maximum.

Cette tentative réussit beaucoup mieux.

L'équilibre des prédateurs et des victimes est en constante évolution, la population de cerfs a considérablement diminué et maintenant, elle ne s'approche même pas de son maximum.

Cependant, tout peut arriver, et presque à chaque fois que les loups parviennent à s'éteindre, et les cerfs remplissent à nouveau triomphalement le fourré.

Dans cette course, les loups ont duré longtemps:

Troisième cercle

Nous devrons resserrer encore plus les noix de reproduction.

Nous énonçons maintenant la condition: il doit y avoir des cerfs à proximité, mais il ne doit pas y avoir de loups.
Ces loups doux ne tolèrent pas la compétition.

Le système est plus stable.

Par rapport au graphique précédent, les pics sont lissés par les cerfs et les loups.

En général, il est clair où aller pour obtenir le même calendrier fluide que sur Wikipedia.
En conséquence, nous arrivons à une conclusion banale - nous devons nous reproduire consciemment, et pas au maximum.
Cela ressemble à une publicité pour l'hédonisme, mais vous pouvez réduire davantage la fertilité des loups dans l'espoir "d'améliorer la qualité et la durée de leur vie" ...

Déploiement

En tant qu'épilogue, instructions de déploiement.

Il est très court:

1. Nous écrivons un simple fichier docker:

FROM node:14
ADD https://github.com/tprlab/predator-prey/archive/master.zip /
RUN unzip /master.zip
WORKDIR /predator-prey-master
RUN npm install
EXPOSE 8081
CMD ["node", "server.js"]

2. build docker. -t predator-proies

3. docker run -p 8081: 8081 predator-proies

Pour les plus paresseux, j'ai collecté et téléchargé l'image sur le Docker Hub.

Si vous ne voulez pas jouer avec le docker, il y a une instruction d'installation à partir de zéro sur la page de dépôt (lien ci-dessous).

Modèle Predator-Prey sur Node.js