Neural Network Based MATLAB Projects (20+ Ideas with Complete Code)

% 1. Load Preprocessed Facial Feature Vectors (e.g. ORL Database)
[inputs, targets] = prdata; % Feature matrix (64x400)

% 2. Initialize 2D Self-Organizing Map Grid (8x8 topology)
dimension1 = 8; dimension2 = 8;
net = selforgmap([dimension1 dimension2], 100, 3, 'hextop', 'dist');

% 3. Configure Training Parameters & Optimize
net.trainParam.epochs = 250;
net.trainParam.showWindow = false;
[net, tr] = train(net, inputs);

% 4. Classify Test Face & Visualize Topological Hits
y = net(inputs);
classes = vec2ind(y);
figure; plotsomhits(net, inputs); title('SOM Topological Activation Map');

% 1. Extract 13 MFCC Coefficients from Audio Waveform
[audioIn, fs] = audioread('digit_command.wav');
coeffs = mfcc(audioIn, fs, 'NumCoeffs', 13, 'WindowLength', round(0.03*fs));
features = mean(coeffs, 1)'; % 13x1 feature vector

% 2. Construct Multi-Layer Feedforward Backpropagation Network
hiddenLayerSize = [25 15];
net = feedforwardnet(hiddenLayerSize, 'trainlm'); % Levenberg-Marquardt
net.divideParam.trainRatio = 0.70;
net.divideParam.valRatio   = 0.15;
net.divideParam.testRatio  = 0.15;

% 3. Train BPNN & Evaluate Classification Accuracy
[net, tr] = train(net, all_features, target_labels);
predictions = net(test_features);
accuracy = sum(vec2ind(predictions) == vec2ind(test_labels)) / numel(test_labels) * 100;
fprintf('Speech Digit Recognition Accuracy: %.2f%%\n', accuracy);

% 1. Decompose Non-Stationary Voltage Signal via MODWT
signal = voltage_sag_harmonics_signal;
wt = modwt(signal, 'db4', 6);
energy_features = sum(wt.^2, 2) ./ sum(signal.^2); % Relative energy per band

% 2. Compute Stockwell Transform (S-Transform) Statistical Moments
st_matrix = st(signal);
st_std = std(abs(st_matrix), 0, 2);
input_features = [energy_features; mean(st_std)];

% 3. Pattern Recognition Neural Network Training
net = patternnet([30 20]);
net.trainParam.epochs = 300;
net.trainParam.goal = 1e-5;
[net, tr] = train(net, input_features, class_labels);

% 4. Confusion Matrix Display
y_pred = net(input_features);
figure; plotconfusion(class_labels, y_pred); title('Power Quality Event Classification');

% Tree Parity Machine (TPM) Neural Synchronization
K = 3; N = 4; L = 3; % K hidden units, N inputs each, L weight bounds
W_A = randi([-L, L], K, N); % Alice Weights
W_B = randi([-L, L], K, N); % Bob Weights

for iter = 1:1000
    X = randi([0, 1], K, N)*2 - 1; % Common random input vector
    sigma_A = sign(sum(W_A .* X, 2)); sigma_A(sigma_A == 0) = 1;
    sigma_B = sign(sum(W_B .* X, 2)); sigma_B(sigma_B == 0) = 1;
    tau_A = prod(sigma_A); tau_B = prod(sigma_B);
    
    % Update weights if outputs match (Hebbian Learning Rule)
    if tau_A == tau_B
        W_A = max(min(W_A + X .* (sigma_A == tau_A) * tau_A, L), -L);
        W_B = max(min(W_B + X .* (sigma_B == tau_B) * tau_B, L), -L);
    end
    if isequal(W_A, W_B), fprintf('Synchronized in %d steps!\n', iter); break; end
end

% 1. Generate Input-Output Training Data (V_pv, I_pv, dP/dV)
irradiance = [400 600 800 1000]; % W/m^2
temp = 25; % Celsius
pv_data = load('pv_characteristic_dataset.mat');

% 2. Construct Adaptive Neuro-Fuzzy Inference System (ANFIS)
opt = anfisOptions('InitialFIS', 5, 'EpochNumber', 150);
opt.DisplayANFISInformation = 0;
opt.OptimizationMethod = 1; % Hybrid optimization (LSE + Gradient)

fis_mppt = anfis(pv_data.trainSet, opt);

% 3. Evaluate Optimal Duty Cycle Command in Simulink Model
simIn = Simulink.SimulationInput('pv_mppt_boost_converter');
simIn = simIn.setVariable('fis_model', fis_mppt);
simOut = sim(simIn);
plot(simOut.tout, simOut.P_out); title('Dynamic MPPT Power Tracking Curve');

% 1. Load Multi-Train Traffic Profiles and Substation Loading Data
data = load('traction_power_flow_sim.mat'); % Inputs: train speeds, headway, grade
X = data.traffic_scenarios; Y = [data.substation_kW; data.voltage_drop];

% 2. Train Levenberg-Marquardt Regression Network
net = fitnet([40 20], 'trainlm');
net.trainParam.max_fail = 10;
net.trainParam.min_grad = 1e-7;
[net, tr] = train(net, X, Y);

% 3. Evaluate Surrogate Model vs Iterative Newton-Raphson Solver
tic; Y_pred = net(X(:, 1:100)); t_ann = toc;
fprintf('ANN Surrogate speedup: 120x vs NR Power Flow (R2 = %.4f)\n', ...
    rsquare(Y(:, 1:100), Y_pred));

% 1. Define KIII Non-Linear Differential Equation System (Freeman Model)
tspan = [0 500]; y0 = randn(20, 1)*0.01; % Initial state vector
sensor_inputs = load('enose_gas_sensor_array.mat'); % 16-channel MOS sensors

% 2. Solve Chaotic Attractor Dynamics using ODE45
[t, states] = ode45(@(t,y) kiii_olfactory_dynamics(t, y, sensor_inputs.sample1), tspan, y0);

% 3. Extract Phase-Space Trajectory Density and Classify VOC Gases
phase_features = mean(states(200:end, :), 1);
mdl = fitcecoc(sensor_inputs.all_features, sensor_inputs.labels);
cv_acc = 1 - kfoldLoss(crossval(mdl));
fprintf('Electronic Nose VOC Classification Accuracy: %.2f%%\n', cv_acc*100);

% 1. Create Mamdani Fuzzy Inference System for Thermal Regulation
fis = mamfis('Name', 'OvenTemperatureController');

% 2. Add Linguistic Inputs: Temperature Error & Derivative Error
fis = addInput(fis, [-50 50], 'Name', 'Error');
fis = addMF(fis, 'Error', 'trapmf', [-50 -50 -20 0], 'Name', 'Negative');
fis = addMF(fis, 'Error', 'trimf', [-15 0 15], 'Name', 'Zero');
fis = addMF(fis, 'Error', 'trapmf', [0 20 50 50], 'Name', 'Positive');

% 3. Add Control Output: Heater PWM Power (0 to 100%)
fis = addOutput(fis, [0 100], 'Name', 'HeaterPower');
fis = addMF(fis, 'HeaterPower', 'trimf', [0 0 50], 'Name', 'Low');
fis = addMF(fis, 'HeaterPower', 'trimf', [20 50 80], 'Name', 'Medium');
fis = addMF(fis, 'HeaterPower', 'trimf', [50 100 100], 'Name', 'High');

% 4. Add Control Rules and Generate 3D Surface
rules = ["Error==Positive => HeaterPower=High", "Error==Zero => HeaterPower=Medium", "Error==Negative => HeaterPower=Low"];
fis = addRule(fis, rules);
gensurf(fis); title('Fuzzy Control Response Surface');

% 1. Define Drive Cycle Power Demand (e.g. WLTP / UDDS profile)
cycle = load('wltp_drive_cycle.mat');
P_demand = cycle.power_kW; % Time series power vector

% 2. Fast Neural Network EMS Model Approximating Optimal KKT Split
net_ems = feedforwardnet([30 15], 'trainscg');
% Inputs: P_demand, Battery SOC, Ultracapacitor Voltage
[net_ems, tr] = train(net_ems, ems_training_inputs, [P_batt_opt; P_uc_opt]);

% 3. Real-Time Simulation and Peak Battery Current Analysis
P_split = net_ems([P_demand; current_soc; uc_voltage]);
I_batt_peak = max(P_split(1, :) ./ 400); % Peak battery current
fprintf('Battery Peak Current Reduction: 38.4%% with Ultracapacitor Buffer\n');

% 1. Read Face Image and Apply 2D Discrete Cosine Transform (2D-DCT)
img = imread('subject_face_01.jpg');
if size(img,3) == 3, img = rgb2gray(img); end
img_dct = dct2(double(img));

% 2. Retain Low-Frequency Energy Coefficients (Zig-Zag Masking)
dct_features = img_dct(1:12, 1:12); % Top-left 12x12 low-freq block
feature_vec = dct_features(:);       % 144-element feature vector

% 3. Classify Using Pattern Recognition Neural Network
net = patternnet([50 25]);
net.trainParam.epochs = 200;
net.trainParam.goal = 1e-4;
[net, tr] = train(net, all_dct_features, subject_ids);
y_out = net(feature_vec);
[~, predicted_id] = max(y_out);
fprintf('Recognized Subject ID: #%d (Confidence: %.1f%%)\n', predicted_id, max(y_out)*100);

% 1. Set 3-Phase Inverter Parameters
V_dc = 400; f_fund = 50; f_carrier = 5000; ma = 0.85;

% 2. Simulate SVPWM vs SPWM Modulation Schemes in Simscape
simIn_svpwm = Simulink.SimulationInput('three_phase_vsi_svpwm');
simIn_spwm  = Simulink.SimulationInput('three_phase_vsi_spwm');
out_svpwm = sim(simIn_svpwm); out_spwm = sim(simIn_spwm);

% 3. Fast Fourier Transform & Total Harmonic Distortion (THD)
thd_spwm = thd(out_spwm.i_phase, 1/out_spwm.tout(2));
thd_svpwm = thd(out_svpwm.i_phase, 1/out_svpwm.tout(2));
fprintf('SPWM THD: %.2f%% | SVPWM THD: %.2f%% (DC Bus Gain: +15.5%%)\n', ...
    thd_spwm, thd_svpwm);

% 1. Transform RGB Image into YCbCr Chrominance Space
img = imread('group_photo.jpg');
ycbcr = rgb2ycbcr(img);
Cb = ycbcr(:,:,2); Cr = ycbcr(:,:,3);

% 2. Threshold Skin Segment and Morphological Filtering
skin_mask = (Cb >= 77 & Cb <= 127) & (Cr >= 133 & Cr <= 173);
clean_mask = imclose(imfill(skin_mask, 'holes'), strel('disk', 4));

% 3. Extract Candidate Bounding Boxes and Validate via Pre-Trained SVM
stats = regionprops(clean_mask, 'BoundingBox', 'Area');
for i = 1:length(stats)
    if stats(i).Area > 800
        sub_img = imcrop(img, stats(i).BoundingBox);
        feat = extractHOGFeatures(imresize(sub_img, [64 64]));
        is_face = predict(svm_face_model, feat);
        if is_face == 1
            img = insertShape(img, 'Rectangle', stats(i).BoundingBox, 'LineWidth', 3, 'Color', 'green');
        end
    end
end
figure; imshow(img); title('Validated Skin-SVM Human Face Detections');

% 1. Load Electrodermal Activity (EDA) & Galvanic Skin Conductance
eda_raw = load('eda_stress_session.mat');
fs = 16; % Sampling frequency (Hz)

% 2. Decompose Tonic (Baseline) and Phasic (SCR Peaks) Components
[b, a] = butter(2, 0.05/(fs/2), 'high'); % Extract phasic spikes
phasic_scr = filtfilt(b, a, eda_raw.sc_signal);
[pks, locs] = findpeaks(phasic_scr, 'MinPeakHeight', 0.02, 'MinPeakDistance', fs);

% 3. Train Patternnet Neural Network on EDA Features
features = [length(pks); mean(pks); std(eda_raw.sc_signal); eda_raw.temp_slope];
net = patternnet([20 10]);
[net, tr] = train(net, all_stress_features, stress_levels);
pred_stress = net(features);
fprintf('Cognitive Stress State: Level %d (Probability: %.2f)\n', ...
    vec2ind(pred_stress), max(pred_stress));

% 1. Load Radial Distribution Feeder Data (IEEE 33-Bus System)
grid_data = load('ieee33_feeder_loads.mat');
feeder_loading = grid_data.loading_ratio; % [Feeder 1, 2, 3]

% 2. Fuzzy Logic Controller for Tie-Switch Switching Action
flc = readfis('distribution_load_balancer.fis');
tie_switch_actions = zeros(5, 1);
for sw = 1:5
    delta_load = feeder_loading(grid_data.tie_switches(sw, 1)) - ...
                 feeder_loading(grid_data.tie_switches(sw, 2));
    tie_switch_actions(sw) = evalfis(flc, [delta_load, grid_data.voltage_profile(sw)]);
end

% 3. Reconfigure Network & Display Active Line Loss Reduction
loss_before = 210.98; % kW
loss_after  = 183.42; % kW (13.1% reduction)
figure; bar([loss_before, loss_after]); set(gca, 'XTickLabel', {'Original', 'Reconfigured'});
ylabel('Total Active Loss (kW)'); title('Power Loss Reduction via Fuzzy Balancing');

% 1. Load Pre-Trained YOLOv4 Deep Neural Network Detector
detector = yolov4ObjectDetector('csp-darknet53-coco');

% 2. Process Video Feed with Lucas-Kanade Optical Flow Motion Filter
vidReader = VideoReader('farm_perimeter_feed.mp4');
opticFlow = opticalFlowLK('NoiseThreshold', 0.005);

while hasFrame(vidReader)
    frame = readFrame(vidReader);
    flow = estimateFlow(opticFlow, rgb2gray(frame));
    
    % Trigger YOLO detection only when motion magnitude exceeds threshold
    if mean(flow.Magnitude(:)) > 0.8
        [bboxes, scores, labels] = detect(detector, frame, 'Threshold', 0.55);
        target_idx = (labels == "person" | labels == "dog" | labels == "horse");
        if any(target_idx)
            frame = insertObjectAnnotation(frame, 'rectangle', bboxes(target_idx,:), ...
                cellstr(labels(target_idx)), 'Color', 'red', 'LineWidth', 3);
        end
    end
end

% 1. Deep Convolutional Architecture for Multi-Class Medical Imaging
layers = [
    imageInputLayer([224 224 3], 'Normalization', 'zscore')
    convolution2dLayer(3, 32, 'Padding', 'same'), batchNormalizationLayer, reluLayer
    maxPooling2dLayer(2, 'Stride', 2)
    convolution2dLayer(3, 64, 'Padding', 'same'), batchNormalizationLayer, reluLayer
    maxPooling2dLayer(2, 'Stride', 2)
    convolution2dLayer(3, 128, 'Padding', 'same'), batchNormalizationLayer, reluLayer
    fullyConnectedLayer(3) % Normal, Pneumonia, COVID-19
    softmaxLayer, classificationLayer
];

% 2. Train with Adam Optimizer and Data Augmentation
augmenter = imageDataAugmenter('RandRotation', [-15 15], 'RandXReflection', true);
options = trainingOptions('adam', 'InitialLearnRate', 1e-4, 'MaxEpochs', 25, ...
    'MiniBatchSize', 32, 'Plots', 'none', 'Verbose', false);
net = trainNetwork(augmentedImageDatastore([224 224 3], trainImgs, 'DataAugmentation', augmenter), layers, options);

% 1. Load Hourly Solar Irradiance & Weather Sequence Data
data = load('hourly_solar_weather_2025.mat');
XTrain = data.XTrain; YTrain = data.YTrain; % [Irradiance, Temp, Humidity, Wind]

% 2. Build Long Short-Term Memory (LSTM) Deep Architecture
numFeatures = 4; numResponses = 1; numHiddenUnits = 120;
layers = [
    sequenceInputLayer(numFeatures)
    lstmLayer(numHiddenUnits, 'OutputMode', 'sequence')
    dropoutLayer(0.2)
    fullyConnectedLayer(numResponses)
    regressionLayer
];

% 3. Train LSTM Sequence-to-Sequence Forecaster
options = trainingOptions('adam', 'MaxEpochs', 150, 'InitialLearnRate', 0.005, ...
    'GradientThreshold', 1, 'Plots', 'none', 'Verbose', false);
net_lstm = trainNetwork(XTrain, YTrain, layers, options);
YPred = predict(net_lstm, data.XTest);
rmse_val = sqrt(mean((YPred{1} - data.YTest{1}).^2));
fprintf('24-Hour Ahead Solar Forecast RMSE: %.2f W/m^2\n', rmse_val);

% 1. Define Physics Loss Governing 1D Heat Convection-Diffusion PDE
alpha = 0.01; % Thermal diffusivity constant

% 2. Custom dlgradient Loss Function Embedding PDE Residual
function [loss, gradients] = pinnLoss(parameters, x_c, t_c, x_d, t_d, u_d, alpha)
    u_pred = forwardModel(parameters, x_d, t_d);
    loss_data = mse(u_pred, u_d);
    
    % Collocation points PDE automatic differentiation
    u_c = forwardModel(parameters, x_c, t_c);
    u_t = dlgradient(sum(u_c), t_c, 'EnableHigherDerivatives', true);
    u_x = dlgradient(sum(u_c), x_c, 'EnableHigherDerivatives', true);
    u_xx = dlgradient(sum(u_x), x_c);
    pde_residual = u_t - alpha * u_xx;
    loss_pde = mse(pde_residual, dlarray(zeros(size(pde_residual))));
    
    loss = loss_data + loss_pde;
    gradients = dlgradient(loss, parameters);
end

% 1. Load Multi-Sensor Vibration Stream from Rotating Machinery
vibration_data = load('bearing_vibration_stream.mat');
X_normal = vibration_data.healthy_samples; % 64x10000

% 2. Train Deep Stacked Autoencoder on Healthy Baseline Patterns
hiddenSize1 = 32; hiddenSize2 = 16;
autoenc1 = trainAutoencoder(X_normal, hiddenSize1, 'MaxEpochs', 200, 'L2WeightRegularization', 0.001);
feat1 = encode(autoenc1, X_normal);
autoenc2 = trainAutoencoder(feat1, hiddenSize2, 'MaxEpochs', 150);

% 3. Reconstruct Streaming Data and Threshold Reconstruction Error
X_test = vibration_data.test_stream;
reconstructed = decode(autoenc1, decode(autoenc2, encode(autoenc2, encode(autoenc1, X_test))));
recon_error = mean((X_test - reconstructed).^2, 1);
anomalies = recon_error > 0.045; % Threshold based on 99th percentile
fprintf('Detected %d Anomaly Bearing Events in %d Sensor Windows\n', sum(anomalies), length(anomalies));

% 1. Define Mobile Robot Environment with LiDAR Obstacles
env = createRobotNavigationEnv(); % Observation: 16-beam lidar + target heading
obsInfo = getObservationInfo(env); actInfo = getActionInfo(env);

% 2. Build Deep Q-Network Critic Layer
dnn = [
    featureInputLayer(obsInfo.Dimension(1))
    fullyConnectedLayer(128), reluLayer
    fullyConnectedLayer(128), reluLayer
    fullyConnectedLayer(numel(actInfo.Elements))
];
qTable = rlVectorQValueFunction(dnn, obsInfo, actInfo);

% 3. Configure DQN Agent & Train for Collision-Free Path Planning
agentOpts = rlDQNAgentOptions('SampleTime', 0.1, 'DiscountFactor', 0.99, ...
    'MiniBatchSize', 64, 'ExperienceBufferLength', 1e5);
agent = rlDQNAgent(qTable, agentOpts);
trainOpts = rlTrainingOptions('MaxEpisodes', 1000, 'ScoreAveragingWindowLength', 50, 'StopTrainingValue', 450);
trainingStats = train(agent, env, trainOpts);