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:

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 . 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 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 laberintos aleatorios de tamaño 10 por 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 ruta plannerRRTStar . Los parámetros ContinueAfterGoalReached y MaxIterations se establecen en true y 5000, respectivamente, para generar el valor óptimo. rutas.

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{:})
    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™.

Crear redes de planificación de movimiento

Cree un objeto Motion Planning Networks (MPNet) para el espacio de estados SE(2) usando mpnetSE2.

mpnet = mpnetSE2;

Establezca las StateBounds, LossWeights y EncodingSize del objeto mpnetSE2 . Establezca StateBounds usando 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 del espacio de estado. $x$ , $y$ , y $θ$ del espacio de estados SE(2). Para un espacio de estados SE(2), no consideramos la cinemática del robot, como el radio de giro. Por lo tanto, puede asignar un valor de peso cero para el $θ$ variable.

Especifique los pesos para cada variable del espacio de estados 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 usa para entrenar los pesos Network minimizando la pérdida de entrenamiento, el conjunto de validación se usa 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 normalizado 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 para entrenar la red de aprendizaje profundo:

Configure el optimizador "adam".
Establezca el MiniBatchSize para el entrenamiento en 2048.
Mezcla el 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 previamente entrenada. La red ha sido entrenada en varios mapas de laberintos generados aleatoriamente 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 ejemplos 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 combinación 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 aumentar 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

mpnetSE2 | stateSamplerMPNET | mpnetPrepareData

Temas relacionados

Comience con las redes de planificación de movimiento

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.