import numpy as np
import matplotlib.pyplot as plt


#decide the direction to move by Q table and random probability epsilon
#and convert it as movement on the map.
def decide_action(status, maze_row, q_table, maze_map, epsilon):
    
    direction=["up", "right", "down", "left"]
    if(np.random.rand() < epsilon):
        #at random choice
        direction_to=np.random.choice(direction, p=maze_map[status])
    else:
        #direction is selected at max Q value direction
        direction_to=direction[np.nanargmax(q_table[status])]
        
        
    #convert direction to map information at matrix
    if(direction_to=="up"):
        status=status-maze_row
        action=0
    elif(direction_to=="right"):
        status=status+1
        action=1
    elif(direction_to=="down"):
        status=status+maze_row
        action=2
    elif(direction_to=="left"):
        status=status-1
        action=3
        
    return status, action


#q_learning function to update the Q_value
def q_learning(status, action, next_status, goal, q_table, alfa, gamma, reward):
    
    #setting of reward
    if(next_status==goal):
        r=reward
    else:
        r=0
        
    #update fomula of Q_value
    q_table[status][action]+=alfa*(r+gamma*(np.nanmax(q_table[next_status])-q_table[status][action]))
    
    return q_table


#solve and update the maze at once
def goal_once(start, goal, maze_row, maze_map, q_table, alfa, gamma, reward, epsilon):
    
    flag=True
    history_move=[]
    
    #initialize
    status=start
    
    #solve maze until it gets the goal
    while(flag):
        
        next_status, action=decide_action(status, maze_row, q_table, maze_map, epsilon)
        q_table=q_learning(status, action, next_status, goal, q_table, alfa, gamma, reward)
        
        #record the history of action
        history_move.append([status, action])
        
        #flag of goal
        if(next_status==goal):flag=False
        
        #status update
        status=next_status
    
    return q_table, history_move



move_0=np.array([0, 0, 0, 0])
move_w=np.array([1, 0, 0, 0])
move_d=np.array([0, 1, 0, 0])
move_s=np.array([0, 0, 1, 0])
move_a=np.array([1, 0, 0, 1])
move_wd=np.array([1, 1, 0, 0])/2
move_ws=np.array([1, 0, 1, 0])/2
move_wa=np.array([1, 0, 0, 1])/2
move_ds=np.array([0, 1, 1, 0])/2
move_da=np.array([0, 1, 0, 1])/2
move_sa=np.array([0, 0, 1, 1])/2
move_wds=np.array([1, 1, 1, 0])/3
move_wda=np.array([1, 1, 0, 1])/3
move_wsa=np.array([1, 0, 1, 1])/3
move_dsa=np.array([0, 1, 1, 1])/3
move_wdsa=np.array([1, 1, 1, 1])/4


###input form###

maze_map=np.array([move_ds, move_dsa, move_dsa, move_dsa, move_sa, \
                   move_wds, move_wdsa, move_wdsa, move_wdsa, move_wsa,\
                   move_wds, move_wdsa, move_wdsa, move_wdsa, move_wsa,\
                   move_wd, move_wda, move_wda, move_wda, move_wa])

q_table=np.where(maze_map==0.0, np.nan, 0)

maze_row=5
maze_columns=4

start=0
goal=19
reward=1
time_of_episode=100
alfa = 0.10  #Taux d'apprentissage
gamma = 0.92 #Taux d'actualisation du temps
epsilon = 0.99  # ε-Valeur initiale de la méthode gourmande
probability_reduce_rate=1.04

###input form end###



history_move=[]
size_of_epi=[]
episode = 1



flag=True
while(flag):
    q_table, history_move=goal_once(start, goal, maze_row, maze_map, q_table, alfa, gamma, reward, epsilon)
    print("this is episode: {0:5d}, steps to goal are {1:5d}".format(episode, len(history_move)))
    size_of_epi.append(len(history_move))
    if(time_of_episode==episode):
        flag=False
        episode=episode-1
    episode+=1
    epsilon=epsilon/probability_reduce_rate
    q_table=q_table/np.nanmax(q_table)
    
direcion=["↑", "→", "↓", "←"]
for i in range(len(history_move)):
    print(direcion[history_move[i][1]])
    
plt.plot(size_of_epi)
plt.show()



q_table[goal]=1.0

np.set_printoptions(suppress=True, precision=4, floatmode='maxprec')
#print(maze_map)
print(q_table)


q_table_max=np.zeros(goal+1)
for i in range(len(q_table)):
    q_table_max[i]=np.nanmax(q_table[i])
        
print(q_table_max.reshape(maze_columns, maze_row))

q_table_max=q_table_max.reshape(maze_columns, maze_row)

plt.figure(figsize=(10, 5))
plt.imshow(q_table_max, interpolation='nearest', vmin=0 ,cmap='YlOrRd')
plt.colorbar()
plt.show()

Les résultats du calcul sont indiqués ci-dessous, et on peut voir que la valeur de l'action est transmise très clairement dans le labyrinthe qui se termine du haut à gauche vers le bas à droite, et la route vers l'objectif est tracée.

Feu simulé

Étendons cela pour simuler l'apprentissage du comportement d'évacuation en cas d'incendie. Ici, le modèle ne met qu'une récompense sur Goal, mais comme une simple extension, nous allons préparer une masse qui ressemble à un feu et donner une récompense négative lorsque nous y arriverons. De plus, si vous atteignez une case avec une récompense négative, le jeu se terminera d'un set. En d'autres termes, l'agent part de Start sans aucune connaissance et vise Goal tout en retournant à la mort plusieurs fois.

résultat

Ce qui précède est le résultat du calcul, mais des résultats assez intéressants ont été obtenus. Regardons à nouveau la formule de mise à jour de l'apprentissage Q.

La valeur d'action de chaque mesure de chaque carré est mise à jour en fonction de la formule ci-dessus, mais dans la formule ci-dessus, toutes les mises à jour reflètent la valeur maximale de la destination de l'action, donc même si une récompense négative est donnée, l'environnement Sauf pour 1 cellule, elle sera ignorée par la fonction Max. La formule de mise à jour ci-dessus Q-learning est une formule de valeur comportementale optimiste, donc simplement, elle prend le meilleur chemin même s'il y a une grande récompense négative à côté. Même si la flamme brûle à côté, si c'est le chemin le plus court, il sera calculé pour y passer.

Mise à jour pessimiste

Considérons maintenant un agent légèrement pessimiste. Étant donné un paramètre appelé pessimisme,

Modifiez l'équation ci-dessus comme l'équation suivante. En d'autres termes, il est modifié pour que la valeur minimale de la valeur d'action de la destination d'action soit estimée à un certain rythme. Si pessimisme = 0, ce sera la même chose que la formule de mise à jour originale, et si pessimisme → ∞, ce sera un programme qui évalue et apprend uniquement la valeur la plus basse de la valeur d'action de chaque carré. En particulier,

q_learning

#q_learning function to update the Q_value
def q_learning(status, action, next_status, goal, q_table, alfa, gamma, reward, pesimism):
    
    r=0
    
    #setting of reward
    for i in range(len(goal)):
        if(next_status==goal[i]):
            r=reward[i]
        
    #update fomula of Q_value
    q_table[status][action]+=alfa*(r+gamma*(np.nanmax(q_table[next_status])-q_table[status][action]))
    
    
    return q_table

La fonction de la pièce correspondante

q_learning

#q_learning function to update the Q_value
def q_learning(status, action, next_status, goal, q_table, alfa, gamma, reward, pesimism):
    
    r=0
    
    #setting of reward
    for i in range(len(goal)):
        if(next_status==goal[i]):
            r=reward[i]
        
    #update fomula of Q_value
    q_table[status][action]+=alfa*(r+gamma*(np.nanmax(q_table[next_status])/(1+pesimism)\
           +np.nanmin(q_table[next_status])*pesimism/(1+pesimism)-q_table[status][action]))
    
    
    return q_table

Réécrivez en. Quand j'essaye de calculer avec ça.

On constate que l'itinéraire est choisi de manière à éviter correctement l'emplacement de l'incendie.

Carte des valeurs d'action (potentiel) d'un labyrinthe de taille moyenne

Sur la base des résultats ci-dessus, avec l'échelle du labyrinthe encore élargie, apprenez l'itinéraire de chaque carré du labyrinthe à l'objectif, et faites la moyenne de la valeur d'action obtenue à partir de celui-ci, et chauffez de l'ensemble du labyrinthe à l'objectif J'ai fait une carte. Bien que la carte thermique elle-même n'ait pas de signification essentielle, elle est considérée comme utile pour montrer clairement le degré de risque en cas d'incendie et le type de changement dans le choix de l'itinéraire.

Le but est le centre de la partie supérieure.

Pas de feu:

Il y a un feu:

On peut voir que si un incendie se produit sur le côté droit du sol, la valeur d'action de l'espace sur le côté droit diminuera considérablement. En revanche, on constate que le passage du côté gauche des deux voies au centre inférieur est plus valorisé et préféré. Même lorsque le feu était considéré comme une seule masse de récompense négative, les résultats étaient assez intéressants.

problème

Bien qu'il ait été déclaré comme une recherche indépendante au début, il y a les problèmes suivants que cela n'est pas encore devenu une forme concrète.

Multi-agent

Il est nécessaire de résoudre des tâches multi-agents, sans parler du flux de personnes en cas d'incendie. Aussi, comme caractéristique du comportement d'évacuation réel

1. Les évacués suivent les chefs (personnel compétent). (Cela peut être considéré comme un partage de la fonction de valeur d'action)
2. Les panneaux d'information et les conseils d'évacuation ont un certain effet. (Il est nécessaire de définir des récompenses et des mesures pour des cases spécifiques)
3. La congestion se produit près de la sortie et la mobilité des personnes diminue. (Bien sûr, il sera retardé pour s'échapper, il est donc nécessaire de définir la récompense pour qu'elle soit progressivement réduite pour ceux qui s'échappent plus tard)

Il est nécessaire d'étudier après avoir pris en compte les caractéristiques d'un tel comportement d'évacuation réel. Par rapport à cela, ce programme se termine par une amélioration de l'apprentissage Q.

Incorporation des caractéristiques du feu

Dans le comportement d'évacuation lors d'un incendie, l'incendie lui-même change considérablement avec le temps. Le facteur le plus important dans le comportement d'évacuation est la fumée. On dit que la vitesse de déplacement latéral de la fumée correspond à la vitesse de marche des humains, mais il est nécessaire d'examiner plus en détail les caractéristiques de diffusion, de vitesse de déplacement et de direction. Il est considéré comme un algorithme efficace pour développer la zone de récompense négative avec le temps de chaque tour, mais dans l'expérience réelle du comportement d'évacuation du feu, la fumée du feu obstrue la vue humaine, ralentit la vitesse de marche, etc. Cela a été souligné, et il n'est pas clair si l'effet ne peut être exprimé que par des récompenses négatives.

Le dilemme du comportement d'évacuation humaine

Comme mentionné précédemment, le comportement d'évacuation humaine comprend un comportement caractéristique observé à partir d'expériences. Il est également connu pour suivre les dirigeants influents et le comportement de la foule pour suivre les gens pour le moment. Un tel comportement peut se produire même si la sortie est étroite et qu'il est plus efficace d'aller vers une autre sortie. Le problème est que le chemin optimal appris par l'apprentissage par renforcement n'est pas toujours optimal lorsque l'on considère l'irrationalité et l'instinct des êtres humains. Alors que certaines personnes sont paniquées, le plus gros problème est de savoir dans quelle mesure le comportement irrationnel peut être inclus dans la récompense et s'il est optimal pour le comportement humain.

Perspective

Après tout, je pense qu'il serait intéressant que le calcul puisse être traité à grande vitesse côté serveur et que l'itinéraire d'évacuation optimal puisse être présenté à chaque évacué. Par rapport à la méthode d'automate cellulaire existante, il existe peu d'algorithmes dépendant de l'environnement, ce qui semble être efficace pour l'extensibilité ici. A-t-il déjà été mis en pratique dans ce domaine, comme le transport urbain et les transferts de gare?

Je vous serais reconnaissant si vous pouviez me faire savoir si vous avez de la documentation utile.

Conclusion

• Puisqu'il existe de nombreuses références, je les omettrai. Merci de me faire savoir si vous êtes intéressé par les références