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

Entrene un muestreador basado en aprendizaje profundo para la planificación del movimiento

Este ejemplo utiliza:

Abrir script en vivo

Este ejemplo muestra cómo crear un muestreador basado en aprendizaje profundo utilizando Motion Planning Networks para acelerar la planificación de rutas utilizando planificadores basados ​​en muestreo como RRT (árbol aleatorio de exploración rápida) y RRT*. Para obtener información sobre las redes de planificación de movimiento (MPNet) para el muestreo del espacio de estados, consulte Comience con las redes de planificación de movimiento.

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 55 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    {13×3 single}
    1×1 binaryOccupancyMap    { 7×3 single}
    1×1 binaryOccupancyMap    {12×3 single}
    1×1 binaryOccupancyMap    {10×3 single}
    1×1 binaryOccupancyMap    { 8×3 single}
    1×1 binaryOccupancyMap    {11×3 single}
    1×1 binaryOccupancyMap    {11×3 single}
    1×1 binaryOccupancyMap    { 9×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 estos estados se calcula utilizando el planificador de rutas RRTStar. Para acelerar el tiempo de cálculo, establecemos el número máximo de iteraciones en 1000. Luego, los nodos redundantes en la ruta resultante se eliminan utilizando la función shortenpath. 

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

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{:})
    title("")
end

legend

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™. El conjunto de datos utilizado en este ejemplo se generó en aproximadamente 12 horas utilizando Parallel Computing Toolbox ™ en una CPU Intel(R) Xeon(R) W-2133 con 64 GB de RAM.

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. 

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;

La función de pérdida es la pérdida cuadrática media ponderada calculada entre el siguiente estado previsto y el estado real (ground-truth) tomado del conjunto de datos. Debe especificar los pesos para cada variable de espacio de estado x, y y θ 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 θ.

Especifique los pesos para cada variable del espacio de estado utilizando la propiedad LossWeights del objeto mpnetSE2. 

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(θ),sin(θ)] y se normaliza al rango de [0, 1].

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

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

Como alternativa, puede utilizar directamente un MPNet previamente entrenado para calcular predicciones.

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.

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

Crear muestra de estado de MPNnet

Cree una muestra de estado de MPNnet utilizando el espacio de estado y el objeto MPNet como entradas. Puede actualizar las propiedades Environment, StartState y GoalState para generar muestras para nuevos escenarios.

stateSamplerDL = stateSamplerMPNET(stateSpace,mpnet);

Genere muestras aprendidas sobre datos de validación

Presione el botón Run a continuación para generar muestras aprendidas para diferentes muestras en el conjunto de datos de prueba.

% Get random sample from testData
ind = randi(height(validationData));
map = validationData(ind,:).Map;
start = double(validationData(ind,:).Path{1,:}(1,:));
goal = double(validationData(ind,:).Path{1,:}(end,:));

Establezca las propiedades Environment, StartState, GoalState, MaxLearnedSamples para stateSampler.

stateSamplerDL.Environment = map;
stateSamplerDL.StartState = start;
stateSamplerDL.GoalState = goal;

Puede variar el total de muestras generadas por el muestreador ajustando numSamples. También puede variar MaxLearnedSamples(<=numSamples) para visualizar la mezcla de muestras aprendidas y muestras uniformes.

numSamples =100;
stateSamplerDL.MaxLearnedSamples = 100;

Presione el botón Run a continuación para generar muestras para un nuevo escenario.

 
samples = sample(stateSamplerDL, numSamples);

Visualizar muestras generadas

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

Conclusión

Este ejemplo muestra cómo entrenar un MPNet para generar muestras aprendidas para planificadores basados ​​en muestreo como RRT y RRT*. También muestra el proceso de generación de datos, la configuración, el entrenamiento y la predicción de la red de aprendizaje profundo. Puede modificar este ejemplo para utilizarlo con mapas y conjuntos de datos personalizados. Además, puede ampliar esto para aplicaciones como planificación de rutas de manipuladores, planificación de rutas de VANT en 3-D y más.

Para ampliar los planificadores basados en muestreo con el muestreador basado en aprendizaje profundo para encontrar rutas óptimas de manera eficiente, consulte el ejemplo Acelere la planificación del movimiento con un muestreador basado en aprendizaje profundo.

Consulte también

| |

Temas

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.

[3] Qureshi, Ahmed H., and Michael C. Yip. “Deeply Informed Neural Sampling for Robot Motion Planning.” In 2018 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), 6582–88. Madrid: IEEE, 2018. https://doi.org/10.1109/IROS.2018.8593772.