net = dlnetwork(lgraph);           % Create dlnetwork
net = trainnet(ds, net, "crossentropy", opts);  % Train with loss function

% WRONG: Using uint8 directly
net = trainNetwork(uint8Images, labels, layers, options);  % Poor convergence

% CORRECT: Normalize to [0,1] or [-1,1]
images = im2single(uint8Images);  % Now [0,1]
% Or for pretrained networks expecting specific preprocessing:
images = (im2single(uint8Images) - 0.485) / 0.229;  % ImageNet normalization

% Check network input size
inputSize = net.Layers(1).InputSize;  % e.g., [224 224 3]

% Resize images to match
augDs = augmentedImageDatastore(inputSize(1:2), imds);
% Or
images = imresize(images, inputSize(1:2));

% Format: S=Spatial, C=Channel, B=Batch, T=Time, U=Unspecified
x = dlarray(data, 'SSCB');    % H×W×C×B (standard image batch)
x = dlarray(data, 'SSSCB');   % H×W×D×C×B (3D volume batch)
x = dlarray(data, 'CBT');     % C×B×T (sequence)

% Common error: wrong format causes dimension mismatch
% WRONG: x = dlarray(data, 'BCSS');  % Batch and Channel swapped

% Gradients only flow through dlarray operations
% WRONG: Using non-differentiable ops
mask = Y > 0.5;  % Thresholding breaks gradient flow

% CORRECT: Use soft operations
mask = sigmoid((Y - 0.5) * 10);  % Differentiable approximation

% Check available GPU memory before training
gpu = gpuDevice;
fprintf('Available: %.2f GB\n', gpu.AvailableMemory/1e9);

% Reduce batch size if OOM
options = trainingOptions('adam', 'MiniBatchSize', 8);  % Start small

% Clear GPU memory between experiments
reset(gpuDevice);

Task?
├── Image Classification
│   ├── Binary/Multiclass → trainNetwork + softmax + crossentropy
│   └── Multi-label → trainNetwork + sigmoid + binary crossentropy
├── Segmentation
│   ├── Semantic (pixel labels) → unetLayers/deeplabv3plusLayers + semanticseg
│   ├── Instance (object masks) → Mask R-CNN
│   └── 3D volumetric → unet3dLayers
├── Object Detection
│   ├── Real-time → YOLO v4 (yolov4ObjectDetector)
│   ├── High accuracy → Faster R-CNN (fasterRCNNObjectDetector)
│   └── Small objects → RetinaNet
├── Custom Architecture
│   └── dlnetwork + custom training loop + dlfeval/dlgradient
└── Generative
    ├── Image synthesis → GAN (generator + discriminator)
    └── Variational → VAE with reparameterization

% Load pretrained network
net = resnet50;
lgraph = layerGraph(net);

% Replace final layers for your classes
numClasses = 4;  % e.g., Normal, Pneumonia, COVID, TB
lgraph = removeLayers(lgraph, {'fc1000', 'fc1000_softmax', 'ClassificationLayer_fc1000'});
newLayers = [
    fullyConnectedLayer(numClasses, 'Name', 'fc_new')
    softmaxLayer('Name', 'softmax_new')
    classificationLayer('Name', 'output')];
lgraph = addLayers(lgraph, newLayers);
lgraph = connectLayers(lgraph, 'avg_pool', 'fc_new');

% Train
options = trainingOptions('adam', ...
    'MaxEpochs', 10, ...
    'MiniBatchSize', 32, ...
    'InitialLearnRate', 1e-4, ...
    'ValidationData', valDs, ...
    'Plots', 'training-progress');
trainedNet = trainNetwork(trainDs, lgraph, options);  % Legacy API
% Modern: net = trainnet(trainDs, dlnetwork(lgraph), "crossentropy", options);

% Create U-Net for medical image segmentation
imageSize = [256 256 1];
numClasses = 2;  % Background + Lesion

% Legacy API (deprecated in R2024b+, use unet() instead):
lgraph = unetLayers(imageSize, numClasses, ...
    'EncoderDepth', 4, ...
    'NumFirstEncoderFilters', 64);  % Default is 64, not 32

% Modern API (R2024b+):
% net = unet(imageSize, numClasses, EncoderDepth=4);

% Prepare pixel label datastore
classNames = ["Background", "Lesion"];
pixelLabelIDs = [0, 1];
pxds = pixelLabelDatastore('masks/', classNames, pixelLabelIDs);
ds = combine(imageDatastore('images/'), pxds);

% Train with dice loss
options = trainingOptions('adam', ...
    'MaxEpochs', 50, ...
    'MiniBatchSize', 8, ...
    'InitialLearnRate', 1e-3);
net = trainNetwork(ds, lgraph, options);  % Legacy API
% Modern: net = trainnet(ds, dlnetwork(lgraph), "crossentropy", options);

% Inference
mask = semanticseg(testImage, net);

% For advanced control: custom loss, metrics, logging
net = dlnetwork(lgraph);
numEpochs = 50;
learnRate = 1e-3;
[avgGrad, avgSqGrad] = deal([]);

for epoch = 1:numEpochs
    shuffle(mbq);
    while hasdata(mbq)
        [X, Y] = next(mbq);

        % Forward + backward
        [loss, gradients, state] = dlfeval(@modelLoss, net, X, Y);
        net.State = state;

        % Update with Adam
        [net, avgGrad, avgSqGrad] = adamupdate(net, gradients, ...
            avgGrad, avgSqGrad, iteration, learnRate);
    end
end

function [loss, gradients, state] = modelLoss(net, X, Y)
    [Ypred, state] = forward(net, X);
    loss = crossentropy(Ypred, Y);
    gradients = dlgradient(loss, net.Learnables);
end

% Create YOLO v4 detector
detector = yolov4ObjectDetector('csp-darknet53-coco');

% For custom classes, create from scratch
name = "nodule_detector";
classes = ["nodule"];
anchorBoxes = {[32 32; 64 64]; [128 128; 256 256]};  % Multi-scale
detector = yolov4ObjectDetector(name, classes, anchorBoxes, ...
    'InputSize', [416 416 3]);

% Train
options = trainingOptions('adam', ...
    'MaxEpochs', 80, ...
    'MiniBatchSize', 8, ...
    'InitialLearnRate', 1e-3);
[detector, info] = trainYOLOv4ObjectDetector(trainData, detector, options);

% Detect
[bboxes, scores, labels] = detect(detector, testImage);

% Before DL: enhance, denoise, normalize
img = adapthisteq(img);                    % CLAHE
img = imgaussfilt(img, 1.5);               % Denoise
img = im2single(img);                       % Normalize

% Multi-scale features as network input
[C, S] = wavedec2(img, 3, 'db4');
features = cat(3, appcoef2(C,S,'db4'), ...
    detcoef2('h',C,S,1), detcoef2('v',C,S,1), detcoef2('d',C,S,1));

% Load with spatial referencing
V = medicalVolume('brain.nii');
% Process slices for DL
for k = 1:V.NumTransverseSlices
    slice = extractSlice(V, k, 'transverse');
    prediction = semanticseg(slice, net);
end