## Mastering Machine Learning and AI with MATLAB

##### Description

The project sets out to provide a practical framework for the application of MATLAB in the development of machine learning and artificial intelligence solutions. Through various modules, the participant will gain in-depth understanding of basic and advanced concepts of machine learning and artificial intelligence, and how to implement them in MATLAB. The project features step-by-step model-building instruction, practical exercises, and real-world applications to cement the understanding of MATLAB and data analysis skills.

# Unit 1: Introduction to MATLAB for Machine Learning

In this first part of the project, we will install MATLAB, set up, and explore using it for data analysis.

## Introduction

MATLAB (Matrix Laboratory) is a high-performance language for technical computing. It retains the features of traditional programming, but its language is built particularly to represent complex data structures and work on them efficiently.

## I. Installation of MATLAB

Go to the official MATLAB website (

https://www.mathworks.com/ ).Ensure your laptop or PC meets the minimum requirements.

Click "Start Trial" or "Buy Now" to procure MATLAB, based on your requirements and complete the due financial transactions.

After you complete the registration and purchase, go to your MATLAB and Simulink account.

Click on 'Download MATLAB' and select your operating system. The downloading process will begin thereafter.

After the installer downloads, click on install and verify, following which it will initiate the installation wizard of MATLAB.

Accept the license agreement and if necessary, use a custom installation.

Activate MATLAB by logging in with your MathWorks Account in the installer.

After the installation is complete you can start MATLAB from your system's application menu.

## II. Getting Started with MATLAB

Begin by creating vectors and matrices, which are the key data structures in MATLAB. A vector in MATLAB is defined as an array which has only one dimension with a size greater than one. A matrix in MATLAB is a two-dimensional array.

```
% Sample code to initialize a matrix
A = [1 2 3; 4 5 6; 7 8 9]
% initiation of a vector
v = [1 2 3 4 5]
% making a row vector into a column one
v = v'
```

Take note of the `%`

symbol, which MATLAB uses to start a comment line.

## III. Data Analysis

Load the data using the `readmatrix`

function.

`data = readmatrix('filename.csv');`

Use in-built MATLAB functions for standard statistical analysis.

```
% Simple statistics
meanValue = mean(data)
medianValue = median(data)
% Variance and Standard Deviation
varianceValue = var(data)
standardDeviation = std(data)
```

For complex statistical analysis, use the Statistics and Machine Learning toolbox.

## IV. Machine Learning

The `fitcsvm`

function is used to train a support vector machine (SVM) for binary classification on a low-dimensional or moderate-dimensional predictor data set.

```
% Load sample data
load fisheriris
% Take mean measurements of sepal length and width
X = [mean(meas(:,1:2),2) mean(meas(:,3:4),2)];
% Create binary classes for setosa and versicolor
Y = (species=="setosa") | (species=="versicolor");
% Split data into train and test
rng(1);
cvp = cvpartition(Y,'Holdout',0.5);
DataTrain = X(training(cvp),:);
ClassTrain = Y(training(cvp),:);
DataTest = X(test(cvp),:);
ClassTest = Y(test(cvp),:);
% Train an SVM model
mdlSVM = fitcsvm(DataTrain,ClassTrain,'Standardize',true,'KernelFunction','RBF');
% Validate the model using test data
label = predict(mdlSVM,DataTest);
TestError = sum(~strcmp(label,ClassTest))/length(ClassTest);
fprintf('\n Test classification error: %f\n', TestError);
```

That's it! You've now installed and explored the very basics of MATLAB for machine learning. Enjoy your journey ahead with Data Analysis and Machine Learning projects.

# Unit 2: Understanding Data Analysis in MATLAB

In this section, we are going to practically implement concepts of data analysis using MATLAB. We will cover necessary topics that include loading data into MATLAB, understanding data types, cleaning of data, data visualization, and descriptive statistics.

## 1. Importing Data into MATLAB

The first step to data analysis is to load your dataset. MATLAB provides different ways to import data. In this example, we will use the `readtable`

function which is suitable for reading large data in a text or spreadsheet file.

```
% load a .csv data file
data = readtable('mydata.csv');
```

## 2. Understanding Data Types

Next, we can get the overview of the data using the command `head`

. This will display the first few rows of the table.

```
% view the first few rows of the table
head(data)
```

To get more detailed information about the data table, we use the `summary`

function.

```
% summarize the table
summary(data)
```

## 3. Cleaning of Data

The data we loaded may not be clean. It might contain missing values. We need to handle those missing values. Let's remove or fill any NA or NaN values in our data. The `rmmissing`

function can help us remove any rows with missing data.

```
% remove missing values
data = rmmissing(data);
```

## 4. Data Visualization

Visualization is a significant aspect of data analysis. It helps to understand the data in a more intuitive way. MATLAB provides several functions for data visualization like `plot`

, `bar`

, `histogram`

etc. Let's create a histogram for a particular column.

```
% histogram
histogram(data.variable1)
```

## 5. Descriptive Statistics

Lastly, we perform descriptive statistics to get a summary of the central tendency, dispersion, and shape of the dataset's distribution. The `mean`

, `median`

, `mode`

, `std`

, `var`

functions can be used to get average, median, mode, standard deviation, and variance of data respectively. Let's find the mean and standard deviation for a particular column.

```
% mean
avg = mean(data.variable1)
% standard deviation
std_dev = std(data.variable1)
```

Now, you have understood the basic steps for data analysis in MATLAB and you can apply these practical steps to your real-life projects. Remember to replace 'variable1' and 'mydata.csv' with your actual column name and data file respectively.

# Unit 3: Basics of Machine Learning Concepts Implementation in MATLAB

In this section, we will implement key machine learning concepts in MATLAB. Concepts include Supervised Learning (linear regression, logistic regression), Unsupervised Learning (K-means), Model Evaluation (Confusion Matrix, ROC Curve), and Feature Selection.

**NOTE:** We would be assuming you have already loaded or imported your dataset using MATLAB's built-in functions since data loading is covered in prior units.

## 1. Supervised Learning

### Linear Regression

Linear regression is a basic predictive analytics technique. It is used to predict a dependent variable (Y) based on the values of independent variables (X).

```
% Load Data.
% Here 'load' function is used to load .mat file.
load hald;
% Setup the model.
mdl = fitlm(ingredients,heat);
% Predict.
Ypred = predict(mdl,ingredients);
```

### Logistic Regression

Logistic regression measures the relationship between a categorical dependent variable and one or more independent variables.

```
% Load Data.
load fisheriris;
% Identify the predictors and response.
resp = ismember(species,'versicolor');
predictors = meas(:,1:3);
% Fit a logistic regression.
mdl = fitglm(predictors,resp,'Distribution','binomial','Link','logit');
```

## 2. Unsupervised Learning

### K-means

K-means is a type of unsupervised learning used to classify data into 'k' number of clusters.

```
% Load Data.
load fisheriris;
% Perform K-Means Clustering.
k = 3; % Number of clusters
[idx, ctrs] = kmeans(meas,k);
```

## 3. Model Evaluation

### Confusion Matrix

Confusion matrix helps us evaluate the quality of the output of a classifier on the iris data set.

```
% Load Data.
load fisheriris;
predictors = meas(:,1:3);
resp = ismember(species,'versicolor');
% Fit a logistic regression.
mdl = fitglm(predictors,resp,'Distribution','binomial','Link','logit');
% Predict on training data.
Ypred = predict(mdl,predictors) > 0.5;
% Create confusion matrix.
confusionMatrix = confusionmat(resp,Ypred);
```

### ROC Curve

Receiver operating characteristic curve, or ROC curve, illustrates the diagnostic ability of a binary classifier system as its discrimination threshold is varied.

```
% Load Data.
load fisheriris;
% Identify the predictors and response.
resp = ismember(species,'versicolor');
predictors = meas(:,1:3);
% Fit a logistic regression.
mdl = fitglm(predictors,resp,'Distribution','binomial','Link','logit');
% Predict probabilities on training data.
scores = predict(mdl,predictors);
% Compute ROC curve.
[X,Y,T,AUC] = perfcurve(resp,scores,true);
```

## 4. Feature Selection

This is done often done for dimensionality reduction. Too many features may cause overfitting. However, we want to retain information that contributes to the predictive power.

```
% Load Data.
load ionosphere;
% Use sequential feature selection.
opts = statset('display','iter');
classf = @(train_data, train_labels, test_data, test_labels)...
sum(predict(fitcsvm(train_data, train_labels,'KernelFunction','rbf'), test_data) ~= test_labels);
[fs, history] = sequentialfs(classf,X,Y,'cv','leaveout','options',opts);
```

## Conclusion

We described the core concepts of machine learning and implemented them using MATLAB. This guide assumes you're familiar with the basics of MATLAB programming and have your environment set up properly. Also, ensure to have clean and prepared data before proceeding with these steps.

# Unit 4: Implementing Machine Learning Algorithms in MATLAB

In this unit, we will use MATLAB to create some basic but useful machine learning models.

## I. Linear Regression

We will use the 'fitlm' function to create a linear regression model.

```
% Load data
load carsmall
% Define the response and predictors
y = Weight;
X = [Acceleration Displacement Horsepower];
% Fit a linear regression model
mdl = fitlm(X,y)
% Display the coefficient estimates
mdl.Coefficients
```

This will fit a linear regression model, and display the estimated coefficients.

## II. K-Nearest Neighbors (KNN)

Now, we are going to apply a K-Nearest Neighbors classifier.

```
% Split iris data to predictors and response
predictors = meas;
classLabel = species;
% Train the model using knn
Mdl = fitcknn(predictors,classLabel,'NumNeighbors',5);
% Predict the class labels
PredictedLabel = predict(Mdl, predictors);
```

This will apply a KNN classifier and predict the labels for the dataset.

## III. Decision Trees

Now, to build a decision tree:

```
% Load data
load fisheriris;
% Train
tree = fitctree(meas,species);
% Visualize
view(tree,'Mode','graph');
```

This will create and visualize a decision tree.

## IV. Logistic Regression

Let's run a logistic regression now:

```
% Load data
load fisheriris;
% Create a binary response variable
resp = ismember(species,'setosa');
% Train a logistic regression model
mdl = fitglm(meas,resp,'Distribution','binomial','Link','logit');
```

Here, we created a binary response variable and then trained a logistic regression model on the data.

## V. Support Vector Machines (SVM)

Lastly, let's build an SVM model:

```
% Load data
load fisheriris
% Create a binary classification problem
groups = ismember(species,'setosa');
data = meas(groups | ismember(species,'versicolor'),3:4);
% Train SVM
svmStruct = fitcsvm(data,groups(groups | ismember(species,'versicolor')));
```

In this case, we trained an SVM model on data for a binary classification problem. Notice that before training the model, we first created a suitable binary classification problem.

In summary, this unit showed you how to implement five basic but fundamental machine learning algorithms in MATLAB: Linear Regression, K-Nearest Neighbors, Decision Trees, Logistic Regression, and Support Vector Machines. You should now be equipped to apply these on your own data sets and perhaps even start exploring other more complex machine learning algorithms.

# Unit 5: Introduction to Artificial Intelligence with MATLAB

In this unit, we will primarily work on creating a simple Artificial Intelligence (AI) model in MATLAB. Our demonstration will focus on a neural network model that will be trained to distinguish between different types of images.

## Load Data

We'll use the CIFAR-10 dataset, which consists of 60000 32x32 color images in 10 classes, with 6000 images per class. MATLAB has a built-in function to load this dataset.

`[cifar10Train,cifar10Test] = helperCIFAR10Data;`

## Preprocessing

We need to preprocess the images to have the right input size and format for our neural network.

```
augimdsTrain = augmentedImageDatastore([32 32 3],cifar10Train,...
'DataAugmentation',imageDataAugmenter(...
'RandXReflection',true,'RandRotation',[-10,10]),...
'OutputSizeMode','randcrop');
augimdsTest = augmentedImageDatastore([32 32 3],cifar10Test,'OutputSizeMode','randcrop');
```

Here, we've applied random x-reflections and random rotations from -10 to 10 degrees for our training data's image augmenter.

## Create Layers for a Convolutional Neural Network

We will use a similar architecture to the famous AlexNet deep learning network.

```
layers = [
imageInputLayer([32 32 3],"Name","imageinput")
convolution2dLayer([5 5],64,"Name","conv_1","Padding",[2 2 2 2],"Stride",[1, 1])
reluLayer("Name","relu_1")
maxPooling2dLayer([3 3],"Name","maxpool_1","Padding",[1 1 1 1],"Stride",[2, 2])
convolution2dLayer([5 5],64,"Name","conv_2","Padding",[2 2 2 2],"Stride",[1, 1])
reluLayer("Name","relu_2")
maxPooling2dLayer([3 3],"Name","maxpool_2","Padding",[1 1 1 1],"Stride",[2, 2])
convolution2dLayer([3 3],128,"Name","conv_3","Padding",[1 1 1 1])
reluLayer("Name","relu_3")
fullyConnectedLayer(64,"Name","fc_1")
fullyConnectedLayer(10,"Name","fc_2")
softmaxLayer("Name","softmax")
classificationLayer("Name","classoutput")];
```

## Specify Training Options

We will specify training options including the solver to use (Stochastic Gradient Descent with Momentum), initial learning rate, and maximum epochs.

```
options = trainingOptions('sgdm', ...
'InitialLearnRate',0.01, ...
'MaxEpochs',20, ...
'MiniBatchSize',128, ...
'L2Regularization',1.0000e-04, ...
'Verbose',false, ...
'Plots','training-progress');
```

## Train the Neural Network

Using the training data, layers, and training options specified earlier, we'll train the network.

`convnet = trainNetwork(augimdsTrain,layers,options);`

## Evaluate the Network

Let's evaluate the performance of the network on our test dataset.

```
predictions = classify(convnet,augimdsTest);
accuracy = sum(predictions == cifar10Test.Labels) / numel(cifar10Test.Labels);
```

The variable `accuracy`

represents the accuracy of our neural network on the test dataset.

With this, we have built a simple AI model using MATLAB, that is capable of distinguishing between different classes of images from the CIFAR-10 dataset. This implementation shows how to prepare data, define, train, and test a neural network in MATLAB. This practical implementation can then be adjusted according to the specific requirements of different tasks you might encounter in real life scenarios.

# Unit 6: Exploring AI Concepts and Techniques

In this unit, we will explore some key AI concepts and techniques and their practical implementation in MATLAB. We will delve into artificial neural networks (ANNs), using the Neural Network Toolbox, and convolutional neural networks (CNNs), using the Deep Learning ToolBox. Let's get started with a practical implementation in MATLAB.

## 1. Artificial Neural Networks (ANN)

The implementation of an ANN consists of defining the network architecture, training the network, predicting with the trained network and then validating the prediction accuracy of the trained network.

```
% Load example training data
load iris_dataset
% Define a feedforward backpropagation network architecture with 10 neurons in the hidden layer
net = feedforwardnet(10);
% Split the data into training set (70%), validation set (15%), and test set (15%)
net.divideParam.trainRatio = 0.7;
net.divideParam.valRatio = 0.15;
net.divideParam.testRatio = 0.15;
% Train the network using the training data
[net, tr] = train(net, irisInputs, irisTargets);
% Test the network with test data
outputs = net(irisInputs);
errors = gsubtract(outputs, irisTargets);
performance = perform(net, irisTargets, outputs);
% View the network
view(net);
```

## 2. Convolutional Neural Networks (CNN)

For the practical implementation of a CNN, let's consider using MATLAB's Deep Learning Toolbox and a sample image dataset.

```
% Load training images
imds = imageDatastore('imfolder','IncludeSubfolders',true,'LabelSource','foldernames');
% Split the data
[imdsTrain, imdsValidation] = splitEachLabel(imds,0.7,'randomized');
% Define network architecture
layers = [
imageInputLayer([28 28 1])
convolution2dLayer(3,8,'Padding','same')
batchNormalizationLayer
reluLayer
maxPooling2dLayer(2,'Stride',2)
convolution2dLayer(3,16,'Padding','same')
batchNormalizationLayer
reluLayer
maxPooling2dLayer(2,'Stride',2)
fullyConnectedLayer(10)
softmaxLayer
classificationLayer];
% Specify training options
opts = trainingOptions('sgdm', ...
'InitialLearnRate',0.01, ...
'MaxEpochs',4, ...
'Shuffle','every-epoch', ...
'ValidationData',imdsValidation, ...
'ValidationFrequency',30, ...
'Verbose',false, ...
'Plots','training-progress');
% Train the network
net = trainNetwork(imdsTrain,layers,opts);
% Classify validation images and compute accuracy
YPred = classify(net,imdsValidation);
accuracy = sum(YPred == imdsValidation.Labels)/numel(imdsValidation.Labels)
```

These scripts provide implementations of ANNs and CNNs in MATLAB using built-in functions and tools as an introduction to AI concepts and techniques.

# Unit 7: Building AI Models using MATLAB

In this unit, we are going to implement a practical AI model using MATLAB. We will use Machine Learning in MATLAB to classify images using a Convolutional Neural Network (CNN). For simplicity, we'll be using the 'digitDatasetPath' that comes prepackaged with MATLAB.

The sections are organized as below:

## 1. Data Loading and Preprocessing

## 2. Train a Convolutional Neural Network (CNN) for Image Classification

## 3. Evaluate the Network

Let's get started.

## 1. Data Loading and Preprocessing

```
digitDatasetPath = fullfile(matlabroot, 'toolbox', 'nnet', 'nndemos', ...
'nndatasets', 'DigitDataset');
digitData = imageDatastore(digitDatasetPath, ...
'IncludeSubfolders', true, 'LabelSource', 'foldernames');
% Count the number of images in each category
countEachLabel(digitData)
% Split Dataset
trainingFraction = 0.8;
[rngTrainingSet, rngValidationSet] = splitEachLabel(digitData, trainingFraction, 'randomized');
% Check the dimension of the first image
img = readimage(digitData, 1);
size(img)
```

## 2. Train a Convolutional Neural Network (CNN) for Image Classification

After preprocessing, we can train our Convolutional Neural Network (CNN). We define the CNN architecture, specify training options, and then train using the 'trainNetwork' function.

```
layersCNN = [
imageInputLayer([28 28 1])
convolution2dLayer(5, 20)
batchNormalizationLayer
reluLayer
maxPooling2dLayer(2, 'Stride', 2)
fullyConnectedLayer(10)
softmaxLayer
classificationLayer];
% Define training options
opts = trainingOptions('sgdm', ...
'InitialLearnRate', 0.001, ...
'MaxEpochs', 20, ...
'MiniBatchSize', 128, ...
'ValidationData', rngValidationSet, ...
'ValidationFrequency', 30, ...
'Verbose', false, ...
'Plots', 'training-progress');
trainedNet = trainNetwork(rngTrainingSet, layersCNN, opts);
```

All these steps will define the architecture of our CNN and the training options, and then train the network.

## 3. Evaluate the Network

After training the model, we need to evaluate its performance. We perform prediction on our validation set and compute the classification accuracy.

```
predictedLabels = classify(trainedNet, rngValidationSet);
valLabels = rngValidationSet.Labels;
% Calculate accuracy
accuracy = sum(predictedLabels == valLabels)/numel(valLabels);
fprintf('Validation accuracy: %.2f%%\n', 100*accuracy);
```

This provides a practical implementation of a basic AI model using MATLAB. This model takes a set of images of handwritten digits(0-9), processes them, learns from them, and finally is capable of making predictions on unseen similar data with a certain accuracy.

Sure, let's kick off with section **Unit 8: Advanced Techniques in Machine Learning with MATLAB**.Each subsection includes the MATLAB code you can implement directly.

## 8.1 Model Optimization

Parameter tuning is an essential part of Machine Learning. One method of performing a grid search to optimize hyperparameters can be seen below:

```
% Assuming we have a sample fitcecoc model named Mdl from previous unit
% Create a hyperparameter optimization function
opts = struct('Optimizer','bayesopt','ShowPlots',true,'CVPartition',cvp,'MaxObjectiveEvaluations',20);
Mdl = fitcecoc(X,Y,'OptimizeHyperparameters','auto','HyperparameterOptimizationOptions',opts)
```

You can change your `MaxObjectiveEvaluations`

, which is the maximum number of points to evaluate before stopping the function.

## 8.2 Feature Engineering

Let's use Principal Component Analysis (PCA) for feature extraction. PCA attempts to explain the variance in high-dimensional data with fewer variables.

```
%Assuming we have a matrix X with our predictors
[coeff, score, latent] = pca(X);
% Now, the score matrix contains the principal component scores
% The columns of score correspond to the principal components of X
```

## 8.3 Working with Large Datasets

In Machine Learning, it's common to have large datasets that you can't load into memory all at once. Below is the implementation for out-of-memory data:

```
% Assuming data is in a file 'large_Dataset.csv'
ds = datastore('large_Dataset.csv');
% We can now preview the dataset
prev_data = preview(ds);
% Implementing fitlm function on large data for linear regression
Mdl = fitlm(ds,'ResponseVar'); % replace 'ResponseVar' with the response variable in your dataset
```

You can now incrementally train models on sections (or "chunks") of this dataset stored in the datastore.

## 8.4 Model Evaluation

It's highly important to assess the performance of your classifier. Let's look at how we could generate a confusion matrix and ROC curve.

```
% Assuming yTest is test data labels & yPredict is corresponding predicted labels.
confMat = confusionmat(yTest,yPredict);
% To create an ROC curve
[X,Y,T,AUC] = perfcurve(yTest, yPredict, 'PositiveClass');
plot(X,Y)
xlabel('False positive rate'); ylabel('True positive rate');
title('ROC Curve');
```

## 8.5 Deep Learning

You can use pre-trained networks (like GoogLeNet) as a baseline for creating more complex models using transfer learning.

```
% Import GoogLeNet
net = googlenet;
% If we want to replace the last three layers
lgraph = layerGraph(net);
lgraph = removeLayers(lgraph, {'loss3-classifier','prob','output'});
numClasses = numel(unique(yTrain)); % assuming yTrain is our training labels.
newLayers = [
fullyConnectedLayer(numClasses,'Name','fc','WeightLearnRateFactor',10,'BiasLearnRateFactor',10)
softmaxLayer('Name','softmax')
classificationLayer('Name','classoutput')];
lgraph = addLayers(lgraph,newLayers);
lgraph = connectLayers(lgraph,'pool5-drop_7x7_s1','fc');
options = trainingOptions('sgdm','MiniBatchSize',10,'MaxEpochs',6,'InitialLearnRate',1e-4,'CheckpointPath','tempdir');
augimdsTrain = augmentedImageDatastore(inputSize(1:2),xTrain,yTrain); % assuming xTrain is our training images.
Mdl = trainNetwork(augimdsTrain,lgraph,options);
```

With this, you have modified GoogLeNet for your classification problem and trained it on your data.

This completes Unit 8. Hopefully it should be easy to connect these blocks with your previous units to train and improve machine learning models in MATLAB.

# Unit 9: AI Projects - Real World Application

In this unit, we will implement an AI project based on the previous units you have learned. We will create a predictive model for heart disease diagnosis using machine learning techniques with MATLAB. The dataset used here is the Cleveland Heart Disease dataset available from the UCI Machine Learning Repository. The data has been preprocessed and standardised for simplicity.

**Disclaimer**: This model should not be used for actual medical diagnoses. It is for educational purposes only.

## 1. Load Dataset

`data = readtable('processed.cleveland.csv');`

The first step is to load the data into MATLAB from the given CSV file using the `readtable()`

function.

## 2. Understanding Data

It's essential to first understand data before building a model. Please refer to Unit 2 for more on data understanding.

## 3. Preparing Data

```
input = data(:, 1:end-1);
output = data(:, end);
```

Here, we separate the input and output data. The input data consists of all columns except the last, which includes the heart disease diagnosis (output).

## 4. Splitting Data Into Training and Test Data

```
cvp = cvpartition(output,'HoldOut',0.3);
idxTrain = training(cvp);
idxTest = test(cvp);
X_train = input(idxTrain,:);
Y_train = output(idxTrain,:);
X_test= input(idxTest, :);
Y_test= output(idxTest,:);
```

In this step, we employ the 'HoldOut' method to divide our data into a 70% training set and a 30% test set.

## 5. Create Model

As per Unit 4, we know how to create a model. In this case, we'll use the Decision Tree classifier.

`treeModel = fitctree(X_train, Y_train);`

## 6. Validating Model

```
label = predict(treeModel, X_test);
accuracy = sum(Y_test == label)/numel(Y_test);
```

The row uses the `predict()`

function to predict output based on the test data. The `accuracy`

is then calculated by comparing the predicted output with the actual output.

## 7. Improving Model (Refer to unit 8)

For better results, we can use other learning techniques such as SVM, Logistic Regression, etc. However, remember to always check the assumptions of the method you choose to ensure they are suitable for your specific data and prediction task.

As an example, we'll use a Random Forest for enhanced performance.

```
bagModel = TreeBagger(50,X_train,Y_train,'OOBPredictorImportance','On','Method', 'classification');
label = predict(bagModel, X_test);
accuracy = sum(Y_test == str2double(label))/numel(Y_test);
```

Above, `TreeBagger`

uses a Random Forest of 50 trees. `OOBPredictorImportance`

calculates out-of-bag estimates of predictor importance.

That completes a basic real-world application of an AI project in MATLAB. Adjust the specific steps based on your dataset and problem requirements. Always assure your data preparation, input handling, model creation, and model validation follow best practices for your specific AI project context.

# Unit 10: Final Project & Course Review

In this final unit, you will consolidate everything you've learned throughout the course to build a comprehensive project. We will be creating an AI model that predicts the housing price based on several predictors using regression techniques. We will use Machine Learning and Artificial Intelligence techniques using MATLAB.

This outline assumes your understanding of MATLAB, basic data analysis, machine learning concepts, AI concepts, building AI models, advanced techniques of machine learning, and designing real-world applications of AI.

## Importing and Cleaning Up The Data

We'll start by loading our data into MATLAB. You've learned how to do this already in previous units, so we can go straight into the implementation here. We'll use the Boston housing dataset, which is readily available in MATLAB.

```
load('boston.mat')
data = boston(:,1:13);
target = boston(:,14);
```

Now that the data is loaded, next would be cleaning the data.

```
nans = sum(isnan(data));
data = data(:, nans==0); % remove nan value columns
```

## Data Splitting

Next, we'll split our data into a training and testing set.

```
cv = cvpartition(length(target),'HoldOut',0.3);
idx = cv.test;
% Train Data
data_train = data(~idx,:);
target_train = target(~idx,:);
% Test Data
data_test = data(idx,:);
target_test = target(idx,:);
```

## Model Training

Let's built our regression model using Regression Learner App in MATLAB.

`Mdl = fitrensemble(data_train,target_train,'Method','Bag');`

## Model Validation

Next, we will validate our model with the test data.

`target_pred = predict(Mdl,data_test);`

## Model Evaluation

Use Mean Squared Error as the evaluation metric.

```
mse = immse(target_test,target_pred);
fprintf(' The mean-squared error is %.2f\n', mse)
```

## Visualizing Comparisons

Now we'll plot our predicted vs actual data points.

```
figure
scatter(target_test, target_pred)
xlabel('True Values')
ylabel('Predicted Values')
title('True vs Predicted Values')
```

If your model is accurate, the plot will show a straight line of points.

## Save Your Model

Finally, save your model using the 'saveLearnerForCoder' function to create a 'Predictor' file that you can deploy in real life.

`saveLearnerForCoder(Mdl, 'Predictor');`

This predictor can be used for detecting housing prices by using loadLearnerForCoder and predict functions.

```
Mdl = loadLearnerForCoder('Predictor');
target_pred = predict(Mdl,data_test);
```

This marks the end of our project. You have now successfully built and deployed a machine learning model using MATLAB.