単回帰分析の原理原則

# はじめに
[フューチャー Advent Calendar 2019（2）](https://qiita.com/advent-calendar/2019/future2)の19日目です。
18日目は、noko_qiiさんの[「SageMakerとpapermillでサクッと始めるJupyterNotebookベースな機械学習案件向け開発環境構築・利用ガイドライン」](https://qiita.com/noko_qii/items/2dc27525023fe55cf7bd)でした。
Advent Calendarって、社内の人が様々なトピックで記事を投稿していて面白いですね。

無事に新人研修が終わり、需要予測のチームに配属されました。
今日は、最近学んだことの中から、回帰分析の１つである単回帰分析についてまとめました。

# 回帰分析って何？

回帰分析とは、結果となる数値と要因となる数値の関係を数式(回帰式)で表す統計的手法です。
具体例を交えながら説明します。
例えば、あるクラスのAさん〜Dさんの「勉強時間」と「テストの点数」のデータがあります。
回帰分析は、「勉強時間」と「テストの点数」の関係を数式で表現します。

![単回帰のトレーニングデータ表.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/322279/edbb01a1-da2e-28e3-77ed-8029295c2835.png)

このデータを視覚化すると、下のようなグラフになります。
横軸が勉強時間、縦軸がテストの点数を表しています。
勉強時間が長くなるほど、テストの点数が上がっている傾向がわかります。

![無題のスプレッドシート_-_Google_スプレッドシート.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/322279/16f84eb7-a3c5-8b20-b16f-a4857fbc80e4.png)

4人のデータを用いて、「勉強時間」と「テストの点数」の関係を数式で表します。
「勉強時間」と「テストの点数」の関係が線形であると仮定して、データに当てはまる直線を下記のように引きます。

![点数と勉強時間の関係（回帰式なし）.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/322279/547772e8-eced-27fa-94e6-b52e0270faea.png)

黒の直線は下の式(回帰式)で表せます。

```math
y = 5.7x + 51 
```

この式（回帰式）の意味は、

```math

(点数)= 5.7 × (学習時間) + 51
```

となります。
学習時間が0のとき、51点となり、１時間勉強するごとに5.7点ずつ点数が上がっていることを意味しています。
この式（回帰式）を利用することで、勉強時間から、他の生徒がどの程度の点数を獲得できるかが予測できるようになります。
例えば、勉強時間が6時間のEさんの点数は、

```math
\begin{align}
(Eさんの点数) &= 5.7× (学習時間) + 51 \\
&= 5.7 × 6 + 51 \\
&= 85(点)
\end{align}
```

と求めることができます。

![無題のスプレッドシート_-_Google_スプレッドシート-2.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/322279/eea5632a-4a3d-f1e7-285d-608bf1a70d81.png)

このように、回帰分析は、結果となる数値と要因となる数値の関係を回帰式で表します。
また、要因となる数値を**説明変数**、結果となる数値を**目的変数**といいます。
今回の例でいうと、「勉強時間」から「点数」を予測したので、「勉強時間」が**説明変数**で、「点数」が**目的変数**となります。

回帰分析のうち、1つの目的変数を1つの説明変数で予測するものを**単回帰分析**と言います。
そして、1つの目的変数を２つ以上の説明変数で予測するものを**重回帰分析**と言います。

単回帰分析

```math
y = a + b_1x_1 \\
```

重回帰分析

```math
y = a + b_1x_1 + b_2x_2 + ・・・ + b_nx_n \\
y:目的変数 \\
a:切片 \\
b:回帰係数 \\
x:説明変数 
```


重回帰分析では、天気や気温、宣伝費用や暦などの説明変数と、商品の売上数という目的変数の関係を回帰式として表現します。
では、どのようにしてインプットしたデータから、回帰式を算出しているのか。

まずは単回帰分析について、Pythonで実装していきたいと思います。
また、**仕組みの理解を目的とする**ため、scikit-learnやStatsModelsのような機械学習のライブラリを利用しないで実装します。

# 単回帰分析

単回帰分析は、1つの目的変数を1つの説明変数で予測する分析手法でした。
また、目的変数と説明変数は**線形の関係がある**という仮定があります。
つまり、目的変数と説明変数は、下記の回帰式で表現できるという仮定があります。

```math
\begin{align}
y &= w_1x + w_0 \\
(目的変数) &= w_1×(説明変数) + w_0
\end{align}
```

先ほどの例では、

```math

(点数)= 5.7 × (学習時間) + 51
```

でした。

![無題のプレゼンテーション.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/322279/ef5c50f5-b675-0503-dc69-32cd1d149f3f.png)

どのようなアルゴリズムで、5.7という傾きや、51という切片を算出したのか。
勉強時間と点数のデータ(49人分)の学習データを使いながら実装していきます。

まずは、必要なライブラリのimportと、学習データを読み込みます。


<details><summary>今回使用する学習データはこちらをクリック</summary><div>
`TestScores_StudyHours_Liner.csv`

https://drive.google.com/open?id=1z80g4kKGMMBbnCaAz_iUAYTLkEvz4cZI

| Hours | Scores |
|--:|--:|
| 5.2 | 78 |
| 4.2 | 77 |
| 7.6 | 95 |
| 2.7 | 66 |
| 9.1 | 91 |
| 1.3 | 59 |
| 3.6 | 72 |
| 9.4 | 100 |
| 6.8 | 88 |
| 8.5 | 89 |
| 8.4 | 98 |
| 2.6 | 71 |
| 2.8 | 66 |
| 4 | 73 |
| 6.9 | 88 |
| 5.2 | 83 |
| 7.9 | 96 |
| 4.6 | 76 |
| 5.4 | 85 |
| 5.4 | 79 |
| 5.2 | 83 |
| 4.4 | 80 |
| 2.2 | 68 |
| 2.1 | 64 |
| 3.4 | 69 |
| 1.2 | 57 |
| 0.2 | 58 |
| 2 | 63 |
| 4.7 | 77 |
| 4.5 | 78 |
| 5.5 | 84 |
| 8.3 | 97 |
| 4.3 | 75 |
| 0.9 | 62 |
| 5.8 | 82 |
| 8.2 | 100 |
| 6.1 | 87 |
| 3.3 | 73 |
| 6.3 | 88 |
| 6.6 | 89 |
| 4.5 | 78 |
| 3.8 | 74 |
| 3.8 | 73 |
| 4.7 | 80 |
| 1.5 | 60 |
| 5 | 81 |
| 9.1 | 91 |
| 4.3 | 74 |
| 1.3 | 58 |

</div></details>

ちなみに、この記事で書いてあるコードは`Google colaboratory`で実装しています。
`Google colaboratory`は、googleアカウントがあれば、誰でもクラウド上でPythonを実行できるサービスです。説明は要らないから、コードを見たいって人は、下記画像からcolaboratoryに飛べるので、見てください。

[<img width = 90 src = "https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/322279/5917d698-e4dc-29ce-7faf-a3b84a91c5a4.png">](https://colab.research.google.com/drive/1IQoYyC9Qxjand3LZ56ymaX8rYwZhQezr)



```python

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

data= np.loadtxt("./TestScores_StudyHours_Liner.csv",delimiter=",",skiprows=1)
```


どのようなデータが入っているのか、プロットして確認します。

```python
plt.plot(data[:,0],data[:,1],'rx',markersize=10,label='Training')
plt.xlabel('Study Hours')
plt.ylabel('Test Score')
plt.grid(True)
plt.show()
```


![IMG_8188.jpg](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/322279/91e17361-2ee7-fa1f-3089-cb13abe76065.jpeg)


横軸が勉強時間、縦軸がテストの点数を表していて、49人分のデータがプロットされています。
これらのデータを入力して、直線の傾き(w<sub>1</sub>)や切片(w<sub>0</sub>)を算出していきます。

```math
y = w_1x + w_0
```

直線の傾き(w<sub>1</sub>)や切片(w<sub>0</sub>)を算出するのに、**コスト関数(平均二乗誤差)**と**最急降下法**を用います。

# コスト関数(平均二乗誤差)
コスト関数(平均二乗誤差)は、**ある回帰式が学習データとどれだけフィットしているかを定量的に評価します。**
もう少し具体的にいうと、コスト関数は**モデルが算出した予測値と学習データの実際値の差(残差)**を計算します。

例えば、(w<sub>0</sub>,w<sub>1</sub>) = (0,0)　のときの、回帰式は下記のようになります。

```math
\begin{align}
y &= w_1x + w_0 \\
y &= 0 
\end{align}
```

このときの、回帰式と学習データの関係を視覚化すると、下のグラフになります。

```python
w0,w1 = 0,0
plt.plot(data[:,0],data[:,1],'rx',markersize=10,label='Training')
plt.xlabel('Study Hours')
plt.ylabel('Test Scores')

plt.plot(data[:,0],data[:,0]*w1 + w0,'-',label='Linear regression')
plt.legend()
plt.show()
```

![y=0.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/322279/7a92298f-c4b2-a433-9d18-5cafa97582e3.png)

青い線が、(w<sub>0</sub>,w<sub>1</sub>) = (0,0)　のときの回帰式、赤×が学習データです。

<details><summary>【補足】係数と直線の関係</summary><div>
補足ですが、(w<sub>0</sub>,w<sub>1</sub>)=(0,0)(0,1)(2,-2)のときの直線は下のようになります。


```math
y = w_1x + w_0 \\
```
![無題のプレゼンテーション (1).png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/322279/cf4a4fec-d5a9-c71b-3d7b-c12ddd579d18.png)
</div></details>

コスト関数は、残差{(予測した値)-(実際の値)}を、それぞれのデータで計算し、全ての残差の和を計算します。

![y_0.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/322279/2b372b60-c5ba-1ebd-72b1-f850a49033d1.png)

(w<sub>0</sub>,w<sub>1</sub>) = (0,10)のときは、こちらが残差になります。
![0_10-2.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/322279/7f13040e-2613-c272-4f01-b9af21c8088a.png)


コスト関数は、平均二乗誤差を計算します。
学習データそれぞれの残差の二乗を計算し、その総和を、2×テータ数で割った値がコストとなります。
式で表現すると、

```math
\begin{align}
J(w_0,w_1) &= \frac{1}{2m}\sum_{i=1}^{m}(\hat{y}-y)^2 \\
 &= \frac{1}{2m}\sum_{i=1}^{m}(w_1x + w_0-y)^2
\end{align}
```

```math
\begin{align}
m &: データ数 (m=49) \\
\hat{y} &: 予測値 (\hat{y}=w_1x + w_0) \\
y &: 実測値
\end{align}
```

![下書き一覧_-_Qiita.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/322279/5bd6fe5f-00ef-fb8c-2130-0fb2a87e746a.png)

では、(w<sub>0</sub>,w<sub>1</sub>) = (0,0)　のときのコストを計算して見ます。
まずは、コスト関数を定義します。

```python
# コスト関数
def cost_function(w0,w1,data):
    cost = 0
    m = len(data)
    for i in range(m):
        x = data[i,0]
        y = data[i,1]
        cost += ((w1 * x +w0) -y)**2
    cost = cost / (2*m)
    return cost
```

(w<sub>0</sub>,w<sub>1</sub>) = (0,0)　のときのコストは、

```python
w0,w1 = 0,0
cost_0_0 =cost_function(w0,w1,data)
print(cost_0_0)
#3128.3979591836733
```

3128と求めることができました。

w<sub>0</sub>,w<sub>1</sub> = 0,10のときのコストも求めます。

```python
w0,w1 = 0,10
cost_0_10 =cost_function(w0,w1,data)
print(cost_0_10)
#538.9285714285714
```
コストは、538と求められました。

![cost.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/322279/8f1833ec-f03f-bbc2-f215-36df21410c10.png)

左の画像と右の画像の直線を見比べると、右のw<sub>0</sub>,w<sub>1</sub> = 0,10のときの回帰式のほうが学習データに近いことが、視覚的にわかります。
また、コスト関数を比べても、左のコストが3128に対して、右のコストが538と、コストが大幅に減少していることがわかります。
このように、回帰式が学習データとフィットしているかは、コスト関数を用いることで、定量的に評価できます。
**単回帰分析においてのモデルの学習とは、コストが最小となる回帰係数を算出することです。**

そして、コストが最小となる回帰係数を算出するのに、ポイントとなるのが、**最急降下法**です。

#最急降下法
**最急降下法**は、**関数を最小にするようなパラメーターを求めるためのアルゴリズム**です。
今回は**コスト関数から得られるコストを最小にするような回帰係数（w<sub>0</sub>,w<sub>1</sub>)を求めたい**です。

コスト関数は下記の式でした。

```math
\begin{align}
J(w_0,w_1) &= \frac{1}{2m}\sum_{i=1}^{m}(\hat{y}-y)^2 \\
 &= \frac{1}{2m}\sum_{i=1}^{m}(w_1x + w_0-y)^2
\end{align}
```
```math
\begin{align}
m &: データ数  \\
\hat{y} &: 予測値 (\hat{y}=w_1x + w_0) \\
y &: 実測値
\end{align}
```
コスト関数をw<sub>0</sub>で偏微分すると、

```math
\begin{align}
\frac{\partial }{\partial w_0}J(w_0,w_1) &= \frac{\partial }{\partial w_0}\frac{1}{2m}\sum_{i=1}^{m}(w_1x + w_0-y)^2 \\
&= \frac{1}{m}(w_1x + w_0-y)
\end{align}
```

コスト関数をw<sub>1</sub>で偏微分すると、

```math
\begin{align}
\frac{\partial }{\partial w_1}J(w_0,w_1) &= \frac{\partial }{\partial w_1}\frac{1}{2m}\sum_{i=1}^{m}(w_1x + w_0-y)^2 \\
&= \frac{1}{m}(w_1x + w_0-y)x
\end{align}
```

と求めることができます。
偏微分をすると、コスト関数の傾きがわかります。
コストが小さくなるように、w<sub>0</sub>,w<sub>1</sub>を更新したいので、元々の回帰係数から偏微分で得られた値を引きます。

```math
\begin{align}
w_0 &:= w_0 - \alpha\frac{1}{m}(w_1x + w_0-y) \\
w_1 &:= w_1 - \alpha\frac{1}{m}(w_1x + w_0-y)x
\end{align}
```

```math
\begin{align}
\alpha &:学習率 \\
m &:データ数 \\
x &:説明変数 \\
y &:目的変数 \\
\end{align}
```

**&alpha;は学習率**と呼ばれ、回帰係数を更新する値の大きさを調整します。
学習率は、大きすぎると回帰係数が収束しない可能性があり、また、小さすぎると、回帰係数の収束に時間がかかってしまいます。
今回は学習率=0.01でと決めて、進めていきます。

では、最急降下法を実装していきます。

```python
# 最急降下法(Gradient Descent)
def gradientDescent(w0_in,w1_in,data,alpha):
    w0_gradient,w1_gradient = 0,0  #初期値
    m = float(len(data))           #データ数
    for i in range(len(data)):
        x,y = data[i,0], data[i,1]
        w0_gradient += (1/m) * (((w1_in * x) + w0_in) -y)
        w1_gradient += (1/m) * ((((w1_in * x) + w0_in) -y) * x)
    w0_out = w0_in - (alpha * w0_gradient) #回帰係数の更新
    w1_out = w1_in - (alpha * w1_gradient) #回帰係数の更新
    return [w0_out, w1_out]
```

`w0_gradient`、`w1_gradient`は、初期値0を設定しています。
また、&alpha;、w<sub>0</sub>、w<sub>1</sub>、学習回数の初期値を設定します。

```python
alpha = 0.01
init_w0,init_w1 = 0,0
iterations = 1000 #学習回数
```

それではコスト関数と最急降下法を用いて、単回帰分析のモデルの学習を定義していきます。
今回は、1000回の回帰係数の更新する中で、コストがどのように推移するかを可視化するために、`J_history`を追加します。

```python
def run(data,init_w0,init_w1,alpha,iterations):
    w0,w1 = init_w0,init_w1
    J_history = [] #コストの履歴を格納用
    for i in range(iterations):
        w0,w1 = gradientDescent(w0,w1,np.array(data),alpha)
        J_history.append(cost_function(w0,w1,data)) #コストの履歴をJ_historyに追加
    return [w0,w1, J_history]
```

それでは、モデルの学習（コストが最小となる回帰係数の算出）をします。

```python
[w0,w1, J_history] = run(data,init_w0,init_w1,alpha,iterations)
print("w0 = {} /w1 = {}".format(w0,w1))
#w0 = 47.325313552065204 /w1 = 6.135761014127023
```

回帰係数を求めることができました。

```math
\begin{align}
y &= w_1x + w_0 \\
  &= 6.13x + 47.3 \\
\end{align}
```

この式とつまり、

```math
(テストの点数)= 6.13×(勉強時間) + 47.3 
```

ということを意味しています。
また、回帰式と学習データを視覚化すると、

```python
plt.plot(data[:,0],data[:,1],'rx',markersize=10,label='Training')
plt.xlabel('Study Hours')
plt.ylabel('Test Scores')

plt.plot(data[:,0],data[:,0]*w1 + w0,'-',label='Linear regression')
plt.legend()
plt.show()
```

![liner regression.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/322279/53decf1a-f138-2cec-3b1b-6b01eda5b8f0.png)

このように、学習データにフィットした直線を描くことができました。

また、コストの推移も確認してみましょう。

```python
# コストと学習回数のグラフ
plt.plot(range(len(J_history)),J_history,"-b",linewidth=1)
plt.xlabel("Number of Iterations")
plt.ylabel("Cost J")
plt.grid(True)
plt.show()
```

![コスト関数の推移.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/322279/63e17d44-17e4-8f88-7b71-f17087da21cc.png)

縦軸がコストで、横軸が学習回数を表しています。
**学習を繰り返すごとに、コストが下がっているのがわかります。**

学習回数を1000回と決めてしまいましたが、学習回数が1回、10回、100回、1000回のときに算出される回帰式を比較してみました。

```python
iterations_ = [1,10,100,1000]

plt.plot(data[:,0],data[:,1],'rx',markersize=10,label='Training')
plt.xlabel('Study Hours')
plt.ylabel('Test Scores')

for iteration in iterations_:
    [w0,w1, J_history]  = run(data,init_w0,init_w1,alpha,iteration)
    plt.plot(data[:,0],data[:,0]*w1 + w0,'-',label='Linear regression_{}'.format(iteration))
    
plt.legend()
plt.show()
```
![iteration1to1000.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/322279/728155d7-a861-ab20-bb91-ee387e0197f4.png)

学習を繰り返すごとに、回帰式が学習データを捉えられるようになっていることがわかります。

#まとめ
**単回帰分析は、目的変数と説明変数が線形の回帰式で表現できるという仮説がある。**

```math
y = w_1x + w_0 
```

**ある回帰係数（w<sub>0</sub>、w<sub>1</sub>）のときの回帰式が、学習データにどれだけフィットしているかはコスト関数を用いて評価する。**
**最急降下法を用いて、コストが小さくなるような回帰係数を算出する。**

#あとがき
今日は単回帰分析についてのまとめを書きました。
本当は重回帰分析について書きたかったのですが、単回帰分析だけで結構長くなってしまったので、別記事にします。
最後まで読んでいただきありがとうございました。