[PYTHON] Explication et mise en œuvre de SocialFoceModel

Je vais expliquer le modèle de mise au point sociale, qui est un type de méthode de potentiel artificiel. Il s'agit d'un modèle de comportement des foules humaines basé sur la dynamique préconisée par Helbing.

Cliquez ici pour le papier original https://arxiv.org/pdf/cond-mat/9805244.pdf

Fondamentalement, il est exprimé comme la somme de la force d'attraction et de la force de répulsion comme indiqué ci-dessous.


F_{all} = F_{gall} + F_{others} + F_{obstacle}

Attraction

Voici la formule de la force attractive qui opère entre le piéton et le but.


F_{all} =\frac{V_0e_t-v_t}{\tau}

$ V_0: Vitesse maximale $ $ e_t: Vecteur unitaire dans la direction du but $ $ \ tau: Temps pour atteindre V_0 (constante de temps) $ $ v_t: Vecteur de vitesse actuel $







force répulsive

Voici la formule de la force répulsive qui agit entre les obstacles et les autres piétons et les piétons. Les formules utilisées sont les mêmes.


F_{others}  = F_{obstacle} =  v_rUe^{-\frac{d}{R}}

$ d: Distance aux obstacles et autres piétons (hors rayon) $ $ R, U: constante $ $ v_r: Direction depuis l'obstacle (vecteur unitaire) $

Les paramètres définis par l'auteur Helbing sont

V_0:1.34 [m/s] \tau:0.5 [s] R:10.0[m^2/s^2] U:0.2[m]

Il est devenu.

la mise en oeuvre

A partir de cette formule et de ces paramètres, je souhaite afficher la trajectoire lorsqu'un piéton évite un obstacle.

Normalement, nous devons considérer les obstacles et le rayon des piétons, mais par souci de simplicité, nous l'avons omis.

# coding: utf-8
import numpy as np
import matplotlib.pyplot as plt

V0  = 1.34 # [m/s] Speed of equilibrium (= max speed)
tau = 0.5  # [sec] Time to reach V0 ziteisuu
delta_sec = 0.01 #[sec]

U = 10.0 # [m^2/s^2]
R = 0.2  # [m]

user_mass_kg = 55 # [kg]
user_mass_N = user_mass_kg / 9.8 # [N]

user_pos = np.array([0.0, 0.0]) # 0=x, 1=y[m]
user_vel = np.array([0.3, 0.0]) # 0=x, 1=y[m/s]
map_size = np.array([10, 10]) # 0=x, 1=y[m]
goal_pos = np.array([10, 5]) # 0=x, 1=y[m]
obstacle_pos = np.array([6, 3]) # 0=x, 1=y[m]

user_pos_lines = user_pos.reshape((2,1))


while True:
	#Attraction
	dist_xy = goal_pos - user_pos
	dist_norm = np.linalg.norm(dist_xy, ord=1)
	e = dist_xy / dist_norm
	F_goal = (V0 * e - user_vel) / tau # [N]
	
	#force répulsive
	dist_xy = user_pos - obstacle_pos
	dist_norm = np.linalg.norm(dist_xy, ord=2)
	v_r = dist_xy / dist_norm
	F_obstacle = v_r * U * np.exp((-1) * dist_norm / R)
	
	#Calcul de la position des piétons
	F_all = F_goal + F_obstacle # [N]
	#accélération[m/s^2]
	user_acc = F_all / user_mass_N
	#la vitesse[m/s]
	user_vel += user_acc * delta_sec
	#position
	user_pos += user_vel * delta_sec
	
	#La distance entre le piéton et le but est de 0.Terminer quand il fait moins de 2m
	if np.linalg.norm(goal_pos - user_pos) < 0.2:
		break
	user_pos_lines = np.append(user_pos_lines, user_pos.reshape((2,1)), axis=1)


#dessin
#Obstacle
plt.scatter(obstacle_pos[0], obstacle_pos[1], color='b', s=100)
#Trajectoire
plt.plot(user_pos_lines[0,:], user_pos_lines[1,:], color='r')
#objectif
plt.scatter(goal_pos[0], goal_pos[1], color='g', s=200)
plt.show()

print("end")

Résultat d'exécution

De cette façon, j'ai pu créer une trajectoire pour éviter les obstacles en me dirigeant vers le but.

Figure_1.png

Recommended Posts

Explication et mise en œuvre de SocialFoceModel
Explication et mise en œuvre de PRML Chapitre 4
Explication et implémentation de l'algorithme ESIM
Explication et mise en œuvre du perceptron simple
Explication et implémentation de l'algorithme Decomposable Attention
Explication de la distance d'édition et de l'implémentation en Python
Introduction et mise en œuvre de JoCoR-Loss (CVPR2020)
Explication du CSV et exemple d'implémentation dans chaque langage de programmation
Mise en œuvre et expérience de la méthode de clustering convexe
Explication mathématique de la recherche de dichotomie et de trisection et méthode de mise en œuvre sans bogues
Implémentation et description à l'aide de XGBoost pour les débutants
Explication et implémentation du protocole XMPP utilisé dans Slack, HipChat et IRC
Comparaison d'exemples d'implémentation de k-means de scikit-learn et pyclustering
Implémentation de l'arbre TRIE avec Python et LOUDS
Implémentation de la séquence de Fibonacci
Principes de base et mise en œuvre de Perceptron
Python - Explication et résumé de l'utilisation des 24 meilleurs packages
Mise à jour séquentielle de la co-distribution pour la dérivation et l'implémentation des expressions
J'ai touché Bergeronnette (3). Enquête et mise en place de messages pop-up.
Implémentation de l'écran de l'administrateur DB par Flask-Admin et Flask-Login
Explication des outils et commandes de package pour le système d'exploitation Linux
Implémentation Python du mode de fusion CSS3 et discussion sur l'espace colorimétrique
Le problème des menteurs et de l'honnêteté
Dérivation et implémentation d'équations de mise à jour pour la décomposition de facteurs tensoriels non négatifs
Mécanisme de pyenv et virtualenv
Implémentation de TF-IDF à l'aide de gensim
Implémentation de MathJax sur Sphinx
Pré-traitement et post-traitement de pytest
Combinaison de récursif et de générateur
Combinaison de anyenv et direnv
Normalisation de la théorie et de la mise en œuvre des flux
Mise en œuvre de la théorie des jeux - Le dilemme du prisonnier -
Différenciation du tri et généralisation du tri
Mise en œuvre d'une analyse de composants indépendante
Coexistence de pyenv et autojump
Implémentation informatique quantique de Quantum Walk 3
[Avec une explication simple] Implémentation Scratch d'une machine Boltsman profonde avec Python ②
Implémentation Python du filtre à particules
[Avec une explication simple] Implémentation Scratch d'une machine Boltzmann profonde avec Python ①
Utilisation et intégration de "Shodan"
Le problème des menteurs et de l'honnêteté
Théorie et mise en œuvre de modèles de régression multiple - pourquoi une régularisation est nécessaire -
Vérification et mise en œuvre de la méthode de reconstruction vidéo en utilisant GRU et Autoencoder
Description et implémentation de Maxout (Python)
Occurrence et résolution de tensorflow.python.framework.errors_impl.FailedPreconditionError
Implémentation du tri rapide en Python
Comparaison d'Apex et de Lamvery
Installation source et installation de Python
Implémentation informatique quantique de Quantum Walk 1
Apprentissage par renforcement profond 2 Mise en œuvre de l'apprentissage par renforcement
Implémentation de Scale-Space pour SIFT
Introduction et astuces de mlflow.
Exploration avec Python et Twitter API 2-Implémentation de la fonction de recherche d'utilisateurs
[Python] J'ai expliqué en détail la théorie et la mise en œuvre de la régression logistique
[Python] J'ai expliqué en détail la théorie et la mise en œuvre de l'arbre de décision
[Python] Implémentation de la méthode Nelder – Mead et sauvegarde des images GIF par matplotlib
Implémentation de l'action de sélecteur Datetime à l'aide de line-bot-sdk-python et exemple d'implémentation du carrousel d'images
[Recommandation] Résumé des avantages et des inconvénients de la méthode de filtrage / mise en œuvre basée sur le contenu et coopérative
Construction d'environnement de python et opencv