## What will we cover?

In this lesson we will learn about **Linear Regression, **difference from **Correlation** and how to visualize **Linear Regression**.

The objective of this tutorial is.

- Understand the difference between
**Linear Regression**and**Correlation**. - Understand the difference between
**true random**and**correlated**variables **Visualize linear regression.**

## Step 1: Similarities and differences between linear regression and correlation

Let’s first see what the similarities and difference between Linear Regression and Correlation is.

**Similarities**.

- Quantify the direction and strength of the relationship between two variables, here we look at stock prices.

**Differences**.

- Correlation is a single statistic. It is just a number between -1 and 1 (both inclusive).
- Linear regression produces an equation.

## Step 2: Visualize data with no correlation

A great way to learn about relationships between variables is to compare it to random variables.

Let’s start by doing that.

```
import pandas as pd
import numpy as np
from sklearn.linear_model import LinearRegression
import pandas_datareader as pdr
import datetime as dt
import matplotlib.pyplot as plt
%matplotlib notebook
X = np.random.randn(5000)
Y = np.random.randn(5000)
fig, ax = plt.subplots()
ax.scatter(X, Y, alpha=.2)
```

Giving the following scatter chart.

Which shows the how two non-correlated variables look like.

## Step 3: How to visualize correlated stock prices

To compare that to two correlated, we need some data.

```
tickers = ['AAPL', 'TWTR', 'IBM', 'MSFT', '^GSPC']
start = dt.datetime(2020, 1, 1)
data = pdr.get_data_yahoo(tickers, start)
data = data['Adj Close']
log_returns = np.log(data/data.shift())
```

Let’s make a function to calculate the Liner Regression and visualize it.

```
def linear_regression(ticker_a, ticker_b):
X = log_returns[ticker_a].iloc[1:].to_numpy().reshape(-1, 1)
Y = log_returns[ticker_b].iloc[1:].to_numpy().reshape(-1, 1)
lin_regr = LinearRegression()
lin_regr.fit(X, Y)
Y_pred = lin_regr.predict(X)
alpha = lin_regr.intercept_[0]
beta = lin_regr.coef_[0, 0]
fig, ax = plt.subplots()
ax.set_title("Alpha: " + str(round(alpha, 5)) + ", Beta: " + str(round(beta, 3)))
ax.scatter(X, Y)
ax.plot(X, Y_pred, c='r')
```

The function takes the two tickers and get’s the log returns in **NumPy** arrays. They are reshaped to fit the required format.

The the Linear Regression model (**LinearRegression**) is used and applied to predict values. The alpha and beta are the liner variables. Finally, we scatter plot all the points and a prediction line.

Let’s try** linear_regression(“AAPL”, “^GSPC”)**.

Where we see the red line as the prediction line.

## Step 4: A few more examples

Other examples **linear_regression(“AAPL”, “MSFT”)**

And **linear_regression(“AAPL”, “TWTR”)**.

Where it visually shows that **AAPL** and **TWTR** are not as closely correlated as the other examples.

## Want to learn more?

This is part of a 2.5-hour full video course in 8 parts about Risk and Return.

In the next lesson you will learn how to Calculate the market (S&P 500) BETA with Python for any Stock.

**12% Investment** Solution

Would you like to get 12% in return of your investments?

D. A. Carter promises and shows how his simple investment strategy will deliver that in the book **The 12% Solution**. The book shows how to test this statement by using backtesting.

**Did Carter find a strategy that will consistently beat the market?**

Actually, it is not that hard to use Python to validate his calculations. But we can do better than that. If you want to work smarter than traditional investors then continue to read here.

## Python Circle

Do you know what the 5 key success factors every programmer must have?

How is it possible that some people become programmer so fast?

While others struggle for years and still fail.

Not only do they learn python 10 times faster they solve complex problems with ease.

What separates them from the rest?

I identified these 5 success factors that every programmer must have to succeed:

**Collaboration**: sharing your work with others and receiving help with any questions or challenges you may have.**Networking**: the ability to connect with the right people and leverage their knowledge, experience, and resources.**Support**: receive feedback on your work and ask questions without feeling intimidated or judged.**Accountability**: stay motivated and accountable to your learning goals by surrounding yourself with others who are also committed to learning Python.**Feedback from the instructor**: receiving feedback and support from an instructor with years of experience in the field.

I know how important these success factors are for growth and progress in mastering Python.

That is why I want to make them available to anyone struggling to learn or who just wants to improve faster.

With the **Python Circle community**, you can take advantage of 5 key success factors every programmer must have.

Be part of something bigger and join the Python Circle community.