KAHIBARO Bookshelves
Discord Login Register

16.3. Basic Correlation and Regression

Understanding Relationships Between Variables

In data analysis you often want to know whether two quantities move together and how to describe that relationship with a simple mathematical model. Correlation and regression are basic tools for this purpose in MATLAB.

This chapter focuses on how to compute and interpret simple correlation and basic linear regression in MATLAB, and how to work with the most important functions and outputs. It does not cover more advanced statistical modeling or time series, which appear elsewhere in the course.

Correlation in MATLAB

Correlation measures the strength and direction of a linear relationship between two variables. In MATLAB you typically use corrcoef to compute the Pearson correlation coefficient.

Suppose you have two numeric vectors x and y of the same length. You can compute the correlation matrix as:

x = [1 2 3 4 5];
y = [2.1 4.0 6.1 7.8 10.2];
R = corrcoef(x, y)

The result R is a 2-by-2 matrix. The diagonal elements are 1, and the off diagonal elements are the correlation between x and y. You usually care about one of these off diagonal values:

r = R(1,2);

This r is the sample Pearson correlation coefficient, which ranges between -1 and 1. Positive values indicate that as x increases, y tends to increase. Negative values indicate that as x increases, y tends to decrease. Values near 0 indicate little or no linear relationship.

You can also compute correlations for multiple variables at once. If you have a matrix X where each column is a different variable observed for the same cases, corrcoef(X) returns a correlation matrix whose entry in row i, column j is the correlation between column i and column j of X.

If your data is in a table, you can convert selected variables to a matrix using {:,:} or table2array, then pass that matrix to corrcoef.

Visualizing Correlation with Scatter Plots

It is helpful to look at a scatter plot before trusting a correlation value. You can create a basic scatter plot with:

scatter(x, y);
xlabel('x');
ylabel('y');
title('Scatter of y vs x');

A roughly straight cloud of points that slopes upward corresponds to a positive correlation. A downward slope corresponds to a negative correlation. If the pattern is curved or very irregular, the correlation coefficient alone may be misleading, even if its magnitude is large.

Scatter plots are also useful for spotting outliers, which can strongly affect the correlation value.

Simple Linear Regression with polyfit

Basic linear regression fits a straight line to describe how a response variable y changes as a predictor x changes. A simple way to do this in MATLAB is with the function polyfit.

For a straight line, you use a polynomial of degree 1. The model is

$$
y \approx p_1 x + p_2,
$$

where p1 is the slope and p2 is the intercept. In MATLAB:

p = polyfit(x, y, 1);
slope     = p(1);
intercept = p(2);

You can then compute fitted values of y for given x using polyval:

yfit = polyval(p, x);

If x is a vector of original data points, yfit contains the predicted values at those points. If you create a finer grid for plotting, for example with linspace, you can draw a smooth regression line.

Plotting a Regression Line

To see the fitted line on top of your data, you can combine scatter, polyfit, and polyval. Here is a typical pattern:

x = [1 2 3 4 5];
y = [2.1 4.0 6.1 7.8 10.2];
p = polyfit(x, y, 1);       % fit line
xline = linspace(min(x), max(x), 100);
yline = polyval(p, xline);  % predicted values
scatter(x, y, 'filled');
hold on;
plot(xline, yline, 'r-', 'LineWidth', 2);
hold off;
xlabel('x');
ylabel('y');
title('Linear Regression Fit');

The hold on and hold off commands let you plot the points and the line in the same axes. The red line shows the linear trend estimated by regression.

Regression with fitlm for Extra Output

If you have the Statistics and Machine Learning Toolbox, the function fitlm provides a richer interface for linear regression. It uses a model that can be written as

$$
y = \beta_0 + \beta_1 x + \varepsilon,
$$

where $\beta_0$ is the intercept, $\beta_1$ is the slope, and $\varepsilon$ is random error.

A basic usage for vectors x and y is:

mdl = fitlm(x, y);

The result mdl is a linear model object that contains many properties. Some of the most useful for beginners are:

mdl.Coefficients: a table with the estimated intercept and slope.
mdl.Rsquared.Ordinary: the coefficient of determination, a measure between 0 and 1 of how much of the variation in y is explained by the linear model.
mdl.Fitted: the fitted values of y for each observation.
mdl.Residuals: the differences between observed and fitted values.

You can display a summary in the Command Window simply by typing:

mdl

If your data is in a table, you can call fitlm with table variable names. For example, if T is a table with variables Height and Weight, you can write:

mdl = fitlm(T, 'Weight ~ Height');

The formula 'Weight ~ Height' tells MATLAB to model Weight as a linear function of Height.

Interpreting Basic Regression Results

For a simple regression with one predictor, the key numbers are:

The slope, which tells you the estimated change in y for a one unit increase in x.
The intercept, which is the estimated value of y when x is zero.
The coefficient of determination $R^2$, which summarizes how well the line fits the data.

If you used fitlm, you can access these as:

coefTable = mdl.Coefficients;
intercept = coefTable.Estimate(1);
slope     = coefTable.Estimate(2);
R2        = mdl.Rsquared.Ordinary;

A value of $R^2$ close to 1 indicates that the line accounts for most of the variability in y. A small $R^2$ means the linear model does not explain much of the variation.

You can add the fitted line from a fitlm model to a scatter plot using the plot method of the model object:

plot(mdl);

This command creates a figure that includes the data and the regression line, along with some diagnostic information. If you want more control, you can extract the fitted values manually and use plot as shown before.

Correlation and Regression Together

Although correlation and regression are related, they are not the same thing. Correlation summarizes how strongly two variables vary together in a linear way. Regression provides an explicit equation that describes how one variable changes on average when the other changes.

In practice with MATLAB, you might often compute both. A typical workflow is:

Use scatter to visualize the relationship.
Use corrcoef to compute the correlation coefficient.
Use polyfit or fitlm to obtain a regression line and fitted values.
Inspect residuals or $R^2$ to judge the quality of the fit.

Remember that both correlation and simple linear regression, as described here, focus on linear relationships and may not capture curved or more complex patterns.

Important points to remember:
Use corrcoef for basic Pearson correlation between numeric variables.
Always inspect scatter plots to see if a linear summary is reasonable.
Use polyfit and polyval for quick straight line fits and plotting.
Use fitlm for richer regression output such as coefficients and $R^2`.
Correlation and regression describe linear relationships and can be misleading when the pattern is strongly non linear or affected by outliers.

Views: 0

Comments

Please login to add a comment.

Don't have an account? Register now!

Where to Move

Move chapter:

  • ☰ 1. Getting Started with MATLAB
    • ☰ 1.1. What Is MATLAB and What Is It Used For
      • ☰ 1.2. Installing MATLAB and Setting Up the Environment
        • ☰ 1.3. Understanding the MATLAB Desktop Interface
          • ☰ 1.4. Command Window, Workspace, and Current Folder
            • ☰ 1.5. Basic Workflow and Running Simple Commands
              • ☰ 1.6. Getting Help and Documentation
              • ☰ 2. MATLAB Language Basics
                • ☰ 2.1. MATLAB Syntax and Expressions
                  • ☰ 2.2. Variables and Assignment
                    • ☰ 2.3. Data Types and Type Conversion
                      • ☰ 2.4. Vectors and Matrices Fundamentals
                        • ☰ 2.5. Creating and Indexing Arrays
                          • ☰ 2.6. Basic Arithmetic and Elementwise Operations
                            • ☰ 2.7. Using Built-In Constants and Functions
                            • ☰ 3. Working with Variables and the Workspace
                              • ☰ 3.1. Creating, Viewing, and Editing Variables
                                • ☰ 3.2. Workspace Browser and Variable Inspector
                                  • ☰ 3.3. Saving and Loading Data Files
                                    • ☰ 3.4. MAT-Files and Importing External Data
                                      • ☰ 3.5. Clearing Variables and Managing the Workspace
                                      • ☰ 4. Vectors, Matrices, and Arrays
                                        • ☰ 4.1. Row and Column Vectors
                                          • ☰ 4.2. Matrix Creation and Concatenation
                                            • ☰ 4.3. Indexing, Slicing, and Logical Indexing
                                              • ☰ 4.4. Matrix Operations vs Elementwise Operations
                                                • ☰ 4.5. Reshaping and Rearranging Arrays
                                                  • ☰ 4.6. Special Matrices and Functions
                                                  • ☰ 5. Basic Programming Constructs
                                                    • ☰ 5.1. Scripts vs Functions
                                                      • ☰ 5.2. Control Flow with if, elseif, else
                                                        • ☰ 5.3. Loops with for and while
                                                          • ☰ 5.4. break, continue, and return
                                                            • ☰ 5.5. Logical Expressions and Relational Operators
                                                              • ☰ 5.6. Best Practices for Clear and Readable Code
                                                              • ☰ 6. Functions in MATLAB
                                                                • ☰ 6.1. Creating Simple Functions
                                                                  • ☰ 6.2. Function Inputs and Outputs
                                                                    • ☰ 6.3. Function Files and the Path
                                                                      • ☰ 6.4. Local vs Global Variables
                                                                        • ☰ 6.5. Anonymous Functions
                                                                          • ☰ 6.6. Organizing Code into Multiple Functions
                                                                          • ☰ 7. Working with Numbers and Math
                                                                            • ☰ 7.1. Scalars and Vectorized Computations
                                                                              • ☰ 7.2. Basic Mathematical Functions
                                                                                • ☰ 7.3. Trigonometric and Exponential Functions
                                                                                  • ☰ 7.4. Complex Numbers in MATLAB
                                                                                    • ☰ 7.5. Rounding, Modulo, and Special Values
                                                                                      • ☰ 7.6. Numerical Precision and Floating Point Considerations
                                                                                      • ☰ 8. Strings, Characters, and Categorical Data
                                                                                        • ☰ 8.1. Character Arrays and String Arrays
                                                                                          • ☰ 8.2. Creating and Manipulating Strings
                                                                                            • ☰ 8.3. Converting Between Data Types and Strings
                                                                                              • ☰ 8.4. Comparing and Searching Strings
                                                                                                • ☰ 8.5. Categorical Arrays Basics
                                                                                                • ☰ 9. Tables, Structures, and Cell Arrays
                                                                                                  • ☰ 9.1. Introduction to Tables
                                                                                                    • ☰ 9.2. Creating Tables and Accessing Data
                                                                                                      • ☰ 9.3. Modifying and Joining Tables
                                                                                                        • ☰ 9.4. Structures and Nested Structures
                                                                                                          • ☰ 9.5. Cell Arrays and Cell Indexing
                                                                                                            • ☰ 9.6. Choosing the Right Container Type
                                                                                                            • ☰ 10. Importing and Exporting Data
                                                                                                              • ☰ 10.1. Reading Text and CSV Files
                                                                                                                • ☰ 10.2. Importing Excel Spreadsheets
                                                                                                                  • ☰ 10.3. Importing Data with the Import Tool
                                                                                                                    • ☰ 10.4. Exporting Data to Files
                                                                                                                      • ☰ 10.5. Working with Image and Audio Files
                                                                                                                        • ☰ 10.6. Basic File Management from MATLAB
                                                                                                                        • ☰ 11. Plotting and Visualization
                                                                                                                          • ☰ 11.1. Introduction to 2D Plotting
                                                                                                                            • ☰ 11.2. Customizing Plots and Axes
                                                                                                                              • ☰ 11.3. Multiple Plots in One Figure
                                                                                                                                • ☰ 11.4. Labels, Titles, Legends, and Annotations
                                                                                                                                  • ☰ 11.5. Plotting with Different Line and Marker Styles
                                                                                                                                    • ☰ 11.6. Saving and Exporting Figures
                                                                                                                                    • ☰ 12. Advanced Plotting for Beginners
                                                                                                                                      • ☰ 12.1. Subplots and Tiled Layouts
                                                                                                                                        • ☰ 12.2. Bar, Scatter, and Stem Plots
                                                                                                                                          • ☰ 12.3. Histograms and Density Plots
                                                                                                                                            • ☰ 12.4. 3D Plots and Surface Plots
                                                                                                                                              • ☰ 12.5. Using plottools and Interactive Editing
                                                                                                                                                • ☰ 12.6. Basics of Handle Graphics
                                                                                                                                                • ☰ 13. Working with Scripts and Live Scripts
                                                                                                                                                  • ☰ 13.1. Creating and Running Script Files
                                                                                                                                                    • ☰ 13.2. Sectioning Code and Running Sections
                                                                                                                                                      • ☰ 13.3. Live Scripts and Rich Text
                                                                                                                                                        • ☰ 13.4. Adding Equations, Images, and Outputs
                                                                                                                                                          • ☰ 13.5. Sharing and Exporting Live Scripts
                                                                                                                                                          • ☰ 14. Debugging and Code Quality
                                                                                                                                                            • ☰ 14.1. Finding and Fixing Syntax Errors
                                                                                                                                                              • ☰ 14.2. Setting Breakpoints and Stepping Through Code
                                                                                                                                                                • ☰ 14.3. Inspecting Variable Values During Execution
                                                                                                                                                                  • ☰ 14.4. Using the Editor Debugging Tools
                                                                                                                                                                    • ☰ 14.5. Using Code Analyzer and Warnings
                                                                                                                                                                      • ☰ 14.6. Writing Clean and Maintainable MATLAB Code
                                                                                                                                                                      • ☰ 15. Basic Linear Algebra with MATLAB
                                                                                                                                                                        • ☰ 15.1. Vectors and Norms
                                                                                                                                                                          • ☰ 15.2. Matrix Addition and Multiplication
                                                                                                                                                                            • ☰ 15.3. Solving Linear Systems with Backslash
                                                                                                                                                                              • ☰ 15.4. Inverses, Determinants, and Rank
                                                                                                                                                                                • ☰ 15.5. Eigenvalues and Eigenvectors
                                                                                                                                                                                  • ☰ 15.6. Using Linear Algebra Functions Safely
                                                                                                                                                                                  • ☰ 16. Data Analysis and Statistics Fundamentals
                                                                                                                                                                                    • ☰ 16.1. Descriptive Statistics and Summary Measures
                                                                                                                                                                                      • ☰ 16.2. Sorting, Filtering, and Grouping Data
                                                                                                                                                                                        • ☰ 16.3. Basic Correlation and Regression
                                                                                                                                                                                          • ☰ 16.4. Simple Data Cleaning Techniques
                                                                                                                                                                                            • ☰ 16.5. Basic Time Series Handling
                                                                                                                                                                                            • ☰ 17. Working with Time and Dates
                                                                                                                                                                                              • ☰ 17.1. Representing Dates and Times
                                                                                                                                                                                                • ☰ 17.2. Creating and Formatting datetime Arrays
                                                                                                                                                                                                  • ☰ 17.3. Date Calculations and Differences
                                                                                                                                                                                                    • ☰ 17.4. Plotting Data over Time
                                                                                                                                                                                                    • ☰ 18. Introduction to Signal and Image Handling
                                                                                                                                                                                                      • ☰ 18.1. Basic Signal Representation in MATLAB
                                                                                                                                                                                                        • ☰ 18.2. Simple Filtering and Transformations
                                                                                                                                                                                                          • ☰ 18.3. Reading, Displaying, and Writing Images
                                                                                                                                                                                                            • ☰ 18.4. Basic Image Transformations
                                                                                                                                                                                                            • ☰ 19. Automation and Scripting Tasks
                                                                                                                                                                                                              • ☰ 19.1. Batch Processing of Files
                                                                                                                                                                                                                • ☰ 19.2. Writing Reusable Utility Scripts
                                                                                                                                                                                                                  • ☰ 19.3. Using Relative Paths and the MATLAB Path
                                                                                                                                                                                                                    • ☰ 19.4. Simple User Interaction with input and disp
                                                                                                                                                                                                                    • ☰ 20. Introduction to Toolboxes
                                                                                                                                                                                                                      • ☰ 20.1. What Are Toolboxes and How to Use Them
                                                                                                                                                                                                                        • ☰ 20.2. Exploring Installed Toolboxes
                                                                                                                                                                                                                          • ☰ 20.3. Finding Functions in Toolboxes
                                                                                                                                                                                                                            • ☰ 20.4. Add-Ons and MATLAB File Exchange
                                                                                                                                                                                                                            • ☰ 21. Best Practices and Next Steps
                                                                                                                                                                                                                              • ☰ 21.1. Organizing Projects and Folders
                                                                                                                                                                                                                                • ☰ 21.2. Version Control Basics with MATLAB
                                                                                                                                                                                                                                  • ☰ 21.3. Performance Tips for Beginners
                                                                                                                                                                                                                                    • ☰ 21.4. Learning Resources and Documentation Path
                                                                                                                                                                                                                                      • ☰ 21.5. Suggested Practice Projects for Beginners