Deep Learning Toolbox Practice
Neural Network Design and Training
Deep Neural Network Construction Example:
% Create a deep feedforward neural network
layers = [
imageInputLayer([28 28 1], 'Normalization', 'zerocenter') % Input layer (grayscale image)
convolution2dLayer(3, 16, 'Padding', 'same') % Convolutional layer (16 3x3 filters)
batchNormalizationLayer % Batch normalization
reluLayer % ReLU activation
maxPooling2dLayer(2, 'Stride', 2) % Max pooling
convolution2dLayer(3, 32, 'Padding', 'same') % Second convolutional layer
batchNormalizationLayer
reluLayer
maxPooling2dLayer(2, 'Stride', 2)
fullyConnectedLayer(128) % Fully connected layer
dropoutLayer(0.5) % Dropout regularization
fullyConnectedLayer(10) % Output layer (10 classes)
softmaxLayer % Softmax activation
classificationLayer]; % Classification layer
% Data preparation (using MNIST as example)
[XTrain, YTrain] = digitTrain4DArrayData;
[XTest, YTest] = digitTest4DArrayData;
% Training options configuration
options = trainingOptions('adam', ...
'InitialLearnRate', 0.001, ...
'MaxEpochs', 10, ...
'MiniBatchSize', 128, ...
'Shuffle', 'every-epoch', ...
'ValidationData', {XTest, YTest}, ...
'ValidationFrequency', 30, ...
'Plots', 'training-progress', ...
'Verbose', false);
% Network training
net = trainNetwork(XTrain, YTrain, layers, options);
% Model evaluation
YPred = classify(net, XTest);
accuracy = mean(YPred == YTest);
fprintf('Test set accuracy: %.2f%%\n', accuracy*100);
Transfer Learning Application:
% Load pre-trained network (ResNet-50)
net = resnet50;
% Replace the last few layers (adapt to new task)
numClasses = 5; % Number of classes for new classification task
layers = [
net.Layers(1:end-3) % Retain pre-trained feature extraction layers
fullyConnectedLayer(numClasses, 'WeightLearnRateFactor', 10, 'BiasLearnRateFactor', 10)
softmaxLayer
classificationLayer];
% Freeze feature extraction layers (train only newly added layers)
for i = 1:length(layers)-3
layers(i).Training = false;
end
% Data augmentation configuration
augmenter = imageDataAugmenter(...
'RandRotation', [-20 20], ...
'RandXReflection', true);
% Training options (lower learning rate)
options = trainingOptions('sgdm', ...
'InitialLearnRate', 0.0001, ...
'MaxEpochs', 5, ...
'MiniBatchSize', 32, ...
'Shuffle', 'every-epoch');
% Load custom dataset
imds = imageDatastore('new_dataset', ...
'IncludeSubfolders', true, ...
'LabelSource', 'foldernames');
augimds = augmentedImageDatastore([224 224 3], imds, 'DataAugmentation', augmenter);
% Transfer learning training
net = trainNetwork(augimds, layers, options);
Advanced CNN and RNN Applications
Convolutional Neural Network Visualization:
% Visualize convolutional layer activations
I = imread('peppers.png');
I = imresize(I, [224 224]);
layer = 'conv1'; % Specify layer to visualize
% Create activation map
actMap = deepDreamImage(net, layer, 1, 'PyramidLevels', 1);
% Display activation channels
figure;
montage(actMap);
title(sprintf('Layer %s Activation Map', layer));
% Visualize filter weights
weights = net.Layers(2).Weights;
figure;
for i = 1:size(weights,3)
subplot(4,8,i);
imshow(weights(:,:,i), []);
end
title('Convolutional Kernel Weights Visualization');
Recurrent Neural Network Time Series Prediction:
% Prepare time series data
load sunspotData;
data = sunspotSeries;
numTimeSteps = 24; % Use past 24 months to predict next month
% Create input/target sequences
[XTrain, YTrain] = createTimeSeriesData(data(1:1000), numTimeSteps);
[XTest, YTest] = createTimeSeriesData(data(1001:end), numTimeSteps);
% Define LSTM network architecture
layers = [
sequenceInputLayer(1)
bilstmLayer(100, 'OutputMode', 'sequence')
dropoutLayer(0.2)
bilstmLayer(100, 'OutputMode', 'last')
dropoutLayer(0.2)
fullyConnectedLayer(1)
regressionLayer];
% Training options
options = trainingOptions('adam', ...
'MaxEpochs', 50, ...
'GradientThreshold', 1, ...
'InitialLearnRate', 0.005, ...
'LearnRateSchedule', 'piecewise', ...
'LearnRateDropPeriod', 125, ...
'LearnRateDropFactor', 0.2, ...
'Verbose', 0);
% Network training
net = trainNetwork(XTrain, YTrain, layers, options);
% Prediction and evaluation
YPred = predict(net, XTest);
rmse = sqrt(mean((YPred - YTest).^2));
fprintf('Test set RMSE: %.2f\n', rmse);
Computer Vision Toolbox Applications
Object Detection and Tracking
YOLOv4-based Object Detection:
% Load pre-trained YOLOv4 model
detector = yolov4ObjectDetector('tiny-yolov4-coco');
% Read test image
I = imread('street_scene.jpg');
% Perform object detection
[bboxes, scores, labels] = detect(detector, I);
% Visualize detection results
I_detected = insertObjectAnnotation(I, 'rectangle', bboxes, labels);
figure;
imshow(I_detected);
title('YOLOv4 Detection Results');
% Export detection results to MAT file
results = struct('Boxes', bboxes, 'Scores', scores, 'Labels', labels);
save('detection_results.mat', 'results');
Multi-Object Tracking System:
% Initialize tracker
tracker = multiObjectTracker('FilterInitializationFcn', @initCVFilter, ...
'AssignmentThreshold', [50 inf], 'DeletionThreshold', 10);
% Simulate video frame processing (using image sequence here)
videoReader = vision.VideoFileReader('traffic_video.mp4');
while hasFrame(videoReader)
frame = readFrame(videoReader);
% Object detection (simplified to fixed position detection here)
[bboxes, scores] = detectObjects(frame); % Custom detection function
% Predict existing object states
predictedTracks = predictTracks(tracker);
% Associate detections with predictions
[confirmedTracks, ~] = updateTracks(tracker, bboxes, scores);
% Visualize tracking results
frame = visualizeTracking(frame, confirmedTracks);
imshow(frame);
drawnow;
end
% Compute tracking evaluation metrics
computeTrackingMetrics(tracker);
Image Segmentation and Enhancement
Semantic Segmentation Network Training:
% Load CamVid dataset
[imds,pxds] = loadCamVidData();
% Define segmentation network architecture
numClasses = 32;
lgraph = unetLayers([360 480 numClasses], 'EncoderDepth', 4);
% Modify network (add attention mechanism)
lgraph = addAttentionModule(lgraph, 'encoder/conv3/conv3_1');
% Data augmentation configuration
augmenter = imageDataAugmenter(...
'RandRotation', [-10 10], ...
'RandXReflection', true);
% Training options
options = trainingOptions('adam', ...
'InitialLearnRate', 1e-4, ...
'MaxEpochs', 30, ...
'MiniBatchSize', 4, ...
'Shuffle', 'every-epoch', ...
'ValidationData', {augmenter.apply(dsVal), pxdsVal}, ...
'ValidationFrequency', 10, ...
'Plots', 'training-progress');
% Network training
net = trainNetwork(imds, lgraph, options);
% Visualize segmentation results
I = imread('test_image.jpg');
[C,scores] = semanticseg(I, net);
B = labeloverlay(I, C, 'Colormap', jet(numClasses));
figure;
imshow(B);
title('Semantic Segmentation Results');
Financial Toolbox Applications
Option Pricing Models
Black-Scholes Model and Greeks Calculation:
% Define option parameters
S = 100; % Underlying asset price
K = 105; % Strike price
r = 0.05; % Risk-free rate
sigma = 0.2; % Volatility
T = 1; % Time to maturity (years)
% Calculate option prices
[c, p] = blsprice(S, K, r, T, sigma);
% Calculate Greeks
[delta, gamma, theta, vega, rho] = blsdelta(S, K, r, T, sigma);
% ...other Greeks calculations
% Plot option price surface
[K_mesh, T_mesh] = meshgrid(80:5:130, 0.1:0.1:2);
C = arrayfun(@(K,T) blsprice(S,K,r,T,sigma), K_mesh, T_mesh);
figure;
surf(K_mesh, T_mesh, C);
xlabel('Strike Price K'); ylabel('Time to Maturity T'); zlabel('Call Option Price');
title('Option Price Surface');
Monte Carlo Option Pricing:
% Monte Carlo simulation for European call option
nSimulations = 1e5;
nSteps = 252; % Daily steps
T = 1; % 1 year to maturity
dt = T/nSteps;
% Simulate underlying asset paths
Z = randn(nSimulations, nSteps);
S = zeros(nSimulations, nSteps+1);
S(:,1) = S0;
for t = 1:nSteps
S(:,t+1) = S(:,t) .* exp((r - 0.5*sigma^2)*dt + sigma*sqrt(dt)*Z(:,t));
end
% Calculate option payoff
payoff = max(S(:,end) - K, 0);
price = exp(-r*T) * mean(payoff);
% Calculate confidence interval
stdErr = std(payoff)*exp(-r*T)/sqrt(nSimulations);
fprintf('Monte Carlo option price: %.4f ± %.4f\n', price, 1.96*stdErr);
Risk Analysis and Portfolio
Value at Risk (VaR) Calculation:
% Load historical return data
returns = readtable('asset_returns.csv');
% Calculate parametric VaR (normal distribution assumption)
confidenceLevel = 0.95;
portfolioReturns = returns.Portfolio;
mu = mean(portfolioReturns);
sigma = std(portfolioReturns);
VaR_parametric = norminv(confidenceLevel, mu, sigma);
% Calculate historical simulation VaR
sortedReturns = sort(portfolioReturns);
index = round((1-confidenceLevel)*length(sortedReturns));
VaR_historical = sortedReturns(index);
% Calculate Monte Carlo VaR
nSimulations = 1e4;
simulatedReturns = normrnd(mu, sigma, nSimulations, 1);
VaR_mc = prctile(simulatedReturns, 100*(1-confidenceLevel));
% Results comparison
fprintf('Parametric VaR: %.2f%%\n', VaR_parametric*100);
fprintf('Historical simulation VaR: %.2f%%\n', VaR_historical*100);
fprintf('Monte Carlo VaR: %.2f%%\n', VaR_mc*100);
% Plot VaR comparison chart
figure;
bar([VaR_parametric, VaR_historical, VaR_mc]);
set(gca, 'XTickLabel', {'Parametric', 'Historical Simulation', 'Monte Carlo'});
ylabel('VaR (return)');
title('VaR Comparison Across Different Methods');
Robotics Toolbox Applications
Robot Kinematics and Path Planning
Robot Forward/Inverse Kinematics:
% Create PUMA560 robot model
robot = loadrobot('puma560');
% Set joint angles (radians)
config = [0 pi/4 pi/2 0 pi/3 pi/4];
% Calculate forward kinematics (end-effector pose)
T = getTransform(robot, config, 'link6');
show(robot, config);
hold on;
plotTransforms(T, 'FrameSize', 0.2);
% Inverse kinematics solving
targetPose = trvec2tform([0.5 0.2 0.3]) * axang2tform([0 1 0 pi/2]);
ik = inverseKinematics('RigidBodyTree', robot);
weights = [1 1 1 1 1 1]; % Joint weights
initialguess = [0 0 0 0 0 0];
[configSol, solInfo] = ik('link6', targetPose, weights, initialguess);
% Verify solution
T_sol = getTransform(robot, configSol, 'link6');
disp('Error between target pose and solved pose:');
distError = norm(tform2trvec(T) - tform2trvec(T_sol));
angleError = rad2deg(norm(tform2quat(T) - tform2quat(T_sol)));
fprintf('Position error: %.4f m, Angle error: %.2f°\n', distError, angleError);
Path Planning and Obstacle Avoidance:
% Create environment map
map = binaryOccupancyMap(10,10,10);
setOccupancy(map, [2 2; 2 3; 3 2; 4 2; 5 2], 1); % Set obstacles
% Create path planner
planner = plannerRRTStar(map);
startPose = [1 1 pi/2];
goalPose = [9 9 pi/2];
% Plan path
[path,solInfo] = plan(planner, startPose, goalPose);
% Visualize results
figure;
show(map);
hold on;
plot(path(:,1), path(:,2), 'r-', 'LineWidth', 2);
plot(startPose(1), startPose(2), 'go', 'MarkerSize', 10, 'MarkerFaceColor', 'g');
plot(goalPose(1), goalPose(2), 'ro', 'MarkerSize', 10, 'MarkerFaceColor', 'r');
title('RRT* Path Planning Results');
Manipulator Control and Simulation
Dynamics Simulation and Control:
% Create robot model
robot = loadrobot('ur5');
% Set simulation parameters
Ts = 0.01; % Sampling time
tFinal = 5; % Simulation duration
time = 0:Ts:tFinal;
% Define trajectory (circular trajectory)
center = [0.4 0.1 0.4];
radius = 0.1;
theta = linspace(0, 2*pi, length(time));
waypoints = [center(1)+radius*cos(theta), center(2)+radius*sin(theta), 0.4*ones(size(theta))];
% Solve joint trajectory via inverse kinematics
configTraj = zeros(length(time),6);
for i = 1:length(time)
targetPose = trvec2tform(waypoints(i,:)) * axang2tform([1 0 0 pi/2]);
configTraj(i,:) = inverseKinematics(robot, 'end_effector', targetPose);
end
% Dynamics simulation
[q,qd,qdd] = robotSimulate(robot, configTraj, Ts);
% Plot joint angle curves
figure;
subplot(2,1,1);
plot(time, q);
xlabel('Time (s)'); ylabel('Joint Angle (rad)');
title('Joint Angles Over Time');
subplot(2,1,2);
plot(time, qd);
xlabel('Time (s)'); ylabel('Joint Velocity (rad/s)');
title('Joint Velocities Over Time');
Automated Driving Toolbox Applications
Sensor Fusion and SLAM
Multi-Sensor Data Fusion:
% Initialize sensor fusion object
fusion = insSensor;
% Simulate sensor data (using real data here)
imuData = readtable('imu_data.csv');
gpsData = readtable('gps_data.csv');
% Initialize state estimation
initialState = [gpsData.Latitude(1), gpsData.Longitude(1), 0, 0, 0, 0]; % [lat, lon, roll, pitch, yaw, speed]
initialCovariance = diag([1e-6 1e-6 1e-4 1e-4 1e-4 1e-2]);
% State estimator configuration
estimator = stateEstimatorINS('StateTransitionFcn', @stateTransition, ...
'MeasurementFcn', @measurement, ...
'InitialState', initialState, ...
'InitialCovariance', initialCovariance);
% Data fusion loop
estimatedStates = zeros(length(imuData),6);
for i = 1:length(imuData)
% IMU measurement update
imuMeasurement = [imuData.AccelX(i), imuData.AccelY(i), imuData.AccelZ(i), ...
imuData.GyroX(i), imuData.GyroY(i), imuData.GyroZ(i)];
estimator = predict(estimator, imuMeasurement, imuData.Timestamp(i));
% GPS measurement update (when GPS data available)
if ~isnan(gpsData.Latitude(i))
gpsMeasurement = [gpsData.Latitude(i), gpsData.Longitude(i), gpsData.Speed(i)];
estimator = correct(estimator, gpsMeasurement, gpsData.Timestamp(i));
end
% Save estimated state
estimatedStates(i,:) = estimator.State;
end
% Visualize trajectory
figure;
plot(estimatedStates(:,2), estimatedStates(:,1), 'b-', 'LineWidth', 2);
hold on;
plot(gpsData.Longitude, gpsData.Latitude, 'ro', 'MarkerSize', 4);
legend('Fused Trajectory', 'GPS Measurements');
xlabel('Longitude'); ylabel('Latitude');
title('INS/GPS Data Fusion Trajectory');
SLAM System Implementation:
% Initialize SLAM system
slamObj = lidarSLAM('MapResolution', 0.5, 'MaxRange', 80);
% Load lidar data
lidarData = load('lidar_scan.mat'); % Contains scan and pose variables
% SLAM processing loop
for i = 1:length(lidarData.scan)
% Add scan data to SLAM system
scan = lidarData.scan{i};
pose = lidarData.pose(i,:);
slamObj.addScan(scan, pose);
% Visualize (every 10 frames)
if mod(i,10)==0
figure(1);
show(slamObj);
title(sprintf('SLAM Progress: %d/%d', i, length(lidarData.scan)));
drawnow;
end
end
% Optimize map
slamObj.optimizeMap;
% Save results
save('slam_result.mat', 'slamObj');
Autonomous Driving Decision and Planning
Path Planning and Behavior Decision:
% Initialize autonomous driving system
ads = drivingScenario;
road(ads, [0 0; 100 0]); % Create straight road
egoCar = vehicle(ads, 'Position', [0 0 0]);
% Set obstacles
obstacleCar = vehicle(ads, 'Position', [30 2 0]);
waypoints = [30 2 0; 60 2 0; 90 2 0];
speed = 10; % m/s
trajectory = waypointTrajectory(waypoints, 'TimeOfArrival', [0 2 4], 'Velocity', [speed 0 0]);
simulate(ads, trajectory);
% Behavior decision
currentStates = detect(ads, egoCar);
decision = behaviorPlanner(currentStates);
% Path planning
pathPlanner = pathPlannerRRT(ads);
startPose = [egoCar.Position, egoCar.Yaw];
goalPose = [100 0 0];
refPath = plan(pathPlanner, startPose, goalPose);
% Trajectory generation
trajectory = generateTrajectory(refPath, egoCar.Velocity);
% Visualize results
figure;
plotScenario(ads);
hold on;
plot(refPath, 'LineWidth', 2);
plot(egoCar.Position(1), egoCar.Position(2), 'go', 'MarkerSize', 10);
title('Autonomous Driving Path Planning');
Sensor Fusion and Object Tracking:
% Initialize multi-object tracker
tracker = multiObjectTracker('FilterInitializationFcn', @initCVFilter, ...
'AssignmentThreshold', [50 inf], 'DeletionThreshold', 10);
% Simulate sensor data (radar + camera)
radarDetections = detectRadar(ads); % Custom radar detection function
cameraDetections = detectCamera(ads); % Custom camera detection function
% Data association and tracking
allDetections = [radarDetections; cameraDetections];
[confirmedTracks, ~] = updateTracks(tracker, allDetections);
% Visualize tracking results
figure;
showScenario(ads);
hold on;
for i = 1:length(confirmedTracks)
track = confirmedTracks(i);
plot(track.Position(1), track.Position(2), 'ro', 'MarkerSize', 8);
end
title('Multi-Sensor Object Tracking');



