{"id":7141,"date":"2022-01-10T09:27:00","date_gmt":"2022-01-10T14:27:00","guid":{"rendered":"https:\/\/blogs.mathworks.com\/student-lounge\/?p=7141"},"modified":"2025-02-20T14:05:53","modified_gmt":"2025-02-20T19:05:53","slug":"wids","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/student-lounge\/2022\/01\/10\/wids\/","title":{"rendered":"Building Regression Models: A Tutorial for the WiDS Datathon 2022"},"content":{"rendered":"
\n

Introduction<\/span><\/h2>\n
Hello! I am Grace Woolson<\/a>, an Application Support Engineer at the MathWorks. We are excited to support the Women in Data Science Datathon 2022 by providing complimentary MATLAB Licenses, tutorials, and resources to each participant.<\/div>\n
\"\"<\/div>\n
This tutorial will walk you through the steps of solving a regression problem with MATLAB for any dataset, while showing examples for each step using a sample dataset. Even after the Datathon has concluded, you can continue to use this blog and any linked resources to learn more about machine learning and regression with MATLAB. Please note that this blog post is an executable MATLAB Live Script, so you have the opportunity to run the code in this tutorial in your browser using MATLAB Online or download the script and run it on a local MATLAB installation. You can find these options at the bottom of the tutorial.<\/div>\n
To request complimentary licenses for you and your teammates, go to this <\/span>MathWorks site<\/span><\/a>, click the \u201cRequest Software\u201d button, and fill out the software request form.<\/span><\/div>\n
The WiDS Datathon 2022 focuses on mitigating climate change by identifying the energy consumption of buildings through data created in collaboration with Climate Change AI (CCAI) and Lawrence Berkeley National Laboratory (Berkeley Lab). Brought to you by the WiDS Worldwide team and Harvard University IACS<\/a>, the Datathon will run until February 26th, 2022. Learn more about the WiDS Datathon<\/a>, or register to participate<\/a> today.<\/div>\n
The Datathon task is to train a model that predicts building energy consumption based on regional differences in building energy efficiency, as this could help determine the best targets for retrofitting. Since the model will be predicting a building’s energy consumption, which is a quantitative result, this problem could be solved using a regression model.<\/div>\n
<\/div>\n
\"\"<\/div>\n
<\/div>\n
Before you get started with this tutorial, please execute the following code in MATLAB if you wish to follow along with the examples. This creates the dataset that I will be using. This dataset contains information about vehicles, and we will use this dataset to create a model that predicts how many miles a vehicle can drive per gallon of gas (‘MPG’).<\/div>\n
To execute the code in this example, you can either copy\/paste the individual code snippets into the Command Window and press the ‘Enter’ key, or if you are using the live script provided with this example then clicking Run Section<\/span> from the Toolstrip will execute all of the code in the current section.<\/div>\n
\n
\n
load carbig<\/span><\/span><\/div>\n<\/div>\n
\n
tbl = table(Acceleration, cyl4, Cylinders, Displacement, Horsepower, Mfg, Model, Model_Year, MPG, org, Origin, Weight,…<\/span><\/span><\/div>\n<\/div>\n
\n
‘VariableNames’<\/span>, {‘Acceleration’<\/span>, ‘Cyl4’<\/span>, ‘Cylinders’<\/span>, ‘Displacement’<\/span>, ‘Horsepower’<\/span>, ‘Make’<\/span>, ‘Model’<\/span>, ‘Year’<\/span>, ‘MPG’<\/span>, ‘RegionOfOrigin’<\/span>, ‘CountryOfOrigin’<\/span>, ‘Weight’<\/span>});<\/span><\/div>\n<\/div>\n
\n
writetable(tbl, ‘carData.csv’<\/span>);<\/span><\/div>\n<\/div>\n
\n
clear;<\/span><\/div>\n<\/div>\n
\n
clc;<\/span><\/div>\n<\/div>\n<\/div>\n
After executing this, you should have a file called ‘carData.csv’ in your current directory. Now, you are ready to start building your own regression model by following the steps of the machine learning workflow.<\/div>\n
<\/div>\n
\"\"<\/div>\n
<\/div>\n

Access and Explore the Data <\/span><\/h2>\n
Real-world data tends to come with real-world challenges. Datasets could be stored in a variety of different file types, may be stored across several files, and can get messy and confusing. In this section, I will discuss some basic steps for loading and cleaning up a dataset in MATLAB.<\/div>\n
<\/div>\n

Step 1: Import Your Data<\/h3>\n
In order to start working with data, you have to first bring it into the Workspace. If your data is stored across multiple files, you may wish to use a datastore, as it provides a convenient way for accessing these files. It stores information about the files in a given location and the format of their contents, and only imports the files when you need them. To learn more about datastores, refer to the documentation page<\/a>.<\/div>\n
In this example, all of our data is stored in one .CSV file, so I will be importing the data as a table. Tables can store data with different data types and allow for the use of headers to label the data in a column, also called a variable<\/span>, so they lend themselves nicely for storing large or complicated datasets in the workspace. To import a table from a file, you can either use the Import Tool or the ‘readtable’ command.<\/div>\n
<\/div>\n

Option 1: Using the Import Tool<\/span><\/h4>\n
The Import Tool lets users preview and import data interactively, without having to write any code. To open the Import Tool, navigate to the Toolstrip at the top of the MATLAB window, click on the Home<\/span> tab, find the ‘Variable’ section, and click Import<\/span> Data<\/span>. This will open a window that prompts you to select the file you wish to import; after you have selected a file, it will open the Import Tool.<\/div>\n
From here, you can see the data in the file, each variable name, and the data type of each variable. Additionally, you can set import options and declare how to treat cells that cannot be imported. I will use the default settings, and click Import Selection<\/span> to finish importing the data.<\/div>\n
\"ImportTool.gif\"<\/div>\n
The Import Tool can also be opened by executing the following command in the Command Window:<\/div>\n
\n
\n
uiimport(‘carData.csv’<\/span>);<\/span><\/div>\n<\/div>\n<\/div>\n
<\/div>\n

Option 2: Using Commands<\/span><\/h4>\n
Importing data using the ‘readtable’ command means that you won’t get a preview of the data before you import it, but it may be more helpful if you wish to customize the import options beyond what the Import Tool offers. For example, this command may be preferred if the data has multiple indicators to say that a value is missing.<\/div>\n
In our example, ‘carData.csv’ always uses NaN when a value is missing, which is automatically interpreted by MATLAB as a missing value. Let’s say, however, that we are working with a dataset called ‘messyData.csv’ that uses NaN, ‘-‘, ‘NA’, -99, and ‘.’ to indicate when there is missing data. In this case, you could use the ‘TreatAsMissing’ Name-Value argument available with ‘readtable’ to convert all of these to NaN:<\/div>\n
importedData = readtable(‘messyData.csv’, ‘TreatAsMissing’, {‘-‘, ‘NA’, ‘-99’, ‘.’});<\/span><\/div>\n
To learn more about the options available when using ‘readtable’ to import data, please visit this documentation site<\/a>.<\/div>\n
<\/div>\n

Preprocess the Data<\/span><\/h2>\n
Now that you have the data in the Workspace, it is time to prepare it for machine learning. It is important that the data is in the correct format and that the values are what you expect them to be, as this can prevent error messages and poor model performance later on in the workflow.<\/div>\n
<\/div>\n

Step 2: Clean Data<\/h3>\n
As I mentioned above, data is messy. Datasets may be missing entries, they may have thousands of rows or observations<\/span>, they could utilize a variety of data types, the measurements may not have been taken in perfect conditions, and the data collected may not be equally representative of all possible inputs. Before you can create a model, it is important to clean the data up so that it accurately reflects the problem and can easily be used as input to train the model.<\/div>\n
There are many different approaches you can take to work with missing values and inconsistent data. I will go through some basic steps in this post, but you can also refer to this documentation page<\/a> to learn more.<\/div>\n
<\/div>\n
First, I use the ‘summary’ function to learn more about the data types and get basic statistics about the data for each variable.<\/div>\n
\n
\n
summary(carData)<\/span><\/div>\n
\n
\n
\n

Variables:<\/p>\n

Acceleration<\/strong>: 406\u00d71 double<\/p>\n

Values:<\/p>\n

Min 8
\nMedian 15.5
\nMax 24.8<\/p>\n

Cyl4<\/strong>: 406\u00d71 categorical<\/p>\n

Values:<\/p>\n

Four 207
\nOther 199<\/p>\n

Cylinders<\/strong>: 406\u00d71 double<\/p>\n

Values:<\/p>\n

Min 3
\nMedian 4
\nMax 8<\/p>\n

Displacement<\/strong>: 406\u00d71 double<\/p>\n

Values:<\/p>\n

Min 68
\nMedian 151
\nMax 455<\/p>\n

Horsepower<\/strong>: 406\u00d71 double<\/p>\n

Values:<\/p>\n

Min 46
\nMedian 95
\nMax 230
\nNumMissing 6<\/p>\n

Make<\/strong>: 406\u00d71 categorical<\/p>\n

Values:<\/p>\n

amc 29
\naudi 7
\nbmw 2
\nbuick 17
\ncadillac 2
\nchevrolet 48
\nchrysler 6
\ncitroen 1
\ndatsun 23
\ndodge 28
\nfiat 8
\nford 54
\nhonda 13
\nih 1
\nmazda 12
\nmercedes-benz 3
\nmercury 11
\nnissan 1
\noldsmobile 10
\nopel 4
\npeugeot 8
\nplymouth 32
\npontiac 16
\nrenault 5
\nsaab 5
\nsubaru 4
\ntoyota 26
\ntriumph 1
\nvolkswagen 23
\nvolvo 6<\/p>\n

Model<\/strong>: 406\u00d71 string<\/p>\n

Year<\/strong>: 406\u00d71 double<\/p>\n

Values:<\/p>\n

Min 70
\nMedian 76
\nMax 82<\/p>\n

MPG<\/strong>: 406\u00d71 double<\/p>\n

Values:<\/p>\n

Min 9
\nMedian 23
\nMax 46.6
\nNumMissing 8<\/p>\n

RegionOfOrigin<\/strong>: 406\u00d71 categorical<\/p>\n

Values:<\/p>\n

Europe 73
\nJapan 79
\nUSA 254<\/p>\n

CountryOfOrigin<\/strong>: 406\u00d71 categorical<\/p>\n

Values:<\/p>\n

England 1
\nFrance 14
\nGermany 39
\nItaly 8
\nJapan 79
\nSweden 11
\nUSA 254<\/p>\n

Weight<\/strong>: 406\u00d71 double<\/p>\n

Values:<\/p>\n

Min 1613
\nMedian 2822.5
\nMax 5140<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n

Once you have learned more about the data, you can begin to think of ways to clean it up. Do you want to convert character arrays to numerical arrays, or do you want to ignore the character arrays completely? How are you going to handle missing values? What about categorical arrays? What if the minimum or maximum value of a variable seems like it is much lower or higher than it should be? Depending on the data you are working with, the answers to these questions may be different. Here are the topics I considered when cleaning up ‘carData’ before using it to create a model.<\/div>\n
<\/div>\n

Remove the String and Categorical Variables<\/span><\/h4>\n
Some algorithms that can be used to train regression models only allow for numeric values, so I removed any non-numeric and categorical variables.<\/div>\n
\n
\n
carData = removevars(carData, {‘Cyl4’<\/span>, ‘Make’<\/span>, ‘Model’<\/span>, ‘RegionOfOrigin’<\/span>,…<\/span><\/span><\/div>\n<\/div>\n
\n
‘CountryOfOrigin’<\/span>})<\/span><\/div>\n
\n
\n
\n
carData = 406\u00d77 table <\/span><\/div>\n
\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
<\/th>\nAcceleration<\/th>\nCylinders<\/th>\nDisplacement<\/th>\nHorsepower<\/th>\nYear<\/th>\nMPG<\/th>\nWeight<\/th>\n<\/tr>\n<\/thead>\n
1<\/th>\n12<\/td>\n8<\/td>\n307<\/td>\n130<\/td>\n70<\/td>\n18<\/td>\n3504<\/td>\n<\/tr>\n
2<\/th>\n11.5000<\/td>\n8<\/td>\n350<\/td>\n165<\/td>\n70<\/td>\n15<\/td>\n3693<\/td>\n<\/tr>\n
3<\/th>\n11<\/td>\n8<\/td>\n318<\/td>\n150<\/td>\n70<\/td>\n18<\/td>\n3436<\/td>\n<\/tr>\n
4<\/th>\n12<\/td>\n8<\/td>\n304<\/td>\n150<\/td>\n70<\/td>\n16<\/td>\n3433<\/td>\n<\/tr>\n
5<\/th>\n10.5000<\/td>\n8<\/td>\n302<\/td>\n140<\/td>\n70<\/td>\n17<\/td>\n3449<\/td>\n<\/tr>\n
6<\/th>\n10<\/td>\n8<\/td>\n429<\/td>\n198<\/td>\n70<\/td>\n15<\/td>\n4341<\/td>\n<\/tr>\n
7<\/th>\n9<\/td>\n8<\/td>\n454<\/td>\n220<\/td>\n70<\/td>\n14<\/td>\n4354<\/td>\n<\/tr>\n
8<\/th>\n8.5000<\/td>\n8<\/td>\n440<\/td>\n215<\/td>\n70<\/td>\n14<\/td>\n4312<\/td>\n<\/tr>\n
9<\/th>\n10<\/td>\n8<\/td>\n455<\/td>\n225<\/td>\n70<\/td>\n14<\/td>\n4425<\/td>\n<\/tr>\n
10<\/th>\n8.5000<\/td>\n8<\/td>\n390<\/td>\n190<\/td>\n70<\/td>\n15<\/td>\n3850<\/td>\n<\/tr>\n
11<\/th>\n17.5000<\/td>\n4<\/td>\n133<\/td>\n115<\/td>\n70<\/td>\nNaN<\/td>\n3090<\/td>\n<\/tr>\n
12<\/th>\n11.5000<\/td>\n8<\/td>\n350<\/td>\n165<\/td>\n70<\/td>\nNaN<\/td>\n4142<\/td>\n<\/tr>\n
13<\/th>\n11<\/td>\n8<\/td>\n351<\/td>\n153<\/td>\n70<\/td>\nNaN<\/td>\n4034<\/td>\n<\/tr>\n
14<\/th>\n10.5000<\/td>\n8<\/td>\n383<\/td>\n175<\/td>\n70<\/td>\nNaN<\/td>\n4166<\/td>\n<\/tr>\n
\u22ee<\/th>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n

<\/h4>\n

Handle Missing Data<\/span><\/h4>\n
When it comes to missing data, there are three things you should ask yourself.<\/div>\n
    \n
  1. What values are used to indicate that a piece of data is missing?<\/li>\n
  2. Is there a good way to fill in the missing data, or should I leave it as missing?<\/li>\n
  3. Under what circumstances should I delete an observation with missing data?<\/li>\n<\/ol>\n
    <\/div>\n
    What values are used to indicate that a piece of data is missing?<\/span><\/div>\n
    If your data has multiple missing value indicators and you did not import your data with the ‘TreatAsMissing’ option mentioned earlier, you can handle these missing value indicators at this step. The ‘standardizeMissing’ function allows users to easily convert custom missing value indicators to the standard missing value in MATLAB. For numeric values and durations, this standard value is NaN; for datetime values, it is NaT.<\/div>\n
    ‘carData’ only uses NaN to represent a missing value, so we do not need to modify anything in this step. Let’s say, however, that we are working with ‘messyData.csv’ again, but this time it has already been imported as a table in the variable ‘messyData’. As a reminder, the person who made this dataset used NaN, ‘-‘, ‘NA’, -99, and ‘.’ to indicate when there is missing data. To quickly standardize these missing value indicators, we can use the ‘standardizeMissing’ command as follows:<\/div>\n
    standardizedData = standardizeMissing(messyData,{‘-‘, ‘NA’, -99, ‘.’});<\/span><\/div>\n
    <\/div>\n
    Is there a good way to fill in the missing data, or should I leave it as missing?<\/span><\/div>\n
    With some datasets, there may be a good way to approximate the value of a missing entry, and if you do not have a lot of data to work with, it may be important to try to fill in these gaps.<\/div>\n
    One way to do this is to calculate simple statistics, such as the mean, median, or mode, of a given variable and replace all missing values in the variable with the result. This method is particularly effective if the values are similar. If the variable is increasing or decreasing in a linear fashion, then another way to fill a missing entry could be to approximate the value based on the neighboring values.<\/div>\n
    In MATLAB, the easiest way to fill missing entries is to use the ‘fillmissing’ function. It allows you to easily approximate and fill in missing values by indicating how you would like the values to be filled. Continuing the example from the previous section, let’s say that ‘standardizedData’ has a variable called ‘Age’ that seems to be increasing in a linear fashion, but it is missing some values. These values could easily be filled by executing the following command:<\/div>\n
    standardizedData.Age = fillmissing(standardizedData.Age, ‘linear’);<\/span><\/div>\n
    While there are certainly benefits to filling in missing values, doing so can get complicated and may result in poor performance of the model if the approximations are not representative of the actual data. Since our dataset only has a few missing values, I will be leaving these as NaN.<\/div>\n
    <\/div>\n
    Under what circumstances should I delete an observation with missing data?<\/span><\/div>\n
    The answer to this depends on a lot of things: How much data do you have to work with? How many missing values are there? What variables have the most missing data? If you have a lot of data available, it may make sense to delete any observations with missing data. If the dataset is missing a lot of entries, maybe you choose to only delete observations with 15 or more missing values.<\/div>\n
    Before we can decide what to do, we need to know what is missing. Let’s take a look at the observations in ‘carData’ that are missing any entries:<\/div>\n
    \n
    \n
    % Get indices of all missing values<\/span><\/span><\/div>\n<\/div>\n
    \n
    missingIdx = ismissing(carData);<\/span><\/div>\n<\/div>\n
    \n
    <\/div>\n<\/div>\n
    \n
    % Get indices of any rows that contain missing values<\/span><\/span><\/div>\n<\/div>\n
    \n
    rowIdxWithMissing = any(missingIdx, 2);<\/span><\/div>\n<\/div>\n
    \n
    <\/div>\n<\/div>\n
    \n
    % Return rows with missing values<\/span><\/span><\/div>\n<\/div>\n
    \n
    rowsWithMissing = carData(rowIdxWithMissing, : )<\/span><\/div>\n
    \n
    \n
    \n
    rowsWithMissing = 14\u00d77 table <\/span><\/div>\n
    \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
    <\/th>\nAcceleration<\/th>\nCylinders<\/th>\nDisplacement<\/th>\nHorsepower<\/th>\nYear<\/th>\nMPG<\/th>\nWeight<\/th>\n<\/tr>\n<\/thead>\n
    1<\/th>\n17.5000<\/td>\n4<\/td>\n133<\/td>\n115<\/td>\n70<\/td>\nNaN<\/td>\n3090<\/td>\n<\/tr>\n
    2<\/th>\n11.5000<\/td>\n8<\/td>\n350<\/td>\n165<\/td>\n70<\/td>\nNaN<\/td>\n4142<\/td>\n<\/tr>\n
    3<\/th>\n11<\/td>\n8<\/td>\n351<\/td>\n153<\/td>\n70<\/td>\nNaN<\/td>\n4034<\/td>\n<\/tr>\n
    4<\/th>\n10.5000<\/td>\n8<\/td>\n383<\/td>\n175<\/td>\n70<\/td>\nNaN<\/td>\n4166<\/td>\n<\/tr>\n
    5<\/th>\n11<\/td>\n8<\/td>\n360<\/td>\n175<\/td>\n70<\/td>\nNaN<\/td>\n3850<\/td>\n<\/tr>\n
    6<\/th>\n8<\/td>\n8<\/td>\n302<\/td>\n140<\/td>\n70<\/td>\nNaN<\/td>\n3353<\/td>\n<\/tr>\n
    7<\/th>\n19<\/td>\n4<\/td>\n98<\/td>\nNaN<\/td>\n71<\/td>\n25<\/td>\n2046<\/td>\n<\/tr>\n
    8<\/th>\n20<\/td>\n4<\/td>\n97<\/td>\n48<\/td>\n71<\/td>\nNaN<\/td>\n1978<\/td>\n<\/tr>\n
    9<\/th>\n17<\/td>\n6<\/td>\n200<\/td>\nNaN<\/td>\n74<\/td>\n21<\/td>\n2875<\/td>\n<\/tr>\n
    10<\/th>\n17.3000<\/td>\n4<\/td>\n85<\/td>\nNaN<\/td>\n80<\/td>\n40.9000<\/td>\n1835<\/td>\n<\/tr>\n
    11<\/th>\n14.3000<\/td>\n4<\/td>\n140<\/td>\nNaN<\/td>\n80<\/td>\n23.6000<\/td>\n2905<\/td>\n<\/tr>\n
    12<\/th>\n15.8000<\/td>\n4<\/td>\n100<\/td>\nNaN<\/td>\n81<\/td>\n34.5000<\/td>\n2320<\/td>\n<\/tr>\n
    13<\/th>\n15.4000<\/td>\n4<\/td>\n121<\/td>\n110<\/td>\n81<\/td>\nNaN<\/td>\n2800<\/td>\n<\/tr>\n
    14<\/th>\n20.5000<\/td>\n4<\/td>\n151<\/td>\nNaN<\/td>\n82<\/td>\n23<\/td>\n3035<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
    As you can see, ‘carData’ does not have a lot of missing data, but we do not have an abundance of observations to work with either. Some of the missing values are in the ‘MPG’ variable, which is the value that we want our model to predict. Since we cannot train a model without a predictor variable, I delete all observations that are missing the ‘MPG’ value, but leave the other missing values.<\/div>\n
    \n
    \n
    carData = rmmissing(carData, ‘DataVariables’<\/span>, ‘MPG’<\/span>)<\/span><\/div>\n
    \n
    \n
    \n
    carData = 398\u00d77 table <\/span><\/div>\n
    \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
    <\/th>\nAcceleration<\/th>\nCylinders<\/th>\nDisplacement<\/th>\nHorsepower<\/th>\nYear<\/th>\nMPG<\/th>\nWeight<\/th>\n<\/tr>\n<\/thead>\n
    1<\/th>\n12<\/td>\n8<\/td>\n307<\/td>\n130<\/td>\n70<\/td>\n18<\/td>\n3504<\/td>\n<\/tr>\n
    2<\/th>\n11.5000<\/td>\n8<\/td>\n350<\/td>\n165<\/td>\n70<\/td>\n15<\/td>\n3693<\/td>\n<\/tr>\n
    3<\/th>\n11<\/td>\n8<\/td>\n318<\/td>\n150<\/td>\n70<\/td>\n18<\/td>\n3436<\/td>\n<\/tr>\n
    4<\/th>\n12<\/td>\n8<\/td>\n304<\/td>\n150<\/td>\n70<\/td>\n16<\/td>\n3433<\/td>\n<\/tr>\n
    5<\/th>\n10.5000<\/td>\n8<\/td>\n302<\/td>\n140<\/td>\n70<\/td>\n17<\/td>\n3449<\/td>\n<\/tr>\n
    6<\/th>\n10<\/td>\n8<\/td>\n429<\/td>\n198<\/td>\n70<\/td>\n15<\/td>\n4341<\/td>\n<\/tr>\n
    7<\/th>\n9<\/td>\n8<\/td>\n454<\/td>\n220<\/td>\n70<\/td>\n14<\/td>\n4354<\/td>\n<\/tr>\n
    8<\/th>\n8.5000<\/td>\n8<\/td>\n440<\/td>\n215<\/td>\n70<\/td>\n14<\/td>\n4312<\/td>\n<\/tr>\n
    9<\/th>\n10<\/td>\n8<\/td>\n455<\/td>\n225<\/td>\n70<\/td>\n14<\/td>\n4425<\/td>\n<\/tr>\n
    10<\/th>\n8.5000<\/td>\n8<\/td>\n390<\/td>\n190<\/td>\n70<\/td>\n15<\/td>\n3850<\/td>\n<\/tr>\n
    11<\/th>\n10<\/td>\n8<\/td>\n383<\/td>\n170<\/td>\n70<\/td>\n15<\/td>\n3563<\/td>\n<\/tr>\n
    12<\/th>\n8<\/td>\n8<\/td>\n340<\/td>\n160<\/td>\n70<\/td>\n14<\/td>\n3609<\/td>\n<\/tr>\n
    13<\/th>\n9.5000<\/td>\n8<\/td>\n400<\/td>\n150<\/td>\n70<\/td>\n15<\/td>\n3761<\/td>\n<\/tr>\n
    14<\/th>\n10<\/td>\n8<\/td>\n455<\/td>\n225<\/td>\n70<\/td>\n14<\/td>\n3086<\/td>\n<\/tr>\n
    \u22ee<\/th>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
    <\/div>\n

    Finalize the data<\/span><\/h4>\n
    At this point, ‘carData’ should have 7 variables left: ‘Acceleration’, ‘Cylinders’, ‘Displacement’, ‘Horsepower’, ‘Year’, ‘MPG’, and ‘Weight’. Since ‘MPG’ is our predictor variable, I will move this to be the last column in the table.<\/div>\n
    \n
    \n
    carData = movevars(carData, “MPG”<\/span>, “After”<\/span>, “Weight”<\/span>)<\/span><\/div>\n
    \n
    \n
    \n
    carData = 398\u00d77 table <\/span><\/div>\n
    \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
    <\/th>\nAcceleration<\/th>\nCylinders<\/th>\nDisplacement<\/th>\nHorsepower<\/th>\nYear<\/th>\nWeight<\/th>\nMPG<\/th>\n<\/tr>\n<\/thead>\n
    1<\/th>\n12<\/td>\n8<\/td>\n307<\/td>\n130<\/td>\n70<\/td>\n3504<\/td>\n18<\/td>\n<\/tr>\n
    2<\/th>\n11.5000<\/td>\n8<\/td>\n350<\/td>\n165<\/td>\n70<\/td>\n3693<\/td>\n15<\/td>\n<\/tr>\n
    3<\/th>\n11<\/td>\n8<\/td>\n318<\/td>\n150<\/td>\n70<\/td>\n3436<\/td>\n18<\/td>\n<\/tr>\n
    4<\/th>\n12<\/td>\n8<\/td>\n304<\/td>\n150<\/td>\n70<\/td>\n3433<\/td>\n16<\/td>\n<\/tr>\n
    5<\/th>\n10.5000<\/td>\n8<\/td>\n302<\/td>\n140<\/td>\n70<\/td>\n3449<\/td>\n17<\/td>\n<\/tr>\n
    6<\/th>\n10<\/td>\n8<\/td>\n429<\/td>\n198<\/td>\n70<\/td>\n4341<\/td>\n15<\/td>\n<\/tr>\n
    7<\/th>\n9<\/td>\n8<\/td>\n454<\/td>\n220<\/td>\n70<\/td>\n4354<\/td>\n14<\/td>\n<\/tr>\n
    8<\/th>\n8.5000<\/td>\n8<\/td>\n440<\/td>\n215<\/td>\n70<\/td>\n4312<\/td>\n14<\/td>\n<\/tr>\n
    9<\/th>\n10<\/td>\n8<\/td>\n455<\/td>\n225<\/td>\n70<\/td>\n4425<\/td>\n14<\/td>\n<\/tr>\n
    10<\/th>\n8.5000<\/td>\n8<\/td>\n390<\/td>\n190<\/td>\n70<\/td>\n3850<\/td>\n15<\/td>\n<\/tr>\n
    11<\/th>\n10<\/td>\n8<\/td>\n383<\/td>\n170<\/td>\n70<\/td>\n3563<\/td>\n15<\/td>\n<\/tr>\n
    12<\/th>\n8<\/td>\n8<\/td>\n340<\/td>\n160<\/td>\n70<\/td>\n3609<\/td>\n14<\/td>\n<\/tr>\n
    13<\/th>\n9.5000<\/td>\n8<\/td>\n400<\/td>\n150<\/td>\n70<\/td>\n3761<\/td>\n15<\/td>\n<\/tr>\n
    14<\/th>\n10<\/td>\n8<\/td>\n455<\/td>\n225<\/td>\n70<\/td>\n3086<\/td>\n14<\/td>\n<\/tr>\n
    \u22ee<\/th>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
    This is because many of MATLAB’s machine learning tools assume that the final variable in an input table will be the predictor, so by moving this now it makes it easier for us to work with the data in the future.<\/div>\n
    <\/div>\n

    Step 3: Create Training and Testing Data<\/h3>\n
    No matter what format your data is in, it is important to have separate training and testing data. Training data is fed to the model, which “teaches” the model how to predict the output value; the testing data is sent to the model after it has already been trained to see how well it performs on new data. Often, it is also beneficial to have validation data, which is used during training to prevent overfitting.<\/div>\n
    Overfitting is when the model learns the training data so well that it is able to predict the output of the training data with a high level of accuracy, but performs poorly when predicting the output for any other data. This could be caused by a number of things, including a lack of diversity in the training data. If we trained our car model on only 4 cylinder cars from the early 90’s, for example, the model would likely learn how to predict the miles per gallon for those cars very well, but would not be able to do so for any other type of vehicle. Validation data may be excluded from training data and is used to intermittently test the overall performance of the model, as this provides an idea of what the model’s overall accuracy may be.<\/div>\n
    <\/div>\n

    Separate the dataset<\/span><\/h4>\n
    Many of MATLAB’s tools use sections of the training data to perform validation, so I will only be creating a training set and a testing set. When creating these different datasets, it is important to try to ensure that both sets contain a variety of data to avoid bias and overfitting. If your data represents buildings, ensure it has data for different types of buildings. If it represents patients, include various ages, races, and previous health history. If it is images, include different angles and lighting. In this case, ‘carData’ is sorted by Year, so if I were to just split the data in half, both sets of data would be missing any cars from several years. Instead, I separate the data by intervals.<\/div>\n
    \n
    \n
    % every third observation is used for testing<\/span><\/span><\/div>\n<\/div>\n
    \n
    testIdx = 1:3:398;<\/span><\/div>\n<\/div>\n
    \n
    testData = carData(testIdx, : )<\/span><\/div>\n
    \n
    \n
    \n
    testData = 133\u00d77 table <\/span><\/div>\n
    \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
    <\/th>\nAcceleration<\/th>\nCylinders<\/th>\nDisplacement<\/th>\nHorsepower<\/th>\nYear<\/th>\nWeight<\/th>\nMPG<\/th>\n<\/tr>\n<\/thead>\n
    1<\/th>\n12<\/td>\n8<\/td>\n307<\/td>\n130<\/td>\n70<\/td>\n3504<\/td>\n18<\/td>\n<\/tr>\n
    2<\/th>\n12<\/td>\n8<\/td>\n304<\/td>\n150<\/td>\n70<\/td>\n3433<\/td>\n16<\/td>\n<\/tr>\n
    3<\/th>\n9<\/td>\n8<\/td>\n454<\/td>\n220<\/td>\n70<\/td>\n4354<\/td>\n14<\/td>\n<\/tr>\n
    4<\/th>\n8.5000<\/td>\n8<\/td>\n390<\/td>\n190<\/td>\n70<\/td>\n3850<\/td>\n15<\/td>\n<\/tr>\n
    5<\/th>\n9.5000<\/td>\n8<\/td>\n400<\/td>\n150<\/td>\n70<\/td>\n3761<\/td>\n15<\/td>\n<\/tr>\n
    6<\/th>\n15.5000<\/td>\n6<\/td>\n198<\/td>\n95<\/td>\n70<\/td>\n2833<\/td>\n22<\/td>\n<\/tr>\n
    7<\/th>\n14.5000<\/td>\n4<\/td>\n97<\/td>\n88<\/td>\n70<\/td>\n2130<\/td>\n27<\/td>\n<\/tr>\n
    8<\/th>\n14.5000<\/td>\n4<\/td>\n107<\/td>\n90<\/td>\n70<\/td>\n2430<\/td>\n24<\/td>\n<\/tr>\n
    9<\/th>\n15<\/td>\n6<\/td>\n199<\/td>\n90<\/td>\n70<\/td>\n2648<\/td>\n21<\/td>\n<\/tr>\n
    10<\/th>\n13.5000<\/td>\n8<\/td>\n318<\/td>\n210<\/td>\n70<\/td>\n4382<\/td>\n11<\/td>\n<\/tr>\n
    11<\/th>\n15.5000<\/td>\n4<\/td>\n140<\/td>\n90<\/td>\n71<\/td>\n2264<\/td>\n28<\/td>\n<\/tr>\n
    12<\/th>\n13<\/td>\n6<\/td>\n232<\/td>\n100<\/td>\n71<\/td>\n2634<\/td>\n19<\/td>\n<\/tr>\n
    13<\/th>\n15.5000<\/td>\n6<\/td>\n250<\/td>\n88<\/td>\n71<\/td>\n3302<\/td>\n19<\/td>\n<\/tr>\n
    14<\/th>\n11.5000<\/td>\n8<\/td>\n400<\/td>\n175<\/td>\n71<\/td>\n4464<\/td>\n14<\/td>\n<\/tr>\n
    \u22ee<\/th>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
    \n
    % the rest is used for training. Remove testing data from trainData<\/span><\/span><\/div>\n<\/div>\n
    \n
    trainData = carData;<\/span><\/div>\n<\/div>\n
    \n
    trainData(testIdx, : ) = []<\/span><\/div>\n
    \n
    \n
    \n
    trainData = 265\u00d77 table <\/span><\/div>\n
    \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
    <\/th>\nAcceleration<\/th>\nCylinders<\/th>\nDisplacement<\/th>\nHorsepower<\/th>\nYear<\/th>\nWeight<\/th>\nMPG<\/th>\n<\/tr>\n<\/thead>\n
    1<\/th>\n11.5000<\/td>\n8<\/td>\n350<\/td>\n165<\/td>\n70<\/td>\n3693<\/td>\n15<\/td>\n<\/tr>\n
    2<\/th>\n11<\/td>\n8<\/td>\n318<\/td>\n150<\/td>\n70<\/td>\n3436<\/td>\n18<\/td>\n<\/tr>\n
    3<\/th>\n10.5000<\/td>\n8<\/td>\n302<\/td>\n140<\/td>\n70<\/td>\n3449<\/td>\n17<\/td>\n<\/tr>\n
    4<\/th>\n10<\/td>\n8<\/td>\n429<\/td>\n198<\/td>\n70<\/td>\n4341<\/td>\n15<\/td>\n<\/tr>\n
    5<\/th>\n8.5000<\/td>\n8<\/td>\n440<\/td>\n215<\/td>\n70<\/td>\n4312<\/td>\n14<\/td>\n<\/tr>\n
    6<\/th>\n10<\/td>\n8<\/td>\n455<\/td>\n225<\/td>\n70<\/td>\n4425<\/td>\n14<\/td>\n<\/tr>\n
    7<\/th>\n10<\/td>\n8<\/td>\n383<\/td>\n170<\/td>\n70<\/td>\n3563<\/td>\n15<\/td>\n<\/tr>\n
    8<\/th>\n8<\/td>\n8<\/td>\n340<\/td>\n160<\/td>\n70<\/td>\n3609<\/td>\n14<\/td>\n<\/tr>\n
    9<\/th>\n10<\/td>\n8<\/td>\n455<\/td>\n225<\/td>\n70<\/td>\n3086<\/td>\n14<\/td>\n<\/tr>\n
    10<\/th>\n15<\/td>\n4<\/td>\n113<\/td>\n95<\/td>\n70<\/td>\n2372<\/td>\n24<\/td>\n<\/tr>\n
    11<\/th>\n15.5000<\/td>\n6<\/td>\n199<\/td>\n97<\/td>\n70<\/td>\n2774<\/td>\n18<\/td>\n<\/tr>\n
    12<\/th>\n16<\/td>\n6<\/td>\n200<\/td>\n85<\/td>\n70<\/td>\n2587<\/td>\n21<\/td>\n<\/tr>\n
    13<\/th>\n20.5000<\/td>\n4<\/td>\n97<\/td>\n46<\/td>\n70<\/td>\n1835<\/td>\n26<\/td>\n<\/tr>\n
    14<\/th>\n17.5000<\/td>\n4<\/td>\n110<\/td>\n87<\/td>\n70<\/td>\n2672<\/td>\n25<\/td>\n<\/tr>\n
    \u22ee<\/th>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
    It is up to you to determine how you will split the data between training and testing. A common starting point uses approximately 80% of the data for training and 20% for testing. In this example, since we only have 398 observations, I split it up so that 66% of the dataset is used for training and 33% is used for testing.<\/div>\n
    <\/div>\n

    Separate the Predictor Variable from the Testing Data<\/span><\/h4>\n
    Once I have a testing set, I remove the predictor variable ‘MPG’ from the table and store it in its own variable. This will make it easier to evaluate the model’s performance later.<\/div>\n
    \n
    \n
    testAnswers = testData.MPG;<\/span><\/div>\n<\/div>\n
    \n
    testData = removevars(testData, “MPG”<\/span>)<\/span><\/div>\n
    \n
    \n
    \n
    testData = 133\u00d76 table <\/span><\/div>\n
    \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
    <\/th>\nAcceleration<\/th>\nCylinders<\/th>\nDisplacement<\/th>\nHorsepower<\/th>\nYear<\/th>\nWeight<\/th>\n<\/tr>\n<\/thead>\n
    1<\/th>\n12<\/td>\n8<\/td>\n307<\/td>\n130<\/td>\n70<\/td>\n3504<\/td>\n<\/tr>\n
    2<\/th>\n12<\/td>\n8<\/td>\n304<\/td>\n150<\/td>\n70<\/td>\n3433<\/td>\n<\/tr>\n
    3<\/th>\n9<\/td>\n8<\/td>\n454<\/td>\n220<\/td>\n70<\/td>\n4354<\/td>\n<\/tr>\n
    4<\/th>\n8.5000<\/td>\n8<\/td>\n390<\/td>\n190<\/td>\n70<\/td>\n3850<\/td>\n<\/tr>\n
    5<\/th>\n9.5000<\/td>\n8<\/td>\n400<\/td>\n150<\/td>\n70<\/td>\n3761<\/td>\n<\/tr>\n
    6<\/th>\n15.5000<\/td>\n6<\/td>\n198<\/td>\n95<\/td>\n70<\/td>\n2833<\/td>\n<\/tr>\n
    7<\/th>\n14.5000<\/td>\n4<\/td>\n97<\/td>\n88<\/td>\n70<\/td>\n2130<\/td>\n<\/tr>\n
    8<\/th>\n14.5000<\/td>\n4<\/td>\n107<\/td>\n90<\/td>\n70<\/td>\n2430<\/td>\n<\/tr>\n
    9<\/th>\n15<\/td>\n6<\/td>\n199<\/td>\n90<\/td>\n70<\/td>\n2648<\/td>\n<\/tr>\n
    10<\/th>\n13.5000<\/td>\n8<\/td>\n318<\/td>\n210<\/td>\n70<\/td>\n4382<\/td>\n<\/tr>\n
    11<\/th>\n15.5000<\/td>\n4<\/td>\n140<\/td>\n90<\/td>\n71<\/td>\n2264<\/td>\n<\/tr>\n
    12<\/th>\n13<\/td>\n6<\/td>\n232<\/td>\n100<\/td>\n71<\/td>\n2634<\/td>\n<\/tr>\n
    13<\/th>\n15.5000<\/td>\n6<\/td>\n250<\/td>\n88<\/td>\n71<\/td>\n3302<\/td>\n<\/tr>\n
    14<\/th>\n11.5000<\/td>\n8<\/td>\n400<\/td>\n175<\/td>\n71<\/td>\n4464<\/td>\n<\/tr>\n
    \u22ee<\/th>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
    If the data you are working with was already separated into training and testing sets, then this step should be relatively simple. Make sure you have imported and cleaned up both sets of data, and then remove the predictor variable from the testing set and save it in a different variable.<\/div>\n
    <\/div>\n

    Train a Model<\/span><\/h2>\n
    Now that the data has been prepared, it is time to start training a model! I will be showing how to use the Regression Learner app<\/a> to create a model, but I will also include examples at the bottom of this section that showcase programmatic workflows for creating a model if you want to learn more about these options. Additionally, if you would like to watch a video overview of the Regression Learner app, you can find one for a different dataset here<\/a>!<\/div>\n
    <\/div>\n

    Step 4: Train Models using the Regression Learner App<\/h3>\n
    The Regression Learner App lets you interactively train, validate, and tune different regression models. Here is how I create a model that will predict a vehicle’s miles per gallon based on our data:<\/div>\n
    1. Open the App: <\/span>On the ‘Apps’ tab, in the ‘Machine Learning and Deep Learning’ section, click Regression Learner<\/span>.<\/div>\n
    Alternatively, you can open the Regression Learner app from the command line:<\/div>\n
    \n
    \n
    regressionLearner<\/span><\/div>\n<\/div>\n<\/div>\n
    <\/div>\n
    2. Start a New Session: <\/span>Click New Session<\/span> and select your training data from the workspace. Specify the response variable.<\/div>\n
    <\/div>\n
    3. Choose a Validation Method: <\/span>Select the validation method you want to use to avoid overfitting. You should see three options: Cross-Validation, Holdout Validation, and Resubstitution Validation. I chose Cross-Validation for this example, but for problems where you have a large amount of data to work with you may wish to choose Holdout Validation. You can refer to this documentation page<\/a> to learn more about these validation methods.<\/div>\n
    <\/div>\n
    4. <\/span>Click Start Session<\/span><\/div>\n
    \"OpenRegressionApp.gif\"<\/div>\n
    <\/div>\n
    5. Investigate Variable-Response Relationships: <\/span>Use the response plot to investigate which variables are useful for predicting the response. To visualize the relationship between different predictor variables and the response variable (‘MPG’), select different variables in the ‘X’ list under ‘X-axis’. Observe which variables are correlated most clearly with the response. Displacement, Horsepower, and Weight all have a visible impact on the response and all show a negative association with the response.<\/div>\n
    \"\"<\/div>\n
    <\/div>\n
    6. Select Model(s): <\/span>On the ‘Regression Learner’ tab, in the ‘Model Type’ section, select the algorithm to be trained. I have chosen to train All<\/span>, so that I can see which model type performs the best on the data.<\/div>\n
    <\/div>\n
    7.<\/span> Tune parameters: <\/span>The Regression Learner app enables users to specify certain preferences when training a model. Options in the ‘Features’ section allow you to choose which variables are used to train the model or to enable principal component analysis (PCA). Parameters can be further adjusted by selecting a model in the ‘Models’ window and then clicking on Advanced <\/span>in the ‘Regression Learner’ tab. To learn more about the advanced options for each model type, please refer to this documentation page<\/a>.<\/div>\n
    Since we are creating our first model, I will be leaving the parameters as their default values.<\/div>\n
    <\/div>\n
    8. <\/span>Click Train<\/span>.<\/div>\n
    \"TrainModels.gif\"<\/div>\n
    <\/div>\n
    9. Investigate Model Performance: <\/span>Once the models have finished training and validation, the ‘Models’ window on the left displays the trained models and their root mean square error (RMSE). Notice that Model 1.18 has the lowest RMSE, and that the value is highlighted to indicate this. Please note: the numbers you see may be a little different.<\/div>\n
    In addition to the RSMEs, you can measure the results of training by creating visuals through the ‘Plots’ section of the ‘Regression Learner’ tab. The ‘Validation Results’ section of the drop down menu allows you to plot the relationships between predicted ‘MPG’ of the validation data and the actual ‘MPG’ of the validation data for any trained model. Simply click on the model you want to evaluate, then click on the type of plot you want to see!<\/div>\n
    \"EvaluateInApp.gif\"<\/div>\n
    To learn more about assessing a model from within the app, please refer to this documentation page<\/a>.<\/div>\n
    <\/div>\n
    10. Choose a Model: <\/span>For this example, I will be using Model 1.18 that we trained in the previous step.<\/div>\n
    <\/div>\n

    Step 5: Export your Model<\/h3>\n
    Once you have tested different settings and found a model that performs well, export the model to the Workspace by selecting Export Model<\/span> from the Regression Learner app. This will allow you to make predictions on the test set. I used the default name ‘trainedModel’ when exporting.<\/div>\n
    \"ExportModel.gif\"<\/div>\n
    <\/div>\n
    As can be seen below, the exported model is actually a structure containing the model object as well as some additional information about the model, or metadata<\/span>. Since the model I have exported is a Gaussian Process model, the model object is stored in the ‘RegressionGP’ property of ‘trainedModel’. If you have exported a different type of model, this property will be called something different. You can learn the name of the propety that contains your model object by executing the following command and identifying what property replaces ‘RegressionGP’ for your model.<\/div>\n
    \n
    \n
    trainedModel<\/span><\/div>\n
    \n
    \n
    \n
    trainedModel = struct with fields:<\/span><\/span><\/div>\n
    predictFcn: @(x)exportableModel.predictFcn(predictorExtractionFcn(x))
    \nRequiredVariables: {‘Acceleration’ ‘Cylinders’ ‘Displacement’ ‘Horsepower’ ‘Weight’ ‘Year’}
    \nRegressionGP: [1\u00d71 RegressionGP]
    \nAbout: ‘This struct is a trained model exported from Regression Learner R2021b.’
    \nHowToPredict: ‘To make predictions on a new table, T, use: \u21b5 yfit = c.predictFcn(T) \u21b5replacing ‘c’ with the name of the variable that is this struct, e.g. ‘trainedModel’. \u21b5 \u21b5The table, T, must contain the variables returned by: \u21b5 c.RequiredVariables \u21b5Variable formats (e.g. matrix\/vector, datatype) must match the original training data. \u21b5Additional variables are ignored. \u21b5 \u21b5For more information, see How to predict using an exported model.’<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
    So, if I need to access the model object without any of the metadata, I can execute the following:<\/div>\n
    \n
    \n
    trainedModel.RegressionGP<\/span><\/div>\n
    \n
    \n
    \n
    ans = <\/span><\/div>\n
    RegressionGP
    \nPredictorNames: {‘Acceleration’ ‘Cylinders’ ‘Displacement’ ‘Horsepower’ ‘Year’ ‘Weight’}
    \nResponseName: ‘Y’
    \nCategoricalPredictors: []
    \nResponseTransform: ‘none’
    \nNumObservations: 263
    \nKernelFunction: ‘Exponential’
    \nKernelInformation: [1\u00d71 struct]
    \nBasisFunction: ‘Constant’
    \nBeta: 27.6840
    \nSigma: 1.8047
    \nPredictorLocation: [6\u00d71 double]
    \nPredictorScale: [6\u00d71 double]
    \nAlpha: [263\u00d71 double]
    \nActiveSetVectors: [263\u00d76 double]
    \nPredictMethod: ‘Exact’
    \nActiveSetSize: 263
    \nFitMethod: ‘Exact’
    \nActiveSetMethod: ‘Random’
    \nIsActiveSetVector: [263\u00d71 logical]
    \nLogLikelihood: -651.3821
    \nActiveSetHistory: []
    \nBCDInformation: []Properties, Methods<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
    <\/div>\n

    Examples: Using Custom Algorithms<\/h3>\n
    If you have some experience with regression learning, then you may wish to also explore programmatic options for developing a regression model. I have included some example workflows below that may help you get started. These workflows could be done instead of or in addition to using the regression learner app.<\/div>\n