Cette page a été traduite par traduction automatique. Cliquez ici pour voir la dernière version en anglais.

mpnetSE2

Réseaux de planification de mouvement

Depuis R2023b

Description

L'objet mpnetSE2 stocke les réseaux de planification de mouvement (MPNet) à utiliser pour l'échantillonnage de l'espace d'état. MPNet est une approche basée sur l'apprentissage en profondeur qui utilise des réseaux de neurones pour effectuer un échantillonnage éclairé. MPNet utilise des connaissances préalables pour trouver des échantillons d'état optimaux pour la planification de mouvements à l'aide de différents planificateurs. Grâce à cet objet, vous pouvez :

• Chargez un MPNet pré-entraîné et utilisez-le pour l'échantillonnage de l'espace d'état.

• Configurez un MPNet non entraîné pour s'entraîner sur un nouvel ensemble de données. Ensuite, utilisez le MPNet formé pour l’échantillonnage de l’espace d’état.

Utilisez la fonction predict de l'objet mpnetSE2 pour prédire des échantillons d'état entre une pose de départ et une pose d'objectif dans un environnement d'entrée connu ou inconnu. Utilisez la fonction loss de l'objet mpnetSE2 pour calculer les pertes lors de la formation du réseau.

Création

Syntaxe

mpnet = mpnetSE2

mpnet = mpnetSE2(Name=Value)

Description

mpnet = mpnetSE2 renvoie un MPNet non entraîné à entraîner et à utiliser pour échantillonner l'espace d'état SE(2). Vous pouvez entraîner ce réseau sur un ensemble de données en utilisant la fonction trainnet (Deep Learning Toolbox) .

mpnet = mpnetSE2(Name=Value) spécifie les propriétés en utilisant un ou plusieurs arguments nom-valeur. Vous pouvez spécifier les propriétés Network, StateBounds, LossWeights et EncodingSize comme arguments nom-valeur. .

Utilisez la propriété Network pour stocker un réseau neuronal profond que vous pouvez utiliser pour rechercher des échantillons d'espace d'état dans un environnement inconnu ou connu. Vous pouvez ensuite utiliser les échantillons sélectionnés pour la planification de mouvements à l'aide de différents planificateurs de trajectoire.

Remarque

Pour exécuter cette fonction, vous aurez besoin du Deep Learning Toolbox™.

Propriétés

Network — MPNet pré-entraîné ou non

dlnetwork objet | LayerGraph objet

MPNet pré-entraîné ou non, spécifié comme objet dlnetwork (Deep Learning Toolbox) ou layerGraph (Deep Learning Toolbox) . Par défaut, cette propriété contient un MPNet non entraîné.

StateBounds — Limites des variables de l'espace d'état SE (2)

[-100 100; -100 100; -pi pi] (par défaut) | Matrice 3x2 de valeurs réelles

Limites des variables de l'espace d'état SE(2), spécifiées sous la forme d'une matrice 3 x 2 de valeurs réelles.

• La première ligne spécifie les limites inférieure et supérieure de la variable d'état x en mètres.

• La deuxième ligne spécifie les limites inférieure et supérieure de la variable d'état y en mètres.

• La troisième ligne spécifie les limites inférieure et supérieure de la variable d'état θ en radians.

Types de données : double

LossWeights — Pondérations des fonctions de perte

[1 1 1] (par défaut) | vecteur à trois éléments de valeurs positives réelles

Pondérations des fonctions de perte, spécifiées comme un vecteur à trois éléments de valeurs positives réelles pour chaque variable d'état, x, y et θ, de l'espace d'état SE(2).

La perte de formation pour MPNet est la distance quadratique moyenne pondérée entre les états prédits et les états réels. Les poids de la fonction de perte spécifient la valeur de poids pour chaque variable de l'espace d'état lors du calcul de la perte.

Types de données : single | double

EncodingSize — Taille de l'environnement codé

[10 10] (par défaut) | vecteur à deux éléments d'entiers non négatifs | scalaire non négatif

Taille de l'environnement codé, spécifiée sous la forme d'un vecteur à deux éléments d'entiers non négatifs ou d'un scalaire non négatif.

• S'ils sont spécifiés comme vecteur, les éléments du vecteur spécifient la taille de l'environnement codé dans les directions x et y .

• S'il est spécifié comme scalaire, l'objet utilise la valeur spécifiée pour les directions x et y .

L'environnement codé est une représentation compacte des cartes d'entrée. La fonction code les cartes d'entrée à l'aide de l'approche de codage Basis Point Set (BPS) présentée dans [1]. EncodingSize spécifie le nombre de points de base à utiliser pour la représentation compacte des cartes d'entrée.

Par exemple, si N_sv est le nombre de variables d'état définissant l'espace d'état d'entrée et [E_x E_y] est la taille de l'environnement codé, alors la taille de l'environnement codé et le nombre d'entrées au MPNet doit satisfaire cette équation :

NumInputs = 2×(N_sv+1) + (Ex×Ey)

.

Si vous entraînez MPNet sur un seul environnement de carte, il n'est pas nécessaire d'encoder la carte. Parce que l’encodage d’un environnement n’affectera pas les prédictions du réseau. Par conséquent, vous pouvez définir la valeur EncodingSize sur 0.

Types de données : single | double

NumInputs — Nombre d'entrées

108 (par défaut) | entier positif

Ce propriété est en lecture seule.

Nombre d'entrées au MPNet, stocké sous forme d'entier positif. La valeur par défaut est 108.

Le nombre d'entrées dans le réseau est déterminé par la somme de la taille de l'environnement codé et du nombre de variables de l'espace d'état représentant à la fois l'état actuel et l'état objectif. L'état actuel et l'état objectif sont fournis en tant qu'entrées au réseau sous la forme de x, y, cosθ et sinθ. Par conséquent, le nombre de variables de l'espace d'état donné en entrée au réseau est 8. La taille par défaut de l'environnement codé est de 10 x 10. Par conséquent, le nombre par défaut d'entrées sur le réseau est (10×10)+8 = 108.

Si la taille de l'environnement codé est spécifiée comme 0, le nombre d'entrées sur le réseau est 8.

Types de données : double

NumOutputs — Nombre de sorties

4 (par défaut)

Ce propriété est en lecture seule.

Nombre de sorties du MPNet, stockées sous 4. Le réseau génère des variables d'espace d'état, x, y, cosθ et sinθ, qui représentent le prochain état prévu.

Types de données : double

Fonctions d'objet

predict	Predict state samples using MPNet
loss	Calculer la perte entre les états prédits et les états réels
copy	Create deep copy of mpnetSE2 object

Exemples

Former MPNet sur un environnement à carte unique

Entraînez un réseau de planification de mouvement (MPNet), sur un environnement de carte unique, pour l'échantillonnage de l'espace d'état. Dans le cas d'un environnement à carte unique, vous utilisez une carte fixe pour former et tester le réseau. Ensuite, vous pouvez utiliser le réseau entraîné pour calculer des échantillons d'état entre n'importe quelle pose de départ et n'importe quelle pose d'objectif sur la carte. Tout d'abord, vous devez configurer un MPNet et former le réseau sur un petit ensemble de données. Utilisez la perte de formation pour évaluer la précision du réseau. Si vous entraînez le MPNet sur un vaste ensemble de données d'entraînement créé à l'aide de plusieurs environnements cartographiques, vous devez également calculer la perte de validation pour affiner la précision du réseau. Pour plus d'informations sur la façon de former le MPNet sur plusieurs environnements cartographiques pour l'échantillonnage de l'espace d'état, voir Train Deep Learning-Based Sampler for Motion Planning.

Charger et inspecter les données de formation

Chargez la carte d'entrée et les données d'entraînement dans l'espace de travail MATLAB® .

data = load("singleTrainData.mat","trainData","map")

data = struct with fields:
    trainData: {100×1 cell}
          map: [1×1 binaryOccupancyMap]

map = data.map;

Les données d'entraînement sont constituées d'échantillons d'état optimaux calculés pour plusieurs valeurs aléatoires de poses de départ et de poses d'objectif sur une carte de labyrinthe. Extrayez les données de formation de la structure de données.

trainData = data.trainData;

Inspectez les données d’entraînement. Les données de formation sont un cell array de taille 100 x 1 contenant 100 échantillons d'état à utiliser pour la formation du réseau.

size(trainData)

ans = 1×2

   100     1

Lisez les échantillons d'état à partir des données d'entraînement. Tracez la carte d'entrée et les échantillons d'état d'entraînement.

figure
show(map)
hold on
for n = 1:100
    pathSample = trainData{n};
    plot(pathSample(:,1),pathSample(:,2),plannerLineSpec.state{:})
end
hold off

Créer MPNet et définir les paramètres réseau

Créez un MPNet non entraîné à l'aide de l'objet mpnetSE2 .

mpnet = mpnetSE2

mpnet = 
  mpnetSE2 with properties:

     StateBounds: [3×2 double]
     LossWeights: [1 1 1]
    EncodingSize: [10 10]
       NumInputs: 108
      NumOutputs: 4
         Network: [1×1 dlnetwork]

Visualisez le réseau. Pour mieux comprendre l'architecture du réseau, inspectez les couches du réseau et le nombre d'entrées dans chaque couche.

analyzeNetwork(mpnet.Network)

Définissez la propriété StateBounds de l'objet mpnetSE2 sur les limites de la carte d'entrée.

x = map.XWorldLimits;
y = map.YWorldLimits;
theta = [-pi pi];
stateBounds = [x; y; theta];
mpnet.StateBounds = stateBounds;

Définissez la propriété EncodingSize de l'objet mpnetSE2 sur 0. Cela indique que la fonction ne doit pas coder la carte d'entrée pour entraîner le réseau. La définition de la propriété EncodingSize sur 0 modifie la propriété NumInputs du MPNet en 8.

mpnet.EncodingSize = 0

mpnet = 
  mpnetSE2 with properties:

     StateBounds: [3×2 double]
     LossWeights: [1 1 1]
    EncodingSize: [0 0]
       NumInputs: 8
      NumOutputs: 4
         Network: [1×1 dlnetwork]

Définissez la propriété LossWeights de l'objet mpnetSE2 sur [10 10 0]. Pour des valeurs de poids plus élevées, le réseau prend plus d’époques pour converger. Si l'entrée est un espace d'état SE(2), la valeur de poids pour la variable de l'espace d'état$\theta$est défini sur 0.

mpnet.LossWeights = [10 10 0];

Préparer les données de formation

Préparez les données de formation en convertissant les échantillons dans un format requis pour la formation du MPNet. La fonction mpnetPrepareData redimensionne les valeurs des états de chemin optimaux dans la plage [0, 1] et les stocke en tant qu'objet datastore à utiliser avec la fonction d'entraînement.

dsTrain = mpnetPrepareData(trainData,mpnet);

Former MPNet

Créez un objet trainingOptions pour la formation du MPNet. Ces options de formation ont été choisies expérimentalement. Si vous utilisez un nouvel ensemble de données pour l'entraînement, vous devez modifier vos options d'entraînement pour obtenir la précision d'entraînement souhaitée.

• Utilisez l'optimiseur Adam.

• Définissez la taille des mini-lots d’entraînement sur 20.

• Mélangez la datastore de formation à chaque époque.

• Définissez le nombre maximum d'époques sur 50.

options = trainingOptions("adam", ...
    MiniBatchSize=20, ...
    MaxEpochs=50, ...
    Shuffle="every-epoch", ...
    Plots="training-progress", ...   
    VerboseFrequency=500);

Entraînez le MPNet en utilisant la fonction trainnet . Spécifiez la fonction de perte et les options de formation comme entrées dans la fonction de formation. Pour des résultats optimaux, la perte d’entraînement doit converger vers zéro.

[net,info] = trainnet(dsTrain,mpnet.Network,@mpnet.loss,options);

    Iteration    Epoch    TimeElapsed    LearnRate    TrainingLoss
    _________    _____    ___________    _________    ____________
            1        1       00:00:02        0.001          6.2466
          500        6       00:00:24        0.001        0.042451
         1000       12       00:00:38        0.001        0.073534
         1500       17       00:00:52        0.001        0.038856
         2000       23       00:01:04        0.001        0.041173
         2500       29       00:01:16        0.001        0.021427
         3000       34       00:01:28        0.001        0.044795
         3500       40       00:01:39        0.001        0.030961
         4000       45       00:01:50        0.001        0.028537
         4450       50       00:02:01        0.001        0.017648
Training stopped: Max epochs completed

Définissez la propriété Network de l'objet mpnetSE2 sur le réseau entraîné.

mpnet.Network = net; 

Effectuer un échantillonnage de l'espace d'état à l'aide de MPNet formé

Spécifiez une pose de départ et une pose objectif pour lesquelles calculer des échantillons d’état.

start= [2 2 0];
goal= [9 6 0];

Créez un objet d'espace d'état pour les limites d'état spécifiées.

stateSpace = stateSpaceSE2(stateBounds);

Configurez l'objet stateSamplerMPNet pour utiliser le MPNet formé pour l'échantillonnage de l'espace d'état. Transmettez l’environnement de la carte, l’état de départ et l’état objectif comme entrées à l’échantillonneur d’état. Définissez les limites du nombre maximum d’échantillons appris à prendre en compte à 50.

stateSamplerDL = stateSamplerMPNET(stateSpace,mpnet,Environment=map,StartState=start,GoalState=goal,MaxLearnedSamples=50);

Générez 50 échantillons d’état entre le début et la pose d’objectif.

samples = sample(stateSamplerDL,50);

Tracez les échantillons d'état générés. Notez que les échantillons d'état générés sont concentrés entre les états de départ et d'objectif, et ne sont pas dispersés dans l'environnement de la carte. Vous pouvez réduire le temps de recherche et trouver rapidement les chemins optimaux en utilisant ces échantillons d’état comme bases pour la planification des mouvements.

figure
show(map)
hold on
plot(samples(:,1),samples(:,2),plannerLineSpec.state{:})
plot(start(1),start(2),plannerLineSpec.start{:})
plot(goal(1),goal(2),plannerLineSpec.goal{:})
legend(Location="eastoutside")

Plus d'information

Vous pouvez également enregistrer le MPNet formé dans un fichier .mat pour une utilisation ultérieure. Enregistrez le réseau formé, les poids de perte et d'autres paramètres de réseau dans le fichier .mat . Pour plus d'informations sur l'utilisation d'un réseau pré-entraîné pour l'échantillonnage de l'espace d'état, voir Predict State Samples Using MPNet Trained on Single Environment.

networkInput = mpnet.NumInputs;
networkOutput = mpnet.NumOutputs;
networkLossWeights = mpnet.LossWeights;
save("trainSingleMap.mat","net","map","networkInput","networkOutput","networkLossWeights");

Exemple d'espace d'état SE(2) à l'aide de MPNet pré-entraîné

Chargez un fichier de données contenant un MPNet pré-entraîné dans l'espace de travail MATLAB . Le MPNet a été formé sur des cartes de labyrinthe 2D générées aléatoirement avec des largeurs et des hauteurs de 10 mètres et une résolution de 2,5 cellules par mètre. Les cartes de labyrinthe contiennent une largeur de passage de 5 cellules de grille et une épaisseur de paroi de 1 cellule de grille.

data = load("mazeMapTrainedMPNET.mat")

data = struct with fields:
      encodingSize: [9 9]
       lossWeights: [100 100 0]
        mazeParams: {[5]  [1]  'MapSize'  [10 10]  'MapResolution'  [2.5000]}
       stateBounds: [3x2 double]
    trainedNetwork: [1x1 dlnetwork]

Créez une carte de labyrinthe aléatoire à utiliser pour la planification des mouvements. La taille de la grille ($\mathrm{MapResolution}\times \mathrm{MapSize}$) doit être la même que celle des cartes utilisées pour la formation du MPNet.

rng(50,"twister")
map = mapMaze(5,1,MapSize=[20 20],MapResolution=1.25);

Spécifiez la pose de départ et la pose d'objectif.

start = [2 8 0];
goal = [18 18 0];

Spécifiez les limites d'état et créez un objet d'espace d'état SE(2).

x = map.XWorldLimits;
y =  map.YWorldLimits;
theta = [-pi pi];
stateBounds = [x; y; theta];
stateSpace = stateSpaceSE2(stateBounds);

Configurez l'objet mpnetSE2 pour utiliser le MPNet pré-entraîné pour prédire des échantillons d'état sur une carte aléatoire. Définissez les valeurs de propriété EncodingSize de l'objet mpnetSE2 sur les valeurs utilisées pour la formation du réseau.

mpnet = mpnetSE2(Network=data.trainedNetwork,StateBounds=stateBounds,EncodingSize=data.encodingSize);

Créez un échantillonneur d'état MPNet pour calculer les échantillons d'état. Spécifiez l'environnement de la carte ainsi que les poses de début et d'objectif comme entrées dans l'échantillonneur d'état.

mpnetSampler = stateSamplerMPNET(stateSpace,mpnet,Environment=map,StartState=start,GoalState=goal);

Générez 30 échantillons à partir de l'espace d'état d'entrée pour la planification de mouvement.

samples = sample(mpnetSampler,30);

Affichez la carte d'entrée et tracez les échantillons d'état calculés.

figure
show(map)
hold on
plot(start(1),start(2),plannerLineSpec.start{:})
plot(goal(1),goal(2),plannerLineSpec.goal{:})
plot(samples(:,1),samples(:,2),plannerLineSpec.state{:})
legend(Location="bestoutside")
hold off

Références

[1] Prokudin, Sergey, Christoph Lassner, and Javier Romero. “Efficient Learning on Point Clouds with Basis Point Sets.” In 2019 IEEE/CVF International Conference on Computer Vision Workshop (ICCVW), 3072–81. Seoul, Korea (South): IEEE, 2019. https://doi.org/10.1109/ICCVW.2019.00370.

[2] Qureshi, Ahmed Hussain, Yinglong Miao, Anthony Simeonov, and Michael C. Yip. “Motion Planning Networks: Bridging the Gap Between Learning-Based and Classical Motion Planners.” IEEE Transactions on Robotics 37, no. 1 (February 2021): 48–66. https://doi.org/10.1109/TRO.2020.3006716.

Capacités étendues

Génération de code C/C++

Générez du code C et C++ avec MATLAB® Coder™.

Les propriétés de l'objet mpnetSE2 doivent être des constantes de compilation.

Historique des versions

Introduit dans R2023b

Voir aussi

Objets

• stateSamplerMPNET

Fonctions

• predict | loss | copy | mpnetPrepareData

Rubriques

• Accelerate Motion Planning with Deep-Learning-Based Sampler
• Train Deep Learning-Based Sampler for Motion Planning
• Get Started with Motion Planning Networks