Using Pretrained DLCHOMP Optimizer to Predict Higher Number of Waypoints- MATLAB & Simulink- MathWorks Nordic (2024)

Since R2024a

This example uses:

Robotics System ToolboxRobotics System Toolbox
Deep Learning ToolboxDeep Learning Toolbox

Open Live Script

This example shows you how to a pretrained dlCHOMP optimizer to work with a different number of waypoints than what it was trained on.

In this example, you'll start with a dlCHOMP object that has a network that has been pretrained for a robot with an appropriate obstacle set. However, the pretrained network also uses a specific number of waypoints. To change these number of waypoints, you'll need to modify the network using transfer learning.

In this example it is assumed that the pretrained dlCHOMP optimizer is trained for the target robot kukaIiwa7 as specified by its RigidBodyTree property and has the desired basis point set encoder as specified by its BPSEncoder property. Since the RigidBodyTree and the BPSEncoder properties meet the desired requirements, but the NumWaypoints property does not, transfer learning can be performed by tweaking the network architecture stored in the underlying Network property of the pretrained dlCHOMP object. If you would like to change the optimization options such as SmoothnessOptions, CollisionOptions or SolverOptions properties instead, refer to the Using Pretrained DLCHOMP Optimizer in Unseen Obstacle Environment example.

To try out pretrained networks for other robots, see Pretrained Optimizers.

This example uses a pretrained network to initialize a new dlCHOMP optimizer and then trains it on a training dataset that meets our target trajectory requirement of a higher number of waypoints.

Background

Transfer learning is a deep learning approach in which a model that has been trained for one task is used as a starting point for a model that performs a similar task. Updating and retraining a network with transfer learning is usually much faster and easier than training a network from scratch.

Transfer learning is used because:

It enables you to train models with less labeled data by reusing popular models that have already been trained on large datasets.
It can reduce training time and computing resources. With transfer learning, the weights are not learned from scratch because the pretrained model has already learned the weights based on previous learnings.

For more information about transfer learning, see What Is Transfer Learning?.

Download Pretrained DLCHOMP Optimizer

The pretrained DLCHOMP optimizer to be downloaded was trained for the target robot kukaIiwa7 as specified by its RigidBodyTree property and has the desired basis point set encoder as specified by its BPSEncoder property. Since the RigidBodyTree and the BPSEncoder properties meet the desired requirements, but the NumWaypoints property does not, transfer learning can be performed by tweaking the network architecture stored in the underlying Network property of the pretrained dlCHOMP object. This will be covered in the next section.

For now, download the pretrained DLCHOMP optimizer. Also obtain the dlCHOMPDataOptions object that was used to generate the training dataset used to train this pretrained optimizer.

dlCHOMPComponent = "rst/data/dlCHOMP/R2024a";pretrainedDLCHOMPFilename = "kukaIiwa7DLCHOMPTrained.zip";disp("Downloading previously trained kukaIiwa7 dlCHOMP optimizer (46 MB)...");

Downloading previously trained kukaIiwa7 dlCHOMP optimizer (46 MB)...

pretrainedDLCHOMPFolder = exampleHelperDownloadData(dlCHOMPComponent,pretrainedDLCHOMPFilename);pretrainedDLCHOMPMATPath = fullfile(pretrainedDLCHOMPFolder,"trainedDLCHOMP.mat"); loadedData = load(pretrainedDLCHOMPMATPath,"robotName","trainedDLCHOMP","trainInfo","trainOptions","trainLossType","dataOptions");

Warning: Error setting property 'ValidationData' of class '<a href="matlab:helpPopup nnet.cnn.TrainingOptions">nnet.cnn.TrainingOptions</a>'. Could not open file C:\Users\sshenoy\OneDrive - MathWorks\Documents\MATLAB\ExampleManager\sshenoy.Bdoc24a.dlCHOMPExamples.j2463341\robotics-ex41715743\allData\sample_1.json. No such file or directory.

pretrainedRobotName = loadedData.robotName;pretrainedDLCHOMP = loadedData.trainedDLCHOMP;pretrainedTrainInfo = loadedData.trainInfo;pretrainedTrainOptions = loadedData.trainOptions;pretrainedTrainLossType = loadedData.trainLossType;pretrainedDataOptions = loadedData.dataOptions;

As can be seen in the training plot above, the pretrainedDLCHOMP optimizer took 1500 iterations to get trained, and hence converge, from scratch.

Modify Last Layer of Pretrained Network to Predict Higher Number of Waypoints

First, specify the desired target number of waypoints.

desiredNumWaypoints = 50;

Compare the desiredNumWaypoints with the NumWaypoints property of the pretrainedDLCHOMP object.

isequal(desiredNumWaypoints,pretrainedDLCHOMP.NumWaypoints)

ans = logical 0

As can be seen, the number of waypoints do not match as the pretrainedDLCHOMP was trained to predict 40 waypoints which does not match the desired 50 waypoints.

Since the NumWaypoints property only affects the last FullyConnectedLayer of the neural network property Network of a given dlCHOMP object, the rest of the network can still be reused from the pretrainedDLCHOMP object.

To do this, first, convert the Network property of the pretrainedDLCHOMP object into a LayerGraph.

pretrainedLayerGraph = layerGraph(pretrainedDLCHOMP.Network);

Then determine the configuration size of the robot of interest.

configurationSize = numel(pretrainedDLCHOMP.RigidBodyTree.homeConfiguration());

Then create a new FullyConnectedLayer object which meets the desired target trajectory requirement of outputting a higher number of waypoints than before.

desiredFinalLayerName = pretrainedDLCHOMP.Network.OutputNames{1};desiredOutputSize = configurationSize * (desiredNumWaypoints-2); % The network only predicts the intermediate waypointsnewFinalLayer = fullyConnectedLayer( ... desiredOutputSize,"Name",desiredFinalLayerName)

newFinalLayer = FullyConnectedLayer with properties: Name: 'FinalFCLayer' Hyperparameters InputSize: 'auto' OutputSize: 336 Learnable Parameters Weights: [] Bias: [] Show all properties

As can be seen, this new layer has empty Weights and Bias properties, which indicates that it has not learned any parameters since it has not been trained yet.

Change the learning rates so that learning is faster in this new layer than in the transferred layers by setting its WeightLearnRateFactor and BiasLearnRateFactor to 10.

newFinalLayer.WeightLearnRateFactor = 10;newFinalLayer.BiasLearnRateFactor = 10;

Now, replace the existing final FullyConnectedLayer with this new layer that was created.

modifiedLayerGraph = pretrainedLayerGraph.replaceLayer( ... desiredFinalLayerName, newFinalLayer);modifiedNetwork = dlnetwork(modifiedLayerGraph);

Finally, create a new dlCHOMP object by setting its NumWaypoints property to desiredNumWaypoints and setting its Network property to modifiedNetwork at object construction time. All other properties will stay the same as that of the pretrainedDLCHOMP object.

There is a need to create a new object since the NumWaypoints and Network properties of a dlCHOMP object are read-only and cannot be modified post object construction.

modifiedDLCHOMP = dlCHOMP( ... pretrainedDLCHOMP.RigidBodyTree, ... pretrainedDLCHOMP.BPSEncoder, ... desiredNumWaypoints, ... CollisionOptions=pretrainedDLCHOMP.CollisionOptions, ... SmoothnessOptions=pretrainedDLCHOMP.SmoothnessOptions, ... SolverOptions=pretrainedDLCHOMP.SolverOptions, ... RigidBodyTreeSpheres=pretrainedDLCHOMP.RigidBodyTreeSpheres, ... Network=modifiedNetwork)

modifiedDLCHOMP = dlCHOMP with properties: RigidBodyTree: [1×1 rigidBodyTree] RigidBodyTreeSpheres: [11×1 table] SmoothnessOptions: [1×1 chompSmoothnessOptions] SolverOptions: [1×1 chompSolverOptions] CollisionOptions: [1×1 chompCollisionOptions] SphericalObstacles: [4×0 double] BPSEncoder: [1×1 bpsEncoder] NumWaypoints: 50 Network: [1×1 dlnetwork] NumInputs: [14 10000] NumOutputs: 336

Now, for using the modifiedDLCHOMP optimizer for inference, it needs to have all of the learnable parameters in its Network property in a learned state.

Since the final FullyConnectedLayer of the pretrained network was replaced with a new layer with non-learned parameters, there is a need to generate a small dataset for retraining the optimizer to meet this one last unsatisfied objective.

Generate Training Dataset Matching Desired Number of Waypoints

First, create a new desiredDataOptions object which is a copy of the pretrainedDataOptions object that was used to generate the training dataset for the pretrainedDLCHOMP object.

desiredDataOptions = pretrainedDataOptions

desiredDataOptions = dlCHOMPDataOptions with properties: RadiusRangeOfObstacles: [0.0500 0.2000] CountRangeOfObstacles: [20 25] MinDistanceFromBase: 0.2100 NumSamples: 5000 ValidationSplit: 0.2000 RandomStream: 'threefry' Seed: 0

Retrain Modified dlCHOMP Optimizer

Let's retrain the modifiedDLCHOMP optimizer object using the new data that was obtained.

Use the same training options object pretrainedTrainOptions by setting its ValidationData property to the new validation datastore validDS that was obtained earlier. Keep the other properties the same.

trainOptions = pretrainedTrainOptions;trainOptions.ValidationData = validDS;

Use the loss type pretrainedTrainLossType that was used to train the pretrainedDLCHOMP object.

Now, retrain the modifiedDLCHOMP optimizer object using the training datastore trainDS, loss type pretrainedTrainLossType and the training options trainOptions.

Retraining takes around 10 minutes on a Windows 10 system with 48 GB RAM using 8 parallel pool workers. So download this previously retrained dlCHOMP object by default as the doRetraining is set to false below.

If you want to retrain the object yourself, set doRetraining to true. Otherwise, set doRetraining to false.

doRetraining = false;

If doRetraining is false, download a new pretrained dlCHOMP optimizer object. Otherwise, retrain the existing object.

if doRetraining == false retrainedDLCHOMPFilename = "kukaIiwa7DLCHOMPRetrainedForHigherWaypoints.zip"; disp("Downloading previously retrained kukaIiwa7 dlCHOMP optimizer (44 MB)..."); retrainedDLCHOMPFolder = exampleHelperDownloadData(dlCHOMPComponent,retrainedDLCHOMPFilename); retrainedDLCHOMPMATPath = fullfile(retrainedDLCHOMPFolder,"retrainedDLCHOMP.mat"); load(retrainedDLCHOMPMATPath,"retrainedDLCHOMP","retrainInfo");else retrainInfo = trainDLCHOMP(modifiedDLCHOMP,trainDS,pretrainedTrainLossType,trainOptions); retrainedDLCHOMP = modifiedDLCHOMP;end

Downloading previously retrained kukaIiwa7 dlCHOMP optimizer (44 MB)...

As can be seen above, the dlCHOMP optimizer converged much faster while training, within about 150 iterations, which is much smaller than the nearly 1500 iterations that were needed to train the pretrained dlCHOMP optimizer from scratch as was shown in the training plot under the Download Pretrained DLCHOMP Optimizer section above. This indicates that the network had already learned weights based on previous learnings and simply had to be tuned to predict a higher number of waypoints than before.

Infer Using Retrained dlCHOMP Optimizer

Now that the retrained optimizer is available, it can be used for inference on an unseen target environment of interest.

Generate One Unseen Target Environment

Let's generate an unseen target environment using the same dlCHOMPDataOptions object were chosen for generating the training and validation data sets to ensure the same environment complexity. However, change the properties that affect the environment diversity to ensure that an unseen data sample is generated.

First, to generate only 1 data sample, set the NumSamples property to 1 and the ValidationSplit property to 0 respectively.

desiredDataOptions.NumSamples = 1;desiredDataOptions.ValidationSplit = 0;

Next, to ensure an unseen data sample is generated, change the Seed value to differ it from the one used when generating the training and validation data sets used to train the optimizer. Since the default Seed value of 0 was used then, let's use a value of 300 now.

desiredDataOptions.Seed = 300

desiredDataOptions = dlCHOMPDataOptions with properties: RadiusRangeOfObstacles: [0.0500 0.2000] CountRangeOfObstacles: [20 25] MinDistanceFromBase: 0.2100 NumSamples: 1 ValidationSplit: 0 RandomStream: 'threefry' Seed: 300

Choose a new location for saving the generated unseen sample.

folderForUnseenData = "unseenData";

Generate an unseen target environment.

rng(desiredDataOptions.Seed,"twister");testDS = retrainedDLCHOMP.generateSamples(desiredDataOptions,folderForUnseenData);

------------------------Starting data generation[1/1] Data Samples Written|┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃┃ 100.00% complete|Total Run Time: 00:00:02 secsEstimated Time Remaining: 00:00:00 secs------------------------

filePathToUnseenSample = resolve(testDS.FileSet).FileName(1);[unseenStart,unseenGoal,unseenObstacles,chompTrajectory] = exampleHelperExtractDataFromDLCHOMPSample(filePathToUnseenSample);

Infer On Unseen Target Environment

Make the retrainedDLCHOMP optimizer aware of the unseen spherical obstacles.

retrainedDLCHOMP.SphericalObstacles = unseenObstacles;

Finally, use the retrainedDLCHOMP optimizer for inference on this unseen target environment.

[optimWptsDLCHOMPNew,optimTptsDLCHOMPNew,solninfoDLCHOMPNew] = retrainedDLCHOMP.optimize(unseenStart,unseenGoal);

Let's visualize this trajectory in an animated fashion.

% Create new figurefigure;% Show animated robot trajectoryax = show(retrainedDLCHOMP,unseenStart);title(sprintf("dlCHOMP Optimized End-Effector Trajectory with %d Waypoints\nUnseen Target Environment",desiredNumWaypoints));axis(ax,"equal");exampleHelperShowAnimatedRobotTrajectory(ax,retrainedDLCHOMP.RigidBodyTree,optimWptsDLCHOMPNew);

Conclusion

In conclusion, you learned how to tweak a pretrained dlCHOMP optimizer's network architecture meant to predict a low number of waypoints, to meet the target requirement of predicting a higher number of waypoints. You also learned how to retrain this modified dlCHOMP optimizer to tune it to predict a higher number of waypoints. Finally, you used this retrained dlCHOMP optimizer for motion planning in an unseen target obstacle environment.

Using Pretrained DLCHOMP Optimizer to Predict Higher Number of Waypoints - MATLAB & Simulink - MathWorks Nordic (2024)