Entrene un muestreador basado en aprendizaje profundo para la planificación del movimiento
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., , ydel 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 comoy 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
endsValidation
yValidationFrequency
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
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.