最小二乗法の基礎を丁寧に

## 最小二乗法？
最小二乗法は、複雑なデータをなにがしかの関数の組み合わせで近似する手法です。
[これならわかる応用数学教室](http://www.amazon.co.jp/%E3%81%93%E3%82%8C%E3%81%AA%E3%82%89%E5%88%86%E3%81%8B%E3%82%8B%E5%BF%9C%E7%94%A8%E6%95%B0%E5%AD%A6%E6%95%99%E5%AE%A4%E2%80%95%E6%9C%80%E5%B0%8F%E4%BA%8C%E4%B9%97%E6%B3%95%E3%81%8B%E3%82%89%E3%82%A6%E3%82%A7%E3%83%BC%E3%83%96%E3%83%AC%E3%83%83%E3%83%88%E3%81%BE%E3%81%A7-%E9%87%91%E8%B0%B7-%E5%81%A5%E4%B8%80/dp/4320017382)を参考にしながら、

大変シンプルに、

数値(x, y)、具体的には

**(4, -17)**
**(15, -4)**
**(30, -7)**
**(50, 25)**

のいくつかのデータを直線

```math
f(x) = ax + b
```

で近似することを目標にします。
図にするとこんな感じです

![SnapCrab_NoName_2016-2-28_13-55-35_No-00.png](https://qiita-image-store.s3.amazonaws.com/0/8588/f2ee31e2-b352-eede-00ca-3d1d3a594e34.png)


大変シンプルですが、シグマ、偏微分、連立方程式、行列などの要素が登場します。
計算器と数学のコラボレーションとしてもとても面白いです。
なるべく平易に、カジュアルにまとめてみます。

## プログラミング環境
環境は、openframeworksを使います。
カジュアルなビジュアライズが可能ですし、win, osxどちらでも可能です。

## 基本戦略
根幹にある考えは、誤差を最小にするというものです。

では誤差はどう考えたらいいでしょうか？
それぞれのxについて、そのときのyの値と、近似関数による答えyの距離の二乗を求めて足し合わせるなんてどうでしょうか？
例えば以下のように

```C++
	std::vector<ofVec2f> plots = {
		{ 4, -17 },
		{ 15, -4 },
		{ 30, -7 },
		{ 50, 25 },
	};
	float error = 0.0f;
	float a = 0.8f;
	float b = -21.0f;
	for (int i = 0; i < plots.size(); ++i) {
		float x = plots[i].x;
		float y = plots[i].y;

		float truthValue = y;
		float maybe = a * x + b;

		error += std::pow(truthValue - maybe, 2.0f);
	}
	printf("%f", error);

```

とすると誤差が計算できます。
式として表現してみましょう。

```math
J = \sum_{i=1}^{N} (y_i - (ax_i + b))^2
```

どうやらこのJを最小化すればよさそうです。

また、
後々の計算で楽になるために、２分の１しておくと良いと本の中で触れられています。
半分にしたところで最小化になんら影響はありません。

```math
J = \frac{1}{2} \sum_{i=1}^{N} (y_i - (ax_i + b))^2
```

## 最小化する
極大極小の考え方でいうと、
a, bそれぞれに対して、微分して0になるところが最小点になります。
それぞれ行うので偏微分です。
偏微分は、一つの変数に着目していったんほかの変数を定数と扱って微分する手法です。

まずはaについての偏微分です。
シグマが入っていますが、これは気にせずそのまま微分できます。
おっと、べき乗があります。これは好都合、微分の展開が楽です。さきほど誤差を、距離の二乗の和としたからですね。
合成関数の微分を行いましょう。
合成関数の片方は、

```math
f(x) = x^2\\
f'(x) = 2x
```

もう片方は

```math
g(a) = y_i - ax_i - b\\
g'(a) = -x_i
```

となるので、

```math
\frac{\partial J}{\partial a} = \frac{1}{2} \sum_{i=1}^{N} 2(y_i - ax_i - b)(-x_i)\\
= \sum_{i=1}^{N} (y_i - ax_i - b)(-x_i)\\
= \sum_{i=1}^{N} (ax_i^2 + bx_i - x_iy_i)\\
= \sum_{i=1}^{N} ax_i^2 + \sum_{i=1}^{N}bx_i - \sum_{i=1}^{N}x_iy_i\\
= a\sum_{i=1}^{N} x_i^2 + b\sum_{i=1}^{N}x_i - \sum_{i=1}^{N}x_iy_i\\
```

とここまで持ってこれます。ここで2分の1があるおかげですっきりしました。
yも同様の流れでやれば、

```math
\frac{\partial J}{\partial b} = \frac{1}{2} \sum_{i=1}^{N} 2(y_i - ax_i - b)(-1)\\
= \sum_{i=1}^{N} (y_i - ax_i - b)(-1)\\
= \sum_{i=1}^{N} (ax_i + b - y_i)\\
= \sum_{i=1}^{N} ax_i + \sum_{i=1}^{N}b - \sum_{i=1}^{N}y_i\\
= a\sum_{i=1}^{N} x_i + b\sum_{i=1}^{N}1 - \sum_{i=1}^{N}y_i\\
```

ともってこれます。
これら２つが０になるので、連立方程式ができます。

```math

\begin{eqnarray}
  {}
  a\sum_{i=1}^{N} x_i^2 + b\sum_{i=1}^{N}x_i = \sum_{i=1}^{N}x_iy_i & \\
  a\sum_{i=1}^{N} x_i + b\sum_{i=1}^{N}1 = \sum_{i=1}^{N}y_i &
\end{eqnarray}
```

# 連立方程式を解く
ここでは行列でまず表現します。

```math
\left(
    \begin{array}{cc}
      \sum_{i=1}^{N} x_i^2 & \sum_{i=1}^{N}x_i\\
      \sum_{i=1}^{N} x_i & \sum_{i=1}^{N}1 
    \end{array}
\right)
\left(
    \begin{array}{c}
      a \\
      b 
    \end{array}
\right)
=
\left(
    \begin{array}{c}
      \sum_{i=1}^{N}x_iy_i \\
      \sum_{i=1}^{N}y_i
    \end{array}
\right)
```

a, bを求めたいわけですから、あとは逆行列を求めればすぐです。

```math
\left(
    \begin{array}{c}
      a \\
      b 
    \end{array}
\right)
=
\left(
    \begin{array}{cc}
      \sum_{i=1}^{N} x_i^2 & \sum_{i=1}^{N}x_i\\
      \sum_{i=1}^{N} x_i & \sum_{i=1}^{N}1 
    \end{array}
\right)^{-1}
\left(
    \begin{array}{c}
      \sum_{i=1}^{N}x_iy_i \\
      \sum_{i=1}^{N}y_i
    \end{array}
\right)
```

ここまできたらプログラムまで落とし込んでしまいましょう。
行列演算はなんでもいいのですが、今回は自分が好きな[glm](http://glm.g-truc.net/0.9.7/index.html)を使います。（ofに2x2行列クラスが無いのはあまり褒められたものではないですね・・・まあ2x2の逆行列くらいは大したことないのですが）

素直に行列に要素を突っ込んで、素直に解を求めます。（解がないのは今回は考慮していません）

```C++

#pragma once

#include "ofMain.h"

class ofApp : public ofBaseApp {
public:
	void setup();
	void update();
	void draw();

	void keyPressed(int key);
	void keyReleased(int key);
	void mouseMoved(int x, int y);
	void mouseDragged(int x, int y, int button);
	void mousePressed(int x, int y, int button);
	void mouseReleased(int x, int y, int button);
	void mouseEntered(int x, int y);
	void mouseExited(int x, int y);
	void windowResized(int w, int h);
	void dragEvent(ofDragInfo dragInfo);
	void gotMessage(ofMessage msg);

	ofEasyCam _camera;
	std::vector<ofVec2f> _plots;
};

```

```C++
#include "ofApp.h"

#include <glm/glm.hpp>

//--------------------------------------------------------------
void ofApp::setup(){
	_plots.emplace_back(4, -17);
	_plots.emplace_back(15, -4);
	_plots.emplace_back(30, -7);
	_plots.emplace_back(50, 25);

	_camera.setDistance(100);
}

//--------------------------------------------------------------
void ofApp::draw(){
	// 最小二乗法
	float m0 = 0.0f;
	float m1 = 0.0f;
	float m2 = 0.0f;
	float m3 = 0.0f;

	float v0 = 0.0f;
	float v1 = 0.0f;
	
	for (int i = 0; i < _plots.size(); ++i) {
		ofVec2f p = _plots[i];
		float x = p.x;
		float y = p.y;

		m0 += x * x;
		m1 += x;
		m2 += x;
		m3 += 1.0f;

		v0 += x * y;
		v1 += y;
	}
	glm::mat2 m(glm::vec2(m0, m1), glm::vec2(m2, m3));
	glm::vec2 v(v0, v1);

	glm::vec2 ab = glm::inverse(m) * v; /* 連立方程式を解く */

	ofSetColor(255);
	ofClear(0);

	_camera.begin();
	ofPushMatrix();
	ofRotateY(90);
	ofDrawGridPlane(10, 10, true);
	ofPopMatrix();

	ofDrawAxis(100);

	ofSetColor(255, 255, 0);
	for (auto p : _plots) {
		ofDrawSphere(p, 1.0f);
	}
	
	ofSetColor(255, 0, 255);
	ofVec2f p0(-100.0f, ab.x * -100.0f + ab.y);
	ofVec2f p1( 100.0f, ab.x *  100.0f + ab.y);
	ofDrawLine(p0, p1);

	_camera.end();
}

```

おめでとうございます！
実行すると見事に近似直線が描画されます。

![SnapCrab_NoName_2016-2-28_14-56-24_No-00.png](https://qiita-image-store.s3.amazonaws.com/0/8588/aa16cf7f-63dc-9184-fce4-772e21955d7b.png)

## まとめ
最小二乗法は数学と計算機との密接なコラボレーションによって、大変大きな力になってくれるテクニックです。
今回は本当に基礎の基礎でしたが、とても実りのある技術です。
もしまだあまり着手したことがないなら、
ぜひ自分の手で触れてみてはいかがでしょうか。きっと新しい発見があるはずです。