Esta página se ha traducido mediante traducción automática. Haga clic aquí para ver la última versión en inglés.

mpnetSE2

Redes de planificación de movimiento

Desde R2023b

Descripción

El objeto mpnetSE2 almacena redes de planificación de movimiento (MPNet) para usar en el muestreo del espacio de estados o en la planificación de movimiento. MPNet es un enfoque basado en aprendizaje profundo que utiliza redes neuronales para realizar un muestreo informado o una planificación del movimiento. MPNet utiliza conocimiento previo para encontrar estados óptimos para la planificación del movimiento. Usando este objeto, puedes:

• Cargue un MPNet previamente entrenado y úselo para muestreo de espacio de estados o planificación de movimiento.

• Configure un MPNnet no entrenado para entrenarlo en un nuevo conjunto de datos. Luego, utilice el MPNet entrenado para el muestreo del espacio de estados o la planificación del movimiento.

Utilice la función predict del objeto mpnetSE2 para predecir muestras de estado entre una pose inicial y una pose objetivo en un entorno de entrada conocido o desconocido. Utilice la función loss del objeto mpnetSE2 para calcular las pérdidas durante el entrenamiento de la red.

Creación

Sintaxis

mpnet = mpnetSE2

mpnet = mpnetSE2(Name=Value)

Descripción

mpnet = mpnetSE2 devuelve un MPNet no entrenado para entrenar y usar para muestrear el espacio de estados SE(2) o para la planificación del movimiento. Puede entrenar esta red en un conjunto de datos utilizando la función trainnet (Deep Learning Toolbox). El espacio de estados SE(2) también incluye el espacio de estados de Reeds-Shepp y el espacio de estados de Dubins.

mpnet = mpnetSE2(Name=Value) especifica propiedades utilizando uno o más argumentos de nombre-valor. Puede especificar las propiedades Network, StateBounds, LossWeights y EncodingSize como argumentos de nombre-valor.

Utilice la propiedad Network para almacenar una red neuronal profunda que pueda utilizar para realizar un muestreo informado o una planificación del movimiento en un entorno desconocido o conocido.

• Para realizar un muestreo del espacio de estados utilizando un MPNet entrenado previamente, utilice el objeto stateSamplerMPNET.

• Para realizar la planificación del movimiento utilizando un MPNet previamente entrenado, utilice el objeto plannerMPNET y la función plan asociada.

Nota

Para ejecutar esta función, necesitará Deep Learning Toolbox™.

Propiedades

Network — MPNet previamente entrenado o no entrenado

objeto dlnetwork | objeto LayerGraph

MPNet preentrenado o no entrenado, especificado como un objeto dlnetwork (Deep Learning Toolbox) o layerGraph (Deep Learning Toolbox). De forma predeterminada, esta propiedad contiene un MPNet no entrenado.

StateBounds — Límites de las variables del espacio de estados SE (2)

[-100 100; -100 100; -pi pi] (predeterminado) | Matriz de valores reales de 3 por 2

Límites de las variables del espacio de estados SE(2), especificadas como una matriz de valores reales de 3 por 2.

• La primera fila especifica los límites inferior y superior de la variable de estado x en metros.

• La segunda fila especifica los límites inferior y superior de la variable de estado y en metros.

• La tercera fila especifica los límites inferior y superior de la variable de estado θ en radianes.

Tipos de datos: double

LossWeights — Pesos de la función de pérdida

[1 1 1] (predeterminado) | vector de tres elementos de valores positivos reales

Pesos de la función de pérdida, especificados como un vector de tres elementos de valores positivos reales para cada variable de estado, x, y y θ, del espacio de estado SE(2).

La pérdida de entrenamiento para MPNet es la distancia cuadrática media ponderada entre los estados previstos y los estados reales. Los pesos de la función de pérdida especifican el valor de peso para cada variable del espacio de estados mientras se calcula la pérdida.

Tipos de datos: single | double

EncodingSize — Tamaño del entorno codificado

[10 10] (predeterminado) | vector de dos elementos de números enteros no negativos | escalar no negativo

Tamaño del entorno codificado, especificado como un vector de dos elementos de enteros no negativos o un escalar no negativo.

• Si se especifica como un vector, los elementos del vector especifican el tamaño del entorno codificado en las direcciones x y y.

• Si se especifica como escalar, el objeto utiliza el valor especificado para las direcciones x y y.

El entorno codificado es una representación compacta de los mapas de entrada. La función codifica los mapas de entrada utilizando el enfoque de codificación de conjunto de puntos básicos (BPS) presentado en [1]. EncodingSize especifica la cantidad de puntos básicos a utilizar para la representación compacta de los mapas de entrada.

Por ejemplo, si N_sv es el número de variables de estado que definen el espacio de estado de entrada y [E_x E_y] es el tamaño del entorno codificado, entonces el tamaño del entorno codificado y el número de entradas a MPNet deben satisfacer esta ecuación:

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

.

Si entrena MPNet en un solo entorno de mapa, no es necesario codificar el mapa. Porque codificar un entorno no afectará las predicciones de la red. Por lo tanto, puedes establecer el valor EncodingSize en 0.

Para obtener resultados correctos, el valor EncodingSize debe establecerse antes de entrenar la red. No debe modificar el valor EncodingSize mientras configura el objeto mpnetSE2 para la inferencia.

Tipos de datos: single | double

NumInputs — Número de entradas

Solo lectura: 108 (predeterminado) | número entero positivo

Esta propiedad o parámetro es de solo lectura.

Número de entradas al MPNet, almacenadas como un entero positivo. El valor predeterminado es 108.

El número de entradas a la red está determinado por la suma del tamaño del entorno codificado y el número de variables del espacio de estados que representan tanto el estado actual como el estado objetivo. El estado actual y el estado objetivo se proporcionan como entradas a la red en forma de x, y, cosθ y sinθ. Por lo tanto, el número de variables de espacio de estado proporcionadas como entrada a la red es 8. El tamaño predeterminado del entorno codificado es 10 por 10. Por lo tanto, el número predeterminado de entradas a la red es (10×10)+8 = 108.

Si el tamaño del entorno codificado se especifica como 0, el número de entradas a la red es 8.

Tipos de datos: double

NumOutputs — Número de salidas

Solo lectura: 4 (predeterminado)

Esta propiedad o parámetro es de solo lectura.

Número de salidas de MPNet, almacenadas como 4. La red genera variables de espacio de estado, x, y, cosθ y sinθ, que representan el próximo estado previsto.

Tipos de datos: double

Funciones del objeto

predict	Predecir muestras de estado usando MPNet
loss	Calcular la pérdida entre los estados previstos y los estados reales
copy	Crear una copia profunda del objeto mpnetSE2

Ejemplos

Entrene MPNet en un entorno de mapa único

Entrene una red de planificación de movimiento (MPNet), en un entorno de mapa único, para el muestreo del espacio de estados. En el caso de un entorno de mapa único, se utiliza un mapa fijo para entrenar y probar la red. Luego, puede utilizar la red entrenada para calcular muestras de estado entre cualquier pose inicial y pose objetivo en el mapa. Primero, debe configurar un MPNet y entrenar la red en un pequeño conjunto de datos. Utilice la pérdida de entrenamiento para evaluar la precisión de la red. Si entrena MPNet en un gran conjunto de datos de entrenamiento creado utilizando múltiples entornos de mapas, también debe calcular la pérdida de validación para ajustar la precisión de la red. Para obtener información sobre cómo entrenar MPNet en múltiples entornos de mapas para el muestreo del espacio de estados, consulte Entrene un muestreador basado en aprendizaje profundo para la planificación del movimiento.

Cargar e inspeccionar datos de entrenamiento

Cargue el mapa de entrada y los datos de entrenamiento en el espacio de trabajo de MATLAB® .

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

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

map = data.map;

Los datos de entrenamiento constan de muestras de estado óptimo calculadas para múltiples valores aleatorios de poses iniciales y poses de destino en un mapa de laberinto. Extraiga los datos de entrenamiento de la estructura de datos.

trainData = data.trainData;

Inspeccionar los datos de entrenamiento. Los datos de entrenamiento son un arreglo de celdas de tamaño 100 por 1 que contiene 100 muestras de estado para usar en el entrenamiento de la red.

size(trainData)

ans = 1×2

   100     1

Lea las muestras de estado de los datos de entrenamiento. Trazar el mapa de entrada y las muestras del estado de entrenamiento.

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

Crear MPNet y establecer parámetros de red

Cree un MPNet no entrenado utilizando el objeto 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]

Visualiza la red. Para comprender mejor la arquitectura de la red, inspeccione las capas de la red y la cantidad de entradas a cada capa.

analyzeNetwork(mpnet.Network)

Establezca la propiedad StateBounds del objeto mpnetSE2 en los límites del mapa de entrada.

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

Establezca la propiedad EncodingSize del objeto mpnetSE2 en 0. Esto indica que la función no debe codificar el mapa de entrada para entrenar la red. Al establecer la propiedad EncodingSize en 0, se cambia la propiedad NumInputs de MPNet a 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]

Establezca la propiedad LossWeights del objeto mpnetSE2 en [10 10 0]. Para valores de peso más altos, la red tarda más épocas en converger. Si la entrada es un espacio de estado SE(2), el valor de peso para la variable de espacio de estado $\theta$ se establece en 0.

mpnet.LossWeights = [10 10 0];

Preparar datos de entrenamiento

Prepare los datos de entrenamiento convirtiendo las muestras a un formato requerido para entrenar MPNet. La función mpnetPrepareData reescala los valores de los estados de la ruta óptima al rango [0, 1] y los almacena como un objeto datastore para usar con la función de entrenamiento.

dsTrain = mpnetPrepareData(trainData,mpnet);

Tren MPNet

Cree un objeto trainingOptions para entrenar MPNet. Estas opciones de formación se han elegido de forma experimental. Si utiliza un nuevo conjunto de datos para el entrenamiento, debe cambiar sus opciones de entrenamiento para lograr la precisión de entrenamiento deseada.

• Utilice el optimizador Adam.

• Establezca el tamaño de los minilotes de entrenamiento en 20.

• Mezcla el almacén de datos de entrenamiento en cada época.

• Establezca el número máximo de épocas en 50.

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

Entrene el MPNet utilizando la función trainnet. Especifique la función de pérdida y las opciones de entrenamiento como entradas a la función de entrenamiento. Para obtener resultados óptimos, la pérdida de entrenamiento debe converger a cero.

[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

Establezca la propiedad Network del objeto mpnetSE2 en la red entrenada.

mpnet.Network = net; 

Realice un muestreo del espacio de estados utilizando MPNet entrenado

Especifique una pose inicial y una pose objetivo para calcular muestras de estado.

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

Cree un objeto de espacio de estados para los límites de estado especificados.

stateSpace = stateSpaceSE2(stateBounds);

Configure el objeto stateSamplerMPNet para utilizar el MPNet entrenado para el muestreo del espacio de estados. Pase el entorno del mapa, el estado inicial y el estado objetivo como entradas al muestreador de estado. Establezca los límites para el número máximo de muestras aprendidas a considerar en 50.

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

Genera 50 muestras de estado entre las poses inicial y meta.

samples = sample(stateSamplerDL,50);

Trazar las muestras de estado generadas. Observe que las muestras de estado generadas se centran entre los estados inicial y objetivo, y no están dispersas por todo el entorno del mapa. Puede reducir el tiempo de búsqueda y encontrar rutas óptimas rápidamente utilizando estas muestras de estado como semillas para la planificación del movimiento.

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")

Más información

También puede guardar el MPNet entrenado en un archivo .mat para uso futuro. Guarde la red entrenada, los pesos de pérdida y otros parámetros de red en el archivo .mat. Para obtener información sobre cómo utilizar una red previamente entrenada para el muestreo del espacio de estados, consulte Predecir muestras de estado utilizando MPNnet entrenado en un solo entorno.

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

Capacitación de MPNet con datos personalizados para la planificación del movimiento

Este ejemplo muestra cómo entrenar una MPNet en un conjunto de datos personalizado y luego usar la red entrenada para calcular rutas entre dos estados en un entorno de mapa desconocido.

Cargar y visualizar conjunto de datos de entrenamiento

Cargue el conjunto de datos desde un archivo .mat. El conjunto de datos contiene 400.000 rutas diferentes para 200 entornos de mapas de laberintos. El conjunto de datos se ha generado para los parámetros predefinidos de la función mazeMap. La primera columna del conjunto de datos contiene los mapas y la segunda columna contiene las rutas óptimas para los estados objetivo y de inicio muestreados aleatoriamente de los mapas correspondientes. El tamaño del conjunto de datos es de 75 MB.

% Download and extract the maze map dataset
if ~exist("mazeMapDataset.mat","file")
    datasetURL = "https://ssd.mathworks.com/supportfiles/nav/data/mazeMapDataset.zip";
    websave("mazeMapDataset.zip", datasetURL);
    unzip("mazeMapDataset.zip")
end

% Load the maze map dataset
load("mazeMapDataset.mat","dataset","stateSpace")
head(dataset)

             Map                  Path     
    ______________________    _____________

    1×1 binaryOccupancyMap    {14×3 single}
    1×1 binaryOccupancyMap    { 8×3 single}
    1×1 binaryOccupancyMap    {24×3 single}
    1×1 binaryOccupancyMap    {23×3 single}
    1×1 binaryOccupancyMap    {17×3 single}
    1×1 binaryOccupancyMap    {15×3 single}
    1×1 binaryOccupancyMap    { 7×3 single}
    1×1 binaryOccupancyMap    {10×3 single}

El conjunto de datos se generó utilizando la función auxiliar examplerHelperGenerateDataForMazeMaps. La función auxiliar examplerHelperGenerateDataForMazeMaps utiliza la función mapMaze para generar mapas de laberinto aleatorios de tamaño 10 x 10 y resolución de 2,5 m. El ancho y el espesor de las paredes de los mapas se establecieron en 5 my 1 m, respectivamente.

passageWidth = 5;
wallThickness = 1;
map = mapMaze(passageWidth,wallThickness,MapSize=[10 10],MapResolution=2.5)

Luego, los estados iniciales y objetivos se generan aleatoriamente para cada mapa. La ruta óptima entre los estados inicial y objetivo se calcula utilizando el planificador de rutas plannerRRTStar. Los parámetros ContinueAfterGoalReached y MaxIterations se establecen en true y 5000, respectivamente, para generar las rutas óptimas.

planner = plannerRRTStar(stateSpace,stateValidator); % Uses default uniform state sampling
planner.ContinueAfterGoalReached = true; % Optimize after goal is reached
planner.MaxIterations = 5000; % Maximum iterations to run the planner

Visualice algunas muestras aleatorias del conjunto de datos de entrenamiento. Cada muestra contiene un mapa y la ruta óptima generada para un estado inicial y objetivo determinado.

figure
for i=1:4
    subplot(2,2,i)
    ind = randi(height(dataset)); % Select a random sample
    map = dataset(ind,:).Map; % Get map from Map column of the table
    pathStates = dataset(ind,:).Path{1}; % Get path from Path column of the table
    start = pathStates(1,:);
    goal = pathStates(end,:);

    % Plot the data
    show(map);
    hold on
    plot(pathStates(:,1),pathStates(:,2),plannerLineSpec.path{:})
    plot(start(1),start(2),plannerLineSpec.start{:})
    plot(goal(1),goal(2),plannerLineSpec.goal{:})
end
legend(Location="bestoutside")

Puede modificar la función auxiliar para generar nuevos mapas y entrenar MPNet desde cero. La generación del conjunto de datos puede tardar algunos días dependiendo de la configuración de la CPU y la cantidad de mapas que desee generar para el entrenamiento. Para acelerar la generación de conjuntos de datos, puede utilizar Parallel Computing Toolbox™.

Crear redes de planificación de movimiento

Cree un objeto de redes de planificación de movimiento (MPNet) para el espacio de estado SE(2) utilizando mpnetSE2. El objeto mpnetSE2 carga un MPNet preconfigurado que puedes usar para entrenamiento. Alternativamente, puede utilizar la función mpnetLayers para crear un MPNet con diferentes cantidades de entradas y capas ocultas para entrenar en el conjunto de datos.

mpnet = mpnetSE2;

Establezca las propiedades StateBounds, LossWeights y EncodingSize del objeto mpnetSE2. Establezca StateBounds utilizando la propiedad StateBounds del objeto stateSpace.

mpnet.StateBounds = stateSpace.StateBounds;

Especifique los pesos para cada variable del espacio de estado utilizando la propiedad LossWeights del objeto mpnetSE2. Debe especificar los pesos para cada variable de espacio de estado $\mathit{x}$, $\mathit{y}$ y $\theta$ del espacio de estado SE(2). Para un espacio de estados SE(2), no consideramos la cinemática del robot, como el radio de giro. Por lo tanto, puedes asignar un valor de peso cero para la variable $\theta$.

mpnet.LossWeights = [100 100 0];

Especifique el valor de la propiedad EncodingSize del objeto mpnetSE2 como [9 9]. Antes de entrenar la red, el objeto mpnetSE2 codifica los entornos del mapa de entrada en una representación compacta de tamaño 9 por 9.

mpnet.EncodingSize = [9 9];

Preparar datos para el entrenamiento

Divida el conjunto de datos en conjuntos de tren y prueba en una proporción de 0,8:0,2. El conjunto de entrenamiento se utiliza para entrenar los pesos Network minimizando la pérdida de entrenamiento, el conjunto de validación se utiliza para verificar la pérdida de validación durante el entrenamiento.

split = 0.8;
trainData = dataset(1:split*end,:);
validationData = dataset(split*end+1:end,:);

Prepare los datos para el entrenamiento convirtiendo los datos sin procesar que contienen los mapas y rutas al formato necesario para entrenar MPNet.

dsTrain = mpnetPrepareData(trainData,mpnet);
dsValidation = mpnetPrepareData(validationData,mpnet);

Visualice el conjunto de datos preparado. La primera columna de muestra contiene los datos del mapa codificados, el estado actual codificado y los estados objetivo. La segunda columna contiene el siguiente estado codificado. El estado codificado se calcula como $[x,y,\cos (\theta ),\sin (\theta \left)\right]$ y se normaliza al rango de [0, 1].

preparedDataSample = read(dsValidation);
preparedDataSample(1,:)

ans=1×2 cell array
    {[0.2607 0.4112 0.6846 0.9647 0.9138 0.5757 0.4883 1.3733e-04 0.0549 0.1646 0 0.1646 0.1646 0.1646 0.1646 0.1646 0.0549 0.1646 0.8244 0.0870 0.9383 0.8244 0.8244 0.8244 0.8244 0.1646 0.1646 0.8244 0.0870 0.9020 0.0094 0.0870 0.0870 0.0870 3.9316e-16 0.1646 0.8244 0.0870 0.9020 0.0094 0.9020 0.9043 0.9383 0.1646 0.1646 0.8244 0.0870 0.9020 0.0094 0.9020 0.0870 0.8244 0.1646 0.1646 1 0.9043 0.9020 0.0094 0.9020 0.0870 0.8244 0.1646 0.1646 0.8313 0.0870 0.0870 0.0094 0.9020 0.0870 0.8244 0.1646 0.1646 0.9333 0.8244 0.8244 0.8244 0.9383 0.0870 0.8244 0.1646 0.0549 0.1646 0.1646 0.1646 0.1646 0.1646 2.6928e-16 0.1646 0.0549]}    {[0.2720 0.4130 0.6786 0.9670]}

Entrenar la red de aprendizaje profundo

Utilice la función trainnet para entrenar el MPNet. El entrenamiento de esta red puede llevar mucho tiempo dependiendo del hardware que utilice. Establezca el valor doTraining en true para entrenar la red.

doTraining = false;

Especifique trainingOptions (Deep Learning Toolbox) para entrenar la red de aprendizaje profundo:

• Configure el optimizador "adam".

• Establezca MiniBatchSize para el entrenamiento en 2048.

• Baraja los dsTrain en cada época.

• Establezca MaxEpochs en 50.

• Establezca ValidationData en dsValidation y ValidationFrequency en 2000.

Puede considerar que la capacitación fue exitosa una vez que la pérdida de capacitación y la pérdida de validación converjan cerca de cero.

if doTraining
    options = trainingOptions("adam",...
        MiniBatchSize=2048,...
        MaxEpochs=50,...
        Shuffle="every-epoch",...
        ValidationData=dsValidation,...
        ValidationFrequency=2000,...
        Plots="training-progress");

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

    % Update Network property of mpnet object with net
    mpnet.Network = net;
end

Puede guardar la red entrenada y los detalles del entorno del mapa de entrada en un archivo .mat y usarlo para realizar la planificación del movimiento. En el resto del ejemplo, utilizará un MPNet previamente entrenado para realizar directamente la planificación del movimiento en un entorno de mapa desconocido.

Cargue un archivo .mat que contenga la red entrenada previamente. La red se ha entrenado en varios mapas de laberinto generados aleatoriamente y almacenados en el archivo mazeMapDataset.mat. El archivo .mat contiene la red entrenada y los detalles de los mapas de laberinto utilizados para entrenar la red.

if ~doTraining
    data = load("mazeMapTrainedMPNET.mat")
    mpnet.Network = data.trainedNetwork;
end

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

Realizar planificación de movimiento utilizando MPNet entrenado

Cree un mapa de laberinto aleatorio para probar la MPNet entrenada para el desplazamiento de ruta. El tamaño de la cuadrícula (MapSize×MapResolution) del mapa de prueba debe ser el mismo que el de los mapas utilizados para entrenar MPNet.

Haga clic en el botón Run para generar un nuevo mapa.

 
mazeParams = data.mazeParams;
map = mapMaze(mazeParams{:});
figure
show(map)

Cree un objeto de validador de estado.

stateValidator = validatorOccupancyMap(stateSpace,Map=map);
stateValidator.ValidationDistance = 0.1;

Cree un planificador de rutas MPNet utilizando el validador de estado y el objeto MPNet como entradas.

planner = plannerMPNET(stateValidator,mpnet);

Genere múltiples estados de inicio y objetivo aleatorios utilizando la función sampleStartGoal.

[startStates,goalStates] = sampleStartGoal(stateValidator,500);

Calcular la distancia entre los estados inicial y objetivo generados.

stateDistance=distance(stateSpace,startStates,goalStates);

Seleccione dos estados que estén más alejados entre sí como inicio y objetivo para la planificación del movimiento.

[dist,index] = max(stateDistance);
start = startStates(index,:);
goal = goalStates(index,:);

Planifique la ruta entre los estados inicial y objetivo utilizando la MPNet entrenada.

[pathObj,solutionInfo] = plan(planner,start,goal)

pathObj = 
  navPath with properties:

      StateSpace: [1×1 stateSpaceSE2]
          States: [6×3 double]
       NumStates: 6
    MaxNumStates: Inf

solutionInfo = struct with fields:
        IsPathFound: 1
      LearnedStates: [32×3 double]
       BeaconStates: [2×3 double]
    ClassicalStates: [0×3 double]

Establezca las propiedades de línea y marcador para mostrar los estados de inicio y objetivo utilizando las funciones plannerLineSpec.start y plannerLineSpec.goal, respectivamente.

sstate = plannerLineSpec.start(DisplayName="Start state",MarkerSize=6);
gstate = plannerLineSpec.goal(DisplayName="Goal state",MarkerSize=6);

Establezca las propiedades de la línea para mostrar la ruta calculada utilizando la función plannerLineSpec.path.

ppath = plannerLineSpec.path(LineWidth=1,Marker="o",MarkerSize=8,MarkerFaceColor="white",DisplayName="Planned path");

Traza la ruta planificada.

figure
show(map)
hold on
plot(pathObj.States(:,1),pathObj.States(:,2),ppath{:})
plot(start(1),start(2),sstate{:})
plot(goal(1),goal(2),gstate{:})
legend(Location="bestoutside")
hold off

Ejemplo de espacio de estados SE(2) utilizando MPNet previamente entrenado

Cargue un archivo de datos que contenga un MPNet previamente entrenado en el espacio de trabajo de MATLAB . El MPNet ha sido entrenado en mapas de laberintos 2-D generados aleatoriamente con anchos y alturas de 10 metros y una resolución de 2,5 celdas por metro. Los mapas de laberinto contienen un ancho de paso de 5 celdas de cuadrícula y un espesor de pared de 1 celda de cuadrícula.

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: [3×2 double]
    trainedNetwork: [1×1 dlnetwork]

Crea un mapa de laberinto aleatorio para usarlo en la planificación de movimientos. El tamaño de la cuadrícula ($\mathrm{MapResolution}\times \mathrm{MapSize}$) debe ser el mismo que el de los mapas utilizados para entrenar MPNet.

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

Especifique la pose inicial y la pose objetivo.

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

Especifique los límites de estado y cree un objeto de espacio de estado SE(2).

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

Configure el objeto mpnetSE2 para utilizar el MPNet entrenado previamente para predecir muestras de estado en un mapa aleatorio. Establezca los valores de la propiedad EncodingSize del objeto mpnetSE2 en los valores utilizados para entrenar la red.

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

Cree un muestreador de estado de MPNnet para calcular las muestras de estado. Especifique el entorno del mapa y las posiciones de inicio y meta como entradas para el muestreador de estado.

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

Genere 30 muestras del espacio de estados de entrada para la planificación del movimiento.

samples = sample(mpnetSampler,30);

Muestre el mapa de entrada y trace las muestras de estado calculadas.

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

Planificar la ruta entre dos estados mediante el Planificador de rutas de MPNet

Cargar MPNet previamente entrenado

Cargue un archivo de datos que contenga un MPNet previamente entrenado en el espacio de trabajo de MATLAB® . El MPNet ha sido entrenado en varios mapas de laberintos 2-D con anchos y alturas de 10 metros y resoluciones de 2,5 celdas por metro. Cada mapa de laberinto contiene un ancho de paso de 5 celdas de cuadrícula y un espesor de pared de 1 celda de cuadrícula.

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: [3×2 double]
    trainedNetwork: [1×1 dlnetwork]

Establezca el valor de semilla para generar resultados repetibles.

rng(10,"twister")

Cree un mapa de laberinto para la planificación del movimiento

Crea un mapa de laberinto aleatorio para planificar el movimiento. El tamaño de la cuadrícula ($\mathrm{MapSize}\times \mathrm{MapResolution}$) debe ser el mismo que el de los mapas utilizados para entrenar MPNet.

map = mapMaze(5,1,MapSize=[10 10],MapResolution=2.5);

Crear validador de estado

Cree un objeto validador de estado para utilizar en la planificación del movimiento.

stateSpace = stateSpaceSE2(data.stateBounds);
stateValidator = validatorOccupancyMap(stateSpace,Map=map);
stateValidator.ValidationDistance = 0.1;

Seleccionar estados de inicio y de destino

Genere múltiples estados de inicio y objetivo aleatorios utilizando la función sampleStartGoal.

[startStates,goalStates] = sampleStartGoal(stateValidator,100);

Calcular la distancia entre los estados inicial y objetivo generados.

stateDistance= distance(stateSpace,startStates,goalStates);

Seleccione dos estados que estén más alejados entre sí como inicio y objetivo para la planificación del movimiento.

[dist,index] = max(stateDistance);
start = startStates(index,:);
goal = goalStates(index,:);

Visualice el mapa de entrada.

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

Calcular ruta usando el Planificador de rutas de MPNet

Configure el objeto mpnetSE2 para utilizar el MPNet entrenado previamente para la planificación de rutas. Establezca los valores de la propiedad EncodingSize del objeto mpnetSE2 en los valores utilizados para entrenar la red.

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

Cree un planificador de rutas MPNet utilizando el validador de estado y el MPNet entrenado previamente.

planner = plannerMPNET(stateValidator,mpnet);

Planifique una ruta entre los estados de inicio y destino seleccionados utilizando el planificador de rutas MPNet.

[pathObj,solutionInfo] = plan(planner,start,goal);

Mostrar ruta planificada

Muestra el objeto navPath devuelto por el planificador de rutas MPNet. El número de estados en la ruta planificada y los vectores de estado asociados se especifican mediante las propiedades NumStates y States del objeto navPath, respectivamente.

disp(pathObj)

  navPath with properties:

      StateSpace: [1×1 stateSpaceSE2]
          States: [5×3 double]
       NumStates: 5
    MaxNumStates: Inf

Establezca las propiedades de línea y marcador para mostrar los estados de inicio y objetivo utilizando las funciones plannerLineSpec.start y plannerLineSpec.goal, respectivamente.

sstate = plannerLineSpec.start(DisplayName="Start state",MarkerSize=6);
gstate = plannerLineSpec.goal(DisplayName="Goal state",MarkerSize=6);

Establezca las propiedades de la línea para mostrar la ruta calculada utilizando la función plannerLineSpec.path.

ppath = plannerLineSpec.path(LineWidth=1,Marker="o",MarkerSize=8,MarkerFaceColor="white",DisplayName="Planned path");

Traza la ruta planificada.

figure
show(map)
hold on
plot(pathObj.States(:,1),pathObj.States(:,2),ppath{:})
plot(start(1),start(2),sstate{:})
plot(goal(1),goal(2),gstate{:})
legend(Location="bestoutside")
hold off

Mostrar datos adicionales

Muestra la estructura solutionInfo devuelta por el planificador de rutas MPNet. Esta estructura almacena los estados aprendidos, los estados clásicos y los estados de baliza calculados por el planificador de rutas MPNet. Si el planificador de rutas MPNet no calcula alguno de estos tres tipos de estados, el valor del campo correspondiente se establece como vacío.

disp(solutionInfo)

        IsPathFound: 1
      LearnedStates: [50×3 double]
       BeaconStates: [2×3 double]
    ClassicalStates: [9×3 double]

Establezca las propiedades de línea y marcador para mostrar los estados aprendidos, los estados clásicos y los estados de baliza mediante plannerLineSpec.state.

lstate = plannerLineSpec.state(DisplayName="Learned states",MarkerSize=3);
cstate = plannerLineSpec.state(DisplayName="Classical states",MarkerSize=3,MarkerFaceColor="green",MarkerEdgeColor="green");
bstate = plannerLineSpec.state(MarkerEdgeColor="magenta",MarkerSize=7,DisplayName="Beacon states",Marker="^");

Grafique los estados aprendidos, los estados clásicos y los estados de baliza junto con la ruta calculada. De la figura, se puede inferir que el enfoque de planificación de ruta neuronal no pudo calcular una ruta libre de colisiones donde hay estados de baliza. Por lo tanto, el planificador de rutas MPNet recurrió al enfoque clásico de planificación de rutas RRT*. Los estados finales de la ruta planificada constituyen los estados devueltos por la planificación de ruta neuronal y los enfoques de planificación de ruta clásica.

figure
show(map)
hold on
plot(pathObj.States(:,1),pathObj.States(:,2),ppath{:})
plot(solutionInfo.LearnedStates(:,1),solutionInfo.LearnedStates(:,2),lstate{:})
plot(solutionInfo.ClassicalStates(:,1),solutionInfo.ClassicalStates(:,2),cstate{:})
plot(solutionInfo.BeaconStates(:,1),solutionInfo.BeaconStates(:,2),bstate{:})
plot(start(1),start(2),sstate{:})
plot(goal(1),goal(2),gstate{:})
legend(Location="bestoutside")
hold off

Referencias

[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.

Capacidades ampliadas

Generación de código C/C++

Genere código C y C++ mediante MATLAB® Coder™.

Las propiedades del objeto mpnetSE2 deben ser constantes de tiempo de compilación.

Historial de versiones

Introducido en R2023b

Consulte también

Objetos

• stateSamplerMPNET | plannerMPNET

Funciones

• predict | loss | copy | mpnetPrepareData | mpnetLayers

Temas

• Acelere la planificación del movimiento con un muestreador basado en aprendizaje profundo
• Entrene un muestreador basado en aprendizaje profundo para la planificación del movimiento
• Comience con las redes de planificación de movimiento