Adding demo files

Author: mathinking

CIFARTraining/cifar10CNN.m

@@ -0,0 +1,141 @@
+%% Classifying the CIFAR-10 dataset using Convolutional Neural Networks
+% This example shows how to train a Convolutional Neural Network (CNN) from
+% scratch using the dataset CIFAR10.
+%
+% Data Credit: Krizhevsky, A., & Hinton, G. (2009). Learning multiple 
+% layers of features from tiny images.
+
+% Copyright 2016 The MathWorks, Inc.
+
+%% Download the CIFAR-10 dataset
+if ~exist('cifar-10-batches-mat','dir')
+    cifar10Dataset = 'cifar-10-matlab';
+    disp('Downloading 174MB CIFAR-10 dataset...');   
+    websave([cifar10Dataset,'.tar.gz'],...
+        ['https://www.cs.toronto.edu/~kriz/',cifar10Dataset,'.tar.gz']);
+    gunzip([cifar10Dataset,'.tar.gz'])
+    delete([cifar10Dataset,'.tar.gz'])
+    untar([cifar10Dataset,'.tar'])
+    delete([cifar10Dataset,'.tar'])
+end    
+   
+%% Prepare the CIFAR-10 dataset
+if ~exist('cifar10Train','dir')
+    disp('Saving the Images in folders. This might take some time...');    
+    saveCIFAR10AsFolderOfImages('cifar-10-batches-mat', pwd, true);
+end
+
+%% Load image CIFAR-10 Training dataset (50000 32x32 colour images in 10 classes)
+imsetTrain = imageSet('cifar10Train','recursive');
+
+%% Display Sampling of Image Data
+numClasses = size(imsetTrain,2);
+imagesPerClass = 10;
+imagesInMontage = cell(imagesPerClass,numClasses);
+for i = 1:size(imagesInMontage,2)
+    imagesInMontage(:,i) = ...
+        imsetTrain(i).ImageLocation(randi(imsetTrain(i).Count, 1, ...
+        imagesPerClass));
+end
+
+montage({imagesInMontage{:}},'Size',[numClasses,imagesPerClass]);
+title('Sample of Training Data (Credit:Learning Multiple Layers of Features from Tiny Images, Alex Krizhevsky, 2009.)')
+
+%% Prepare the data for Training
+% Read all images and store them in a 4D uint8 input array for training,
+% with its corresponding class
+
+trainNames = {imsetTrain.Description};
+XTrain = zeros(32,32,3,sum([imsetTrain.Count]),'uint8');
+TTrain = categorical(discretize((1:sum([imsetTrain.Count]))',...
+    [0,cumsum([imsetTrain.Count])],'categorical',trainNames));
+
+j = 0;
+tic;
+for c = 1:length(imsetTrain)
+    for i = 1:imsetTrain(c).Count
+        XTrain(:,:,:,i+j) = read(imsetTrain(c),i);
+    end
+    j = j + imsetTrain(c).Count;
+end
+toc;
+
+%% Define a CNN architecture
+conv1 = convolution2dLayer(5,32,'Padding',2,...
+                     'BiasLearnRateFactor',2);
+conv1.Weights = gpuArray(single(randn([5 5 3 32])*0.0001));
+fc1 = fullyConnectedLayer(64,'BiasLearnRateFactor',2);
+fc1.Weights = gpuArray(single(randn([64 576])*0.1));
+fc2 = fullyConnectedLayer(10,'BiasLearnRateFactor',2);
+fc2.Weights = gpuArray(single(randn([10 64])*0.1));
+
+layers = [ ...
+    imageInputLayer([32 32 3]);
+    conv1;
+    maxPooling2dLayer(3,'Stride',2);
+    reluLayer();
+    convolution2dLayer(5,32,'Padding',2,'BiasLearnRateFactor',2);
+    reluLayer();
+    averagePooling2dLayer(3,'Stride',2);
+    convolution2dLayer(5,64,'Padding',2,'BiasLearnRateFactor',2);
+    reluLayer();
+    averagePooling2dLayer(3,'Stride',2);
+    fc1;
+    reluLayer();
+    fc2;
+    softmaxLayer()
+    classificationLayer()];
+
+% Define the training options.
+opts = trainingOptions('sgdm', ...
+    'InitialLearnRate', 0.001, ...
+    'LearnRateSchedule', 'piecewise', ...
+    'LearnRateDropFactor', 0.1, ...
+    'LearnRateDropPeriod', 8, ...
+    'L2Regularization', 0.004, ...
+    'MaxEpochs', 10, ...
+    'MiniBatchSize', 100, ...
+    'Verbose', true);
+
+%% Training the CNN
+[net, info] = trainNetwork(XTrain, TTrain, layers, opts);
+
+% Alternative way using imageDataStore
+% imdsTrain = imageDatastore(fullfile(pwd,'cifar10Train'),...
+%     'IncludeSubfolders',true,'LabelSource','foldernames');
+% [net, info] = trainNetwork(imdsTrain, layers, opts);
+
+%%  Visualise the first layer weights.
+figure;
+montage(mat2gray(gather(net.Layers(2).Weights)));
+title('First Layer Weights');
+
+%% Load Test Data
+
+imsetTest = imageSet('cifar10Test','recursive');
+
+testNames = {imsetTest.Description};
+XTest = zeros(32,32,3,sum([imsetTest.Count]),'uint8');
+TTest = categorical(discretize((1:sum([imsetTest.Count]))',...
+    [0,cumsum([imsetTest.Count])],'categorical',testNames));
+j = 0;
+tic;
+for c = 1:length(imsetTest)
+    for i = 1:imsetTest(c).Count
+        XTest(:,:,:,i+j) = read(imsetTest(c),i);
+    end
+    j = j + imsetTest(c).Count;
+end
+toc;
+
+%% Run the network on the test set
+
+YTest = classify(net, XTest);
+
+% Alternative way using imageDataStore
+% imdsTest = imageDatastore(fullfile(pwd, 'cifar10Test'),...
+%     'IncludeSubfolders',true,'LabelSource','foldernames');
+% YTest = classify(net, imdsTest);
+
+% Calculate the accuracy.
+accuracy = sum(YTest == TTest)/numel(TTest)

CIFARTraining/loadCIFAR10AsAFourDimensionalArray.m

@@ -0,0 +1,33 @@
+% Copyright 2016 The MathWorks, Inc.
+
+function [XTrain, TTrain, XTest, TTest] = loadCIFAR10AsAFourDimensionalArray()
+
+% loadCIFAR10AsAFourDimensionalArray   Load the CIFAR-10 data
+
+[XTrain1, TTrain1] = iLoadBatchAsFourDimensionalArray('data_batch_1.mat');
+[XTrain2, TTrain2] = iLoadBatchAsFourDimensionalArray('data_batch_2.mat');
+[XTrain3, TTrain3] = iLoadBatchAsFourDimensionalArray('data_batch_3.mat');
+[XTrain4, TTrain4] = iLoadBatchAsFourDimensionalArray('data_batch_4.mat');
+[XTrain5, TTrain5] = iLoadBatchAsFourDimensionalArray('data_batch_5.mat');
+
+XTrain = cat(4, XTrain1, XTrain2, XTrain3, XTrain4, XTrain5);
+TTrain = [TTrain1; TTrain2; TTrain3; TTrain4; TTrain5];
+
+[XTest, TTest] = iLoadBatchAsFourDimensionalArray('test_batch.mat');
+
+XTrain = double(XTrain);
+XTest = double(XTest);
+end
+
+function [XBatch, TBatch] = iLoadBatchAsFourDimensionalArray(batchFileName)
+load(batchFileName);
+XBatch = data';
+XBatch = reshape(XBatch, 32,32,3,[]);
+XBatch = permute(XBatch, [2 1 3 4]);
+TBatch = iConvertLabelsToCategorical(labels);
+end
+
+function categoricalLabels = iConvertLabelsToCategorical(integerLabels)
+load('batches.meta.mat');
+categoricalLabels = categorical(integerLabels, 0:9, label_names);
+end

CIFARTraining/saveCIFAR10AsFolderOfImages.m

@@ -0,0 +1,79 @@
+% Copyright 2016 The MathWorks, Inc.
+
+function saveCIFAR10AsFolderOfImages(inputPath, outputPath, varargin)
+% saveCIFAR10AsFolderOfImages   Save the CIFAR-10 dataset as a folder of images
+%   saveCIFAR10AsFolderOfImages(inputPath, outputPath) takes the CIFAR-10
+%   dataset located at inputPath and saves it as a folder of images to the
+%   directory outputPath. If inputPath or outputPath is an empty string, it
+%   is assumed that the current folder should be used.
+%
+%   saveCIFAR10AsFolderOfImages(..., labelDirectories) will save the
+%   CIFAR-10 data so that instances with the same label will be saved to
+%   sub-directories with the name of that label.
+
+% Check input directories are valid
+if(~isempty(inputPath))
+    assert(exist(inputPath,'dir') == 7);
+end
+if(~isempty(outputPath))
+    assert(exist(outputPath,'dir') == 7);
+end
+
+% Check if we want to save each set with the same labels to its own
+% directory.
+if(isempty(varargin))
+    labelDirectories = false;
+else
+    assert(nargin == 3);
+    labelDirectories = varargin{1};
+end
+
+% Set names for directories
+trainDirectoryName = 'cifar10Train';
+testDirectoryName = 'cifar10Test';
+
+% Create directories for the output
+mkdir(fullfile(outputPath, trainDirectoryName));
+mkdir(fullfile(outputPath, testDirectoryName));
+
+if(labelDirectories)
+    labelNames = {'airplane','automobile','bird','cat','deer','dog','frog','horse','ship','truck'};
+    iMakeTheseDirectories(fullfile(outputPath, trainDirectoryName), labelNames);
+    iMakeTheseDirectories(fullfile(outputPath, testDirectoryName), labelNames);
+    for i = 1:5
+        iLoadBatchAndWriteAsImagesToLabelFolders(fullfile(inputPath,['data_batch_' num2str(i) '.mat']), fullfile(outputPath, trainDirectoryName), labelNames, (i-1)*10000);
+    end
+    iLoadBatchAndWriteAsImagesToLabelFolders(fullfile(inputPath,'test_batch.mat'), fullfile(outputPath, testDirectoryName), labelNames, 0);
+else
+    for i = 1:5
+        iLoadBatchAndWriteAsImages(fullfile(inputPath,['data_batch_' num2str(i) '.mat']), fullfile(outputPath, trainDirectoryName), (i-1)*10000);
+    end
+    iLoadBatchAndWriteAsImages(fullfile(inputPath,'test_batch.mat'), fullfile(outputPath, testDirectoryName), 0);
+end
+end
+
+function iLoadBatchAndWriteAsImagesToLabelFolders(fullInputBatchPath, fullOutputDirectoryPath, labelNames, nameIndexOffset)
+load(fullInputBatchPath);
+data = data'; %#ok<NODEF>
+data = reshape(data, 32,32,3,[]);
+data = permute(data, [2 1 3 4]);
+for i = 1:size(data,4)
+    imwrite(data(:,:,:,i), fullfile(fullOutputDirectoryPath, labelNames{labels(i)+1}, ['image' num2str(i + nameIndexOffset) '.png']));
+end
+end
+
+function iLoadBatchAndWriteAsImages(fullInputBatchPath, fullOutputDirectoryPath, nameIndexOffset)
+load(fullInputBatchPath);
+data = data'; %#ok<NODEF>
+data = reshape(data, 32,32,3,[]);
+data = permute(data, [2 1 3 4]);
+for i = 1:size(data,4)
+    imwrite(data(:,:,:,i), fullfile(fullOutputDirectoryPath, ['image' num2str(i + nameIndexOffset) '.png']));
+end
+end
+
+function iMakeTheseDirectories(outputPath, directoryNames)
+for i = 1:numel(directoryNames)
+    mkdir(fullfile(outputPath, directoryNames{i}));
+end
+end

LICENSE.md

@@ -0,0 +1,27 @@
+Copyright (c) 2017, The MathWorks, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in
+      the documentation and/or other materials provided with the distribution.
+    * In all cases, the software is, and all modifications and derivatives
+      of the software shall be, licensed to you solely for use in conjunction
+      with MathWorks products and service offerings.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

README.md

@@ -0,0 +1,17 @@
+# DeepLearning-for-ComputerVision-with-MATLAB 
+[![View Example files for "Deep Learning for Computer Vision with MATLAB" Webinar on File Exchange](https://www.mathworks.com/matlabcentral/images/matlab-file-exchange.svg)](https://www.mathworks.com/matlabcentral/fileexchange/58030-example-files-for-deep-learning-for-computer-vision-with-matlab-webinar)
+
+These are the example files used in the webinar ["Aprendizaje Profundo para Visión Artificial con MATLAB" - Spanish](https://www.mathworks.com/videos/deep-learning-for-computer-vision-with-matlab-1540981496452.html) ("Deep Learning for Computer Vision with MATLAB").
+
+
+Deep Learning is an area of Machine Learning that uses multiple nonlinear processing layers to learn useful representations of features directly from data. This webinar shows the fundamentals of Deep Learning for Computer Vision and how to use Convolutional Neural Networks (popularly known as CNNs or ConvNets) to solve object classification/recognition problems.
+
+The source code consists of 3 different examples:
+1. Running a trained CNN (/WebcamClassification)
+2. Training a CNN from scratch (/CIFARTraining)
+3. Fine-tuning a pre-trained CNN. Transfer learning (/TransferLearning)
+Examples 1) and 3) make use AlexNet [1]. In order to download the trained CNN [2], run the file downloadAndPrepareCNN.m (if using R2016a) or download AlexNet Network support package (if using R2016b or later).
+
+References:
+[1] Krizhevsky, A., Sutskever, I., & Hinton, G. E. (2012). Imagenet classification with Deep Convolutional Neural Networks. Advances in Neural Information Processing Systems (pp. 1097-1105).
+[2] Vedaldi, A., & Lenc, K. (2015, October). MatConvNet: Convolutional Neural Networks for MATLAB. Proceedings of the 23rd ACM International Conference on Multimedia (pp. 689-692). ACM.

TransferLearning/DisplayImageMontage.m

@@ -0,0 +1,13 @@
+% Copyright 2016 The MathWorks, Inc.
+
+function DisplayImageMontage(cellArrayOfImages)
+% Displays a montage of images. Images are resized to handle different
+% image sizes.
+
+thumbnails = [];
+for i = 1:numel(cellArrayOfImages)
+    img = imread(cellArrayOfImages{i});
+    thumbnails = cat(4, thumbnails, imresize(img, [200 200]));
+end
+
+montage(thumbnails)

TransferLearning/TwoClassTransferLearning.m

@@ -0,0 +1,191 @@
+%% Fine Tuning A Deep Neural Network
+% This example shows how to fine tune a pre-trained deep convolutional
+% neural network (CNN) for a new recognition task.
+
+% Copyright 2016 The MathWorks, Inc.
+
+%% Load network
+cnnMatFile = fullfile(pwd, '..', 'networks', 'imagenet-cnn.mat');
+if ~exist(cnnMatFile,'file')
+    disp('Run downloadAndPrepareCNN.m to download and prepare the CNN')
+    return;
+end
+imagenet_cnn = load(cnnMatFile);
+net = imagenet_cnn.convnet;
+
+%% Look at structure of pre-trained network
+% Notice the last layer performs 1000 object classification
+net.Layers
+
+%% Perform net surgery
+% The pre-trained layers at the end of the network are designed to classify
+% 1000 objects. But we need to classify 2 different objects now. So the
+% first step in transfer learning is to replace the last 3 layers of the
+% pre-trained network with a set of layers that can classify 2 classes.
+
+% Get the layers from the network. the layers define the network
+% architecture and contain the learned weights. Here we only need to keep
+% everything except the last 3 layers.
+layers = net.Layers(1:end-3);
+
+% Add new fully connected layer for 2 categories.
+layers(end+1) = fullyConnectedLayer(2, 'Name', 'fc8_2')
+
+% Add the softmax layer and the classification layer which make up the
+% remaining portion of the networks classification layers.
+layers(end+1) = softmaxLayer('Name','prob_2');
+layers(end+1) = classificationLayer('Name','classificationLayer_2')
+
+% Modify image layer to add randcrop data augmentation. This increases the
+% diversity of training images. The size of the input images is set to the
+% original networks input size.
+layers(1) = imageInputLayer([227 227 3], 'DataAugmentation', 'randcrop');
+
+
+%% Setup learning rates for fine-tuning
+% For fine-tuning, we want to changed the network ever so slightly. How
+% much a network is changed during training is controlled by the learning
+% rates. Here we do not modify the learning rates of the original layers,
+% i.e. the ones before the last 3. The rates for these layers are already
+% pretty small so they don't need to be lowered further. You could even
+% freeze the weights of these early layers by setting the rates to zero.
+%
+% Instead we boost the learning rates of the new layers we added, so that
+% they change faster than the rest of the network. This way earlier layers
+% don't change that much and we quickly learn the weights of the newer
+% layer.
+
+% fc 8 - bump up learning rate for last layers
+layers(end-2).WeightLearnRateFactor = 100;
+layers(end-2).WeightL2Factor = 1;
+layers(end-2).BiasLearnRateFactor = 20;
+layers(end-2).BiasL2Factor = 0;
+
+%% Load Image Data
+% Now we get the training data. This was collected as traffic drove into
+% the MathWorks head office in Natick.
+%
+% Create an imageDataStore to read images
+location = 'VehicleData';
+imds = imageDatastore(location,'IncludeSubfolders',1,'LabelSource','foldernames');
+tbl = countEachLabel(imds);
+
+% Display a sampling of training images
+
+%% Display Sampling of Image Data
+% Notice that the cars and SUV look very similar
+imagesInMontage = cell(10,2);
+carFiles = imds.Files(imds.Labels == 'Car');
+suvFiles =  imds.Files(imds.Labels == 'SUV');
+imagesInMontage(:,1) =  carFiles(1:length(carFiles)/10:length(carFiles));
+imagesInMontage(:,2) =  suvFiles(1:length(suvFiles)/10:length(suvFiles));
+figure;
+subplot(1,2,1);
+DisplayImageMontage({imagesInMontage{:,1}});title('Cars');
+subplot(1,2,2);
+DisplayImageMontage({imagesInMontage{:,2}});title('SUV');
+
+%% Equalize number of images of each class in training set
+minSetCount = min(tbl{:,2}); % determine the smallest amount of images in a category
+% Use splitEachLabel method to trim the set.
+imds = splitEachLabel(imds, minSetCount);
+
+% Notice that each set now has exactly the same number of images.
+countEachLabel(imds)
+[trainingDS, testDS] = splitEachLabel(imds, 0.7,'randomize');
+% Convert labels to categoricals
+trainingDS.Labels = categorical(trainingDS.Labels);
+trainingDS.ReadFcn = @readFunctionTrain;
+
+%% Setup test data for validation
+testDS.Labels = categorical(testDS.Labels);
+testDS.ReadFcn = @readFunctionValidation;
+
+%% Fine-tune the Network
+
+miniBatchSize = 32; % lower this if your GPU runs out of memory.
+numImages = numel(trainingDS.Files);
+
+% Run training for 5000 iterations. Convert 20000 iterations into the
+% number of epochs this will be.
+numIterationsPerEpoch = numImages/miniBatchSize;
+%maxEpochs = round(20000/numIterationsPerEpoch);
+maxEpochs = 100;
+lr = 0.001;
+opts = trainingOptions('sgdm', ...
+    'InitialLearnRate', lr,...
+    'LearnRateSchedule', 'none',...
+    'L2Regularization', 0.0005, ...
+    'MaxEpochs', maxEpochs, ...
+    'MiniBatchSize', miniBatchSize);
+
+net = trainNetwork(trainingDS, layers, opts);
+% This could take over an hour to run.
+
+%% Test 2-class classifier on  validation set
+% Now run the network on the test data set to see how well it does:
+
+labels = classify(net, testDS, 'MiniBatchSize', 32);
+
+confMat = confusionmat(testDS.Labels, labels);
+confMat = bsxfun(@rdivide,confMat,sum(confMat,2));
+
+mean(diag(confMat))
+
+%% Run on Video Stream
+videoPlayer = vision.DeployableVideoPlayer;
+
+% Learn the background ( this takes a few seconds ) 
+foregroundDetector = vision.ForegroundDetector('NumGaussians', 3, ...
+    'NumTrainingFrames', 50,'MinimumBackgroundRatio',0.5);
+roi = [139.25 239.75 985.5 400];
+videoReader = vision.VideoFileReader('MorningTraffic2.mp4');
+for i = 1:150
+    frame = step(videoReader); % read the next video frame
+    frame = imcrop(frame,roi);
+    frameSmall = imresize(frame,0.25);
+    foreground = step(foregroundDetector, frameSmall);
+end
+blobAnalysis = vision.BlobAnalysis('BoundingBoxOutputPort', true, ...
+    'AreaOutputPort', false, 'CentroidOutputPort', false, ...
+    'MinimumBlobArea', 300);
+
+
+%% Detect Cars using Background Subtraction then classify
+se = strel('square', 3); % morphological filter for noise removal
+while ~isDone(videoReader)
+    
+    frame = step(videoReader); % read the next video frame
+    frame = imcrop(frame,roi); % crop to region of interest
+    frameSmall = imresize(frame,0.25);
+    foreground = step(foregroundDetector, frameSmall);
+    
+    % Use morphological opening to remove noise in the foreground
+    filteredForeground = imopen(foreground, se);
+    
+    % Detect the connected components with the specified minimum area, and
+    % compute their bounding boxes
+    bbox = step(blobAnalysis, filteredForeground);
+    
+    numCars = size(bbox,1);
+    bbox = 4.*bbox;
+    result = frame;
+    if numCars > 0
+        for j=1:numCars
+            
+            % Crop a slightly larger region around car 
+            im = imcrop(frame,[bbox(j,1)-10 bbox(j,2)-10 bbox(j,3)+30 bbox(j,4)+30]);
+            
+            im = single(im2uint8(im));
+            im = imresize(im, [227 227]) ;
+            label = char(classify(net,im)); % classify with deep learning 
+            result = insertObjectAnnotation(result,'Rectangle',bbox(j,:),label,'FontSize',32);
+        end
+        
+    end
+    step(videoPlayer,result);
+    % Draw bounding boxes around the detected cars
+       
+end
+
+release(videoReader); % close the video file

TransferLearning/readFunctionTrain.m

@@ -0,0 +1,7 @@
+% Copyright 2016 The MathWorks, Inc.
+
+function I = readFunctionTrain(filename)
+% Resize the flowers images to the size required by the network.
+I = imread(filename);
+
+I = imresize(I, [227 227]);

TransferLearning/readFunctionValidation.m

@@ -0,0 +1,7 @@
+% Copyright 2016 The MathWorks, Inc.
+
+function I = readFunctionValidation(filename)
+% Resize the flowers images to the size required by the network.
+I = imread(filename);
+
+I = imresize(I, [227 227]);

WebcamClassification/cnn_webcam_demo.m

@@ -0,0 +1,97 @@
+% Copyright 2016-2017 The MathWorks, Inc.
+
+function cnn_webcam_demo(numTopClasses)
+
+    if nargin == 0
+        numTopClasses = 5;
+    end
+    
+    if verLessThan('nnet','9.1') % Neural Network Toolbox from R2016a or earlied
+        cnnMatFile = fullfile(pwd, '..', 'networks', 'imagenet-cnn.mat');
+        
+        if ~exist(cnnMatFile,'file')
+            disp('Run ''downloadAndPrepareCNN.m'' to download and prepare the CNN')
+            return;
+        else
+            imagenet_cnn = load(cnnMatFile);
+            convnet = imagenet_cnn.convnet; 
+        end
+        
+        % Convert ImageNet synset IDs to meaningful word descriptions
+        synsetsFile = fullfile(fileparts(mfilename('fullpath')),'..',...
+            'networks','synsetMap');
+
+        % Image net class labels are synset IDs.
+        synsetMap = load(synsetsFile);
+        synsetMap = synsetMap.synsetMap;
+        synsetMapKeys = keys(synsetMap);
+        categories = values(synsetMap, synsetMapKeys);
+    else
+        try
+            convnet = alexnet;
+        catch
+            error('Download the CNN model: AlexNet from the Add-On Explorer.');
+        end
+        
+        % Proper category names already available in last layer. No need to
+        % use syset IDs
+        categories = convnet.Layers(end).ClassNames;
+    end
+       
+    wcam = webcam;
+    player = vision.DeployableVideoPlayer('Name', ...
+        'Object Detection using Convolutional Neural Networks');
+    
+    % Configure position of labels and scores in Video Player
+    imgResolution = str2double(strsplit(wcam.Resolution,'x'));
+    classBarWidth = 30;
+    spaceBetweenBars = 15;
+    xPosition = imgResolution(1) + 50;
+    yPosition = round((imgResolution(2) - classBarWidth * ...
+        numTopClasses - spaceBetweenBars * (numTopClasses - 1))/2);
+    
+    cont = true;
+    while cont
+        img = snapshot(wcam);
+
+        I = imresize(img, convnet.Layers(1).InputSize(1:2));
+        [~, scores] = classify(convnet, I);
+        [scores, idx] = sort(scores, 'descend');
+       
+        labelsTopCategories = categories(idx(1:numTopClasses));
+        topScores = scores(1:numTopClasses)' * 100;
+
+        img = insertTopClasses(img, labelsTopCategories, topScores);
+        step(player,img)
+
+        cont = isOpen(player);
+    end
+
+    function img = insertTopClasses(img, labels, scores)
+
+        labelsXposition = xPosition * ones(numTopClasses,1);
+        labelsYposition = yPosition * ones(numTopClasses,1) + ...
+            (classBarWidth + spaceBetweenBars) * (0:numTopClasses-1)';
+        
+        img = padarray(img, [0 300], 0, 'post');
+        
+        % Top class scores
+        img = insertShape(img, 'FilledRectangle', [labelsXposition, ...
+            labelsYposition, 2*round(scores), ...
+            classBarWidth * ones(numTopClasses,1)], 'Color', 'green');
+        
+        scoreLabels = cellfun(@(c1,c2) sprintf('%s (%2.2f %%)', c1, c2),...
+            labels(:), num2cell(scores), 'UniformOutput', false);
+        
+        % Top class labels
+        img = insertText(img, [labelsXposition, labelsYposition], ...
+            scoreLabels, 'BoxOpacity', 0, 'TextColor', 'white', ...
+            'FontSize', 14);
+        
+        % Highlighting top class
+        img = insertText(img, [imgResolution(1)/2 30], labels(1), ...
+            'BoxColor', 'green', 'FontSize', 20, ...
+            'AnchorPoint', 'CenterTop');
+    end
+
+end

WebcamClassification/synsets2words.m

@@ -0,0 +1,26 @@
+% Copyright 2016 The MathWorks, Inc.
+
+function synsets2words(convnet)
+% This function converts ImageNet synset IDs to meaningful word 
+% descriptions
+
+synsetsFile = fullfile(fileparts(mfilename('fullpath')), '..', 'networks', 'synsetMap.mat');
+url = 'http://www.image-net.org/api/text/wordnet.synset.getwords?wnid=%s';
+
+% image net class names are synset IDs. Get the description instead
+synsets = convnet.Layers(end).ClassNames;
+synsetMap = containers.Map;
+synsetWords = cell(1,numel(synsets));
+
+fprintf(1,'Converting ImageNet synset IDs to meaningful word descriptions\n');
+fprintf(1,['Processing %0',num2str(length(num2str(numel(synsets)))),'i of %i.\n'],0,numel(synsets));
+
+for i = 1:numel(synsets)
+    fprintf(1,['\b\b\b\b\b\b\b',repmat('\b',1,2*numel(num2str(numel(synsets)))),...
+            ' %0',num2str(length(num2str(numel(synsets)))),'i of %i.\n'], i, numel(synsets));
+    synsetWords{i} = urlread(sprintf(url,synsets{i}));
+    synsetWords{i} = strtok(synsetWords{i},sprintf('\n'));
+    synsetMap(synsets{i}) = synsetWords{i};
+end
+
+save(synsetsFile, 'synsetMap');

downloadAndPrepareCNN.m

@@ -0,0 +1,28 @@
+% Copyright 2016-2017 The MathWorks, Inc.
+
+function downloadAndPrepareCNN()
+% Download AlexNet CNN in MatConvNet format and converts to SerialNetwork
+
+addpath(fullfile(pwd, 'WebcamClassification'));
+mkdir(fullfile(pwd,'networks'));
+cnnMatFile = fullfile(pwd, 'networks', 'imagenet-cnn.mat');
+synsetsFile = fullfile(pwd, 'networks', 'synsetMap.mat');
+
+if ~exist(cnnMatFile,'file')
+    
+    cnnSourceMatFile  = fullfile(pwd, 'networks', 'imagenet-caffe-alex.mat');
+    cnnURL = 'http://www.vlfeat.org/matconvnet/models/beta16/imagenet-caffe-alex.mat';
+
+    if ~exist(cnnSourceMatFile,'file') % download only once
+        disp('Downloading 233MB AlexNet pre-trained CNN model. This may take several minutes...');
+        websave(cnnSourceMatFile, cnnURL);
+    end
+    convnet = helperImportMatConvNet(cnnSourceMatFile);
+
+    save(cnnMatFile, 'convnet');
+    delete(cnnSourceMatFile)
+end
+
+if ~exist(synsetsFile,'file')
+    synsets2words(convnet);
+end