機械学習とは何か（ついでにsin(θ)を人工知能で計算）

from math import pi, radians, sqrt
from numpy import absolute, frompyfunc, sin
import matplotlib.pyplot as plt
from statistics import mean, stdev

def _sin1(θ):
    # 角度θを0.0～359.999...の範囲に直す
    while True:
        if θ < 0.0:
            θ += 2.0 * pi
            continue
        if 2.0 * pi <= θ:
            θ -= 2.0 * pi
            continue
        break

    # 180度を超える場合、x軸に関して対称とする
    if pi < θ:
        return -1 * _sin1(2.0 * pi - θ)

    # 90〜180度の場合、y軸に関して対称とする
    if 0.5 * pi < θ:
        return _sin1(pi - θ)

    # 結果の初期化
    ans_sin = 0.0

    # 角度に応じて分岐する
    if θ == 0:
        ans_sin =  0.0
    elif θ == 0.5 * pi:
        ans_sin =  1.0
    else:
        θ1, θ2 = 0.0, 0.5 * pi
        x1, y1 = 1.0, 0.0
        x2, y2 = 0.0, 1.0
        delta = 0.0000000000000001
        loopnumber = 0
#        l = []
#        s = []

        # 無限ループ
        while True:
            # ループ回数
            loopnumber += 1
#            l.append(loopnumber)

            # 角度、座標の中間値を計算
            θm, xm, ym = (θ1 + θ2) / 2.0, (x1 + x2) / 2.0, (y1 + y2) / 2.0

            # 原点(0,0)と(xm,ym)を結ぶ線の単位ベクトル(new_x, new_y)を計算
            d = sqrt(xm ** 2 + ym ** 2)
            new_x, new_y = xm / d, ym / d
#            s.append(new_y)

            # 角度の差がdelta未満で終了
            if absolute(θm - θ) < delta:
                ans_sin = new_y

                '''
                # 収束状況を表示
                print("ループ回数：" + str(loopnumber))
                plt.plot(l, s, marker='.')
                plt.grid()
                plt.xlabel('ループ回数')
                plt.ylabel('sin(θ)')
                plt.show()
                '''
                break

            # 角度を狭める
            if (θ > θm):
                x1, y1, θ1 = new_x, new_y, θm
            else:
                x2, y2, θ2 = new_x, new_y, θm

    return ans_sin

def sin1(θ):
    return frompyfunc(_sin1, 1, 1)(θ)


deg = 30.0
rad = radians(deg)
x = sin1(rad)
y = sin(rad)
print("独自関数によるsin(" + str(deg) + ")：" + str(x))
print("組込関数によるsin(" + str(deg) + ")：" + str(y))

deg = 45.0
rad = radians(deg)
x = sin1(rad)
y = sin(rad)
print("独自関数によるsin(" + str(deg) + ")：" + str(x))
print("組込関数によるsin(" + str(deg) + ")：" + str(y))

deg = 60.0
rad = radians(deg)
x = sin1(rad)
y = sin(rad)
print("独自関数によるsin(" + str(deg) + ")：" + str(x))
print("組込関数によるsin(" + str(deg) + ")：" + str(y))

rads = [radians(i) for i in range(0, 359)]
h = sin1(rads)
y = sin(rads)
e = absolute(y - h)
print("誤差最大値  ：" + str(max(e)))
print("誤差最小値  ：" + str(min(e)))
print("誤差平均値  ：" + str(mean(e)))
print("誤差標準偏差：" + str(stdev(e)))

独自関数によるsin(30.0)：0.5000000000000004
組込関数によるsin(30.0)：0.49999999999999994
独自関数によるsin(45.0)：0.7071067811865475
組込関数によるsin(45.0)：0.7071067811865475
独自関数によるsin(60.0)：0.8660254037844387
組込関数によるsin(60.0)：0.8660254037844386
誤差最大値  ：5.551115123125783e-16
誤差最小値  ：0.0
誤差平均値  ：1.386164670430837e-16
誤差標準偏差：1.1688186600394947e-16

from math import factorial, pi
from numpy import arange, sin
import matplotlib.pyplot as plt

θ  = arange(0, 2.0 * pi, 0.1)
θ1 =  θ
θ3 = -θ**3 / factorial(3)
θ5 =  θ**5 / factorial(5)
θ7 = -θ**7 / factorial(7)
θ9 =  θ**9 / factorial(9)
θall = θ1 + θ3 + θ5 + θ7 + θ9
sinθ = sin(θ)

plt.figure()
plt.plot(θ, θ1, label='θ1', linestyle='--', alpha=0.5)
plt.plot(θ, θ3, label='θ3', linestyle='--', alpha=0.5)
plt.plot(θ, θ5, label='θ5', linestyle='--', alpha=0.5)
plt.plot(θ, θ7, label='θ7', linestyle='--', alpha=0.5)
plt.plot(θ, θ9, label='θ9', linestyle='--', alpha=0.5)
plt.plot(θ, θall, label='θ1+...+θ9')
plt.plot(θ, sinθ, label='sinθ')
plt.legend()
plt.ylim([-1.1, 1.1])
plt.grid()
plt.xlabel('θ')
plt.ylabel('f(θ)')
plt.show()

from math import factorial, pi, radians
from numpy import absolute, frompyfunc, sin
from statistics import mean, stdev

def _sin2(θ):
    # 角度θを0.0～359.999...の範囲に直す
    while True:
        if θ < 0.0:
            θ += 2.0 * pi
            continue
        if 2.0 * pi <= θ:
            θ -= 2.0 * pi
            continue
        break

    # 180度を超える場合、x軸に関して対称とする
    if pi < θ:
        return -1 * _sin2(2.0 * pi - θ)

    # 90〜180度の場合、y軸に関して対称とする
    if 0.5 * pi < θ:
        return _sin2(pi - θ)

    return sum([(-1)**(i-1) * θ**(2*i-1) / factorial(2*i-1) for i in range(1, 12)])

def sin2(θ):
    return frompyfunc(_sin2, 1, 1)(θ)


deg = 30.0
rad = radians(deg)
x = sin2(rad)
y = sin(rad)
print("独自関数によるsin(" + str(deg) + ")：" + str(x))
print("組込関数によるsin(" + str(deg) + ")：" + str(y))

deg = 45.0
rad = radians(deg)
x = sin2(rad)
y = sin(rad)
print("独自関数によるsin(" + str(deg) + ")：" + str(x))
print("組込関数によるsin(" + str(deg) + ")：" + str(y))

deg = 60.0
rad = radians(deg)
x = sin2(rad)
y = sin(rad)
print("独自関数によるsin(" + str(deg) + ")：" + str(x))
print("組込関数によるsin(" + str(deg) + ")：" + str(y))

rads = [radians(i) for i in range(359)]
h = sin2(rads)
y = sin(rads)
e = absolute(y - h)
print("誤差最大値  ：" + str(max(e)))
print("誤差最小値  ：" + str(min(e)))
print("誤差平均値  ：" + str(mean(e)))
print("誤差標準偏差：" + str(stdev(e)))

独自関数によるsin(30.0)：0.49999999999999994
組込関数によるsin(30.0)：0.49999999999999994
独自関数によるsin(45.0)：0.7071067811865475
組込関数によるsin(45.0)：0.7071067811865475
独自関数によるsin(60.0)：0.8660254037844385
組込関数によるsin(60.0)：0.8660254037844386
誤差最大値  ：3.3306690738754696e-16
誤差最小値  ：0.0
誤差平均値  ：1.1695900013687744e-16
誤差標準偏差：9.066751491381523e-17

from math import radians

deg = 30.0
rad = radians(deg)
%timeit x = sin1(rad)
%timeit x = sin2(rad)

64.1 µs ± 502 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
9.16 µs ± 62.9 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

from os import mkdir
from os.path import exists
from sys import exc_info
from math import pi, radians
from numpy import absolute, array, arange, frompyfunc, sin
from pandas import DataFrame
from sklearn.externals.joblib import dump, load
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt
from statistics import mean, stdev

class MregSin:
    # モデル
    modeldir = './data'
    modelfile = './data/MregSin.pkl'

    # データに関するパラメータ
    number_of_train_data = 300
    start_of_train_data = 0.0 * pi
    stop_of_train_data = 0.5 * pi

    # モデルに関するパラメータ
    number_of_features = 11

    # 訓練に関するパラメータ
    #   特になし

    def __init__(self, recycle=True):
        if recycle and exists(MregSin.modelfile):
            try:
                print('訓練済みモデルを読み込みます。')
                self.__model = load(MregSin.modelfile)
            except:
                print('訓練済みモデルの読み込み中にエラーが発生しました。')
                print('Unexpected error:', exc_info()[0])
                raise
        else:
            print('訓練を行うので、お待ちください。')

            # データ
            feature_names = [str(i) for i in
                             range(1, MregSin.number_of_features + 1, 1)]
            x = arange(MregSin.start_of_train_data, MregSin.stop_of_train_data,
                         (MregSin.stop_of_train_data - MregSin.start_of_train_data)
                         / MregSin.number_of_train_data)
            data = [[i**j for j in
                     range(1, MregSin.number_of_features + 1, 1)] for i in x]
            target = sin(x)

            # モデル
            self.__model = LinearRegression()

            # 訓練
            self.__model.fit(data, target)

            # 訓練状況の可視化
            print('回帰係数')
            coefficient = DataFrame({'feature' : feature_names
                                     , 'coefficient' : self.__model.coef_})
            print(coefficient)
            print('切片')
            print(self.__model.intercept_)

            # 予測
            x2 = [x[i] for i in
                  range(0, len(x), round(0.02 * MregSin.number_of_train_data))]
            data2 = [[i**j for j in
                      range(1, MregSin.number_of_features + 1, 1)] for i in x2]
            target2 = [target[i] for i in
                       range(0, len(target), round(0.02 * MregSin.number_of_train_data))]
            predicted = self.__model.predict(data2)
            plt.figure()
            plt.plot(x2, target2, marker='.', label='組込関数')
            plt.plot(x2, predicted, marker='.', label='独自関数')
            plt.legend(loc='best', fontsize=10)
            plt.grid()
            plt.xlabel('θ')
            plt.ylabel('sin(θ)')
            plt.show()

            # モデルの保存
            if not exists(MregSin.modeldir):
                try:
                    mkdir(MregSin.modeldir)
                except:
                    print('モデル保存フォルダの作成中にエラーが発生しました。')
                    print('Unexpected error:', exc_info()[0])
                    raise
            try:
                dump(self.__model, MregSin.modelfile)
            except:
                print('モデルの保存中にエラーが発生しました。')
                print('Unexpected error:', exc_info()[0])
                raise

    def __sin(self, θ):
        # 角度θを0.0～359.999...の範囲に直す
        while True:
            if θ < 0.0:
                θ += 2.0 * pi
                continue
            if 2.0 * pi <= θ:
                θ -= 2.0 * pi
                continue
            break

        # 180度を超える場合、x軸に関して対称とする
        if pi < θ:
            return -1 * self.sin(2.0 * pi - θ)

        # 90〜180度の場合、y軸に関して対称とする
        if 0.5 * pi < θ:
            return self.sin(pi - θ)

        data = [[θ**i for i in range(1, MregSin.number_of_features + 1, 1)]]
        return self.__model.predict(data)[0]

    def sin(self, θ):
        return frompyfunc(self.__sin, 1, 1)(θ)


ds = MregSin(recycle=False)

deg = 30.0
rad = radians(deg)
x = ds.sin(rad)
y = sin(rad)
print("独自関数によるsin(" + str(deg) + ")：" + str(x))
print("組込関数によるsin(" + str(deg) + ")：" + str(y))

deg = 45.0
rad = radians(deg)
x = ds.sin(rad)
y = sin(rad)
print("独自関数によるsin(" + str(deg) + ")：" + str(x))
print("組込関数によるsin(" + str(deg) + ")：" + str(y))

ds = MregSin()

deg = 60.0
rad = radians(deg)
x = ds.sin(rad)
y = sin(rad)
print("独自関数によるsin(" + str(deg) + ")：" + str(x))
print("組込関数によるsin(" + str(deg) + ")：" + str(y))

rads = [radians(i) for i in range(359)]
h = ds.sin(rads)
y = sin(rads)
e = absolute(y - h)
print("誤差最大値  ：" + str(max(e)))
print("誤差最小値  ：" + str(min(e)))
print("誤差平均値  ：" + str(mean(e)))
print("誤差標準偏差：" + str(stdev(e)))

訓練を行うので、お待ちください。
回帰係数
   feature   coefficient
0        1  1.000000e+00
1        2 -2.602449e-10
2        3 -1.666667e-01
3        4 -1.611588e-08
4        5  8.333389e-03
5        6 -1.227027e-07
6        7 -1.982343e-04
7        8 -1.720502e-07
8        9  2.863353e-06
9       10 -4.069894e-08
10      11 -1.754363e-08
切片
-8.915090887740007e-14

独自関数によるsin(30.0)：0.5000000000000134
組込関数によるsin(30.0)：0.49999999999999994
独自関数によるsin(45.0)：0.7071067811865207
組込関数によるsin(45.0)：0.7071067811865475
訓練済みモデルを読み込みます。
独自関数によるsin(60.0)：0.8660254037844507
組込関数によるsin(60.0)：0.8660254037844386
誤差最大値  ：1.6620038678638593e-13
誤差最小値  ：2.55351295663786e-15
誤差平均値  ：2.1351626923889052e-14
誤差標準偏差：1.5984259514679425e-14

from os import mkdir
from os.path import exists
from sys import exc_info
from math import pi, radians
from numpy import absolute, arange, array, frompyfunc, sin 
from keras.models import load_model, Sequential
from keras.layers import Dense, Dropout
from keras.callbacks import EarlyStopping
import matplotlib.pyplot as plt
from statistics import mean, stdev

class DeepSin:
    # モデル
    modeldir = './data'
    modelfile = './data/DeepSin.h5'

    # データに関するパラメータ
    number_of_train_data = 300000
    start_of_train_data = 0.0 * pi
    stop_of_train_data = 0.5 * pi
    number_of_test_data = 0.3 * number_of_train_data
    start_of_test_data = 0.0
    stop_of_test_data = 0.5 * pi

    # モデルに関するパラメータ
    number_of_layer = 10
    units = 30

    # 訓練に関するパラメータ
#    min_delta = 0
#    patience = 0
    batch_size = round(0.01 * number_of_train_data)
    epochs = 20

    def __init__(self, recycle=True):
        if recycle and exists(DeepSin.modelfile):
            try:
                print('訓練済みモデルを読み込みます。')
                self.__model = load_model(DeepSin.modelfile)
            except:
                print('訓練済みモデルの読み込み中にエラーが発生しました。')
                print('Unexpected error:', exc_info()[0])
                raise
        else:
            print('訓練を行うので、お待ちください。')
#            print('学習が頭打ちになった場合、途中で訓練を打ち切ります。')

            # データ
            trX = arange(DeepSin.start_of_train_data, DeepSin.stop_of_train_data,
                         (DeepSin.stop_of_train_data - DeepSin.start_of_train_data)
                         / DeepSin.number_of_train_data)
            trY = sin(trX)
            valX = arange(DeepSin.start_of_test_data, DeepSin.stop_of_test_data,
                         (DeepSin.stop_of_test_data - DeepSin.start_of_test_data)
                          / DeepSin.number_of_test_data)
            valY = sin(valX)

            # モデル
            self.__model = Sequential()
            self.__model.add(Dense(1, input_dim=1, activation='linear'))
            for i in (range(DeepSin.number_of_layer)):
                self.__model.add(Dense(DeepSin.units, activation='relu'))
            self.__model.add(Dense(1))
            self.__model.compile(loss='mean_squared_error', optimizer='Adam')

            # 訓練
#            early_stopping = EarlyStopping(monitor='val_loss'
#                                           , min_delta=DeepSin.min_delta
#                                           , patience=DeepSin.patience
#                                           , mode='auto'
#                                          )
            hist = self.__model.fit(trX, trY,
                                    batch_size=DeepSin.batch_size
                                    , epochs=DeepSin.epochs
#                                    , callbacks=[early_stopping]
                                    , validation_data=(valX, valY)
                                   )

            # 訓練状況の可視化
            loss = hist.history['loss']
            val_loss = hist.history['val_loss']
            plt.figure()
            plt.plot(range(1, len(loss) + 1),
                     loss, marker='.', label='訓練データ')
            plt.plot(range(1, len(val_loss) + 1),
                     val_loss, marker='.', label='テストデータ')
            plt.legend(loc='best', fontsize=10)
            plt.grid()
            plt.xlabel('エポック')
            plt.ylabel('損失')
            plt.show()

            # 予測
            trX2 = array([trX[i] for i in
                          range(0, len(trX), round(0.02 * DeepSin.number_of_train_data))])
            trY2 = array([trY[i] for i in
                          range(0, len(trY), round(0.02 * DeepSin.number_of_train_data))])
            predicted = self.__model.predict(trX2)
            plt.figure()
            plt.plot(trX2, trY2, marker='.', label='組込関数')
            plt.plot(trX2, predicted, marker='.', label='独自関数')
            plt.legend(loc='best', fontsize=10)
            plt.grid()
            plt.xlabel('θ')
            plt.ylabel('sin(θ)')
            plt.show()

            # モデルの保存
            if not exists(DeepSin.modeldir):
                try:
                    mkdir(DeepSin.modeldir)
                except:
                    print('モデル保存フォルダの作成中にエラーが発生しました。')
                    print('Unexpected error:', exc_info()[0])
                    raise
            try:
                self.__model.save(DeepSin.modelfile)
            except:
                print('モデルの保存中にエラーが発生しました。')
                print('Unexpected error:', exc_info()[0])
                raise

    def __sin(self, θ):
        # 角度θを0.0～359.999...の範囲に直す
        while True:
            if θ < 0.0:
                θ += 2.0 * pi
                continue
            if 2.0 * pi <= θ:
                θ -= 2.0 * pi
                continue
            break

        # 180度を超える場合、x軸に関して対称とする
        if pi < θ:
            return -1 * self.sin(2.0 * pi - θ)

        # 90〜180度の場合、y軸に関して対称とする
        if 0.5 * pi < θ:
            return self.sin(pi - θ)
        return self.__model.predict([θ])[0][0]

    def sin(self, θ):
        return frompyfunc(self.__sin, 1, 1)(θ)


ds = DeepSin(recycle=False)

deg = 30.0
rad = radians(deg)
x = ds.sin(rad)
y = sin(rad)
print("独自関数によるsin(" + str(deg) + ")：" + str(x))
print("組込関数によるsin(" + str(deg) + ")：" + str(y))

deg = 45.0
rad = radians(deg)
x = ds.sin(rad)
y = sin(rad)
print("独自関数によるsin(" + str(deg) + ")：" + str(x))
print("組込関数によるsin(" + str(deg) + ")：" + str(y))

ds = DeepSin()

deg = 60.0
rad = radians(deg)
x = ds.sin(rad)
y = sin(rad)
print("独自関数によるsin(" + str(deg) + ")：" + str(x))
print("組込関数によるsin(" + str(deg) + ")：" + str(y))

rads = [radians(i) for i in range(359)]
h = ds.sin(rads)
y = sin(rads)
e = absolute(y - h)
print("誤差最大値  ：" + str(max(e)))
print("誤差最小値  ：" + str(min(e)))
print("誤差平均値  ：" + str(mean(e)))
print("誤差標準偏差：" + str(stdev(e)))

Using TensorFlow backend.


訓練を行うので、お待ちください。
Train on 300000 samples, validate on 90000 samples
Epoch 1/20
300000/300000 [==============================] - 2s 5us/step - loss: 0.0697 - val_loss: 0.0012
Epoch 2/20
300000/300000 [==============================] - 1s 3us/step - loss: 5.5763e-04 - val_loss: 2.6283e-04
Epoch 3/20
300000/300000 [==============================] - 1s 3us/step - loss: 1.3936e-04 - val_loss: 5.4291e-05
Epoch 4/20
300000/300000 [==============================] - 1s 3us/step - loss: 2.5608e-05 - val_loss: 9.9707e-06
Epoch 5/20
300000/300000 [==============================] - 1s 3us/step - loss: 5.6591e-06 - val_loss: 4.3353e-06
Epoch 6/20
300000/300000 [==============================] - 1s 3us/step - loss: 2.4574e-06 - val_loss: 1.3504e-06
Epoch 7/20
300000/300000 [==============================] - 1s 3us/step - loss: 1.4784e-06 - val_loss: 9.6404e-07
Epoch 8/20
300000/300000 [==============================] - 1s 3us/step - loss: 1.1821e-06 - val_loss: 5.3071e-07
Epoch 9/20
300000/300000 [==============================] - 1s 3us/step - loss: 1.1959e-06 - val_loss: 2.5098e-06
Epoch 10/20
300000/300000 [==============================] - 1s 3us/step - loss: 1.2143e-06 - val_loss: 4.1867e-07
Epoch 11/20
300000/300000 [==============================] - 1s 3us/step - loss: 1.6130e-06 - val_loss: 2.5240e-07
Epoch 12/20
300000/300000 [==============================] - 1s 3us/step - loss: 7.9917e-07 - val_loss: 5.5269e-07
Epoch 13/20
300000/300000 [==============================] - 1s 3us/step - loss: 1.9296e-06 - val_loss: 4.3476e-07
Epoch 14/20
300000/300000 [==============================] - 1s 3us/step - loss: 1.2812e-06 - val_loss: 2.6409e-07
Epoch 15/20
300000/300000 [==============================] - 1s 3us/step - loss: 1.2712e-06 - val_loss: 1.9644e-07
Epoch 16/20
300000/300000 [==============================] - 1s 3us/step - loss: 2.0916e-06 - val_loss: 3.1340e-07
Epoch 17/20
300000/300000 [==============================] - 1s 3us/step - loss: 1.1972e-06 - val_loss: 8.7616e-07
Epoch 18/20
300000/300000 [==============================] - 1s 3us/step - loss: 2.6864e-06 - val_loss: 1.4640e-05
Epoch 19/20
300000/300000 [==============================] - 1s 3us/step - loss: 4.0446e-06 - val_loss: 1.4378e-05
Epoch 20/20
300000/300000 [==============================] - 1s 3us/step - loss: 1.1424e-06 - val_loss: 1.0116e-07

独自関数によるsin(30.0)：0.500035
組込関数によるsin(30.0)：0.49999999999999994
独自関数によるsin(45.0)：0.70708025
組込関数によるsin(45.0)：0.7071067811865475
訓練済みモデルを読み込みます。
独自関数によるsin(60.0)：0.86587673
組込関数によるsin(60.0)：0.8660254037844386
誤差最大値  ：0.00250852108001709
誤差最小値  ：3.4490914585516563e-06
誤差平均値  ：0.0001902273061400219
誤差標準偏差：0.0002800383029470891