Lesson 12-Advanced Toolbox Practice

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');
Share your love