由于高等數學底子太差的原因，機器學習無法深入學習下去，只能做一個簡單的嘗試者，甚至連調優也未必能算的上，不過這樣也好，可以把重心放到對業務的理解上，以及業務和模型的選擇上。

線性模型包括了傳統的線性回歸、嶺回歸、Lasso回歸，主要用于連續值的預測；邏輯回歸雖然也是回歸，但卻是一種分類方法；LDA線性判別分析，則是一種降維方法；多項式回歸，是使用線性模型訓練數據的非線性函數。

總的來說，嘗試著回顧一下，也挺有意思的。

import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets,linear_model,discriminant_analysis,model_selection,preprocessing
from sklearn.pipeline import make_pipeline,Pipeline

def load_data():
    diabetes=datasets.load_diabetes()
    # datasets.load_diabetes()定義
    # C:\Python\Python37\Lib\site-packages\sklearn\datasets\_base.py
    #     return Bunch(data=data, target=target, DESCR=fdescr,
    #                  feature_names=['age', 'sex', 'bmi', 'bp',
    #                                 's1', 's2', 's3', 's4', 's5', 's6'],
    #                  data_filename=data_filename,
    #                  target_filename=target_filename)
    # print(diabetes)
    # 得到一個字典
    # print(diabetes.keys())
    #dict_keys(['data', 'target', 'DESCR', 'feature_names', 'data_filename', 'target_filename'])
    # print(diabetes['data'].shape)
    # (442, 10)
    # print(diabetes['target'])
    # print(diabetes['target'].shape)
    # (442, )
    # print(diabetes['feature_names'])
    # ['age', 'sex', 'bmi', 'bp', 's1', 's2', 's3', 's4', 's5', 's6']
    # print(diabetes['data_filename'])
    # C:\Python\Python37\lib\site-packages\sklearn\datasets\data\diabetes_data.csv.gz
    # 壓縮包中有個X.csv文件，數據格式如下
    # 3.81E-02 5.07E-02   6.17E-02   2.19E-02   -4.42E-02  -3.48E-02  -4.34E-02  -2.59E-03  1.99E-02   -1.76E-02
    # -1.88E-03    -4.46E-02  -5.15E-02  -2.63E-02  -8.45E-03  -1.92E-02  7.44E-02   -3.95E-02  -6.83E-02  -9.22E-02
    # 8.53E-02 5.07E-02   4.45E-02   -5.67E-03  -4.56E-02  -3.42E-02  -3.24E-02  -2.59E-03  2.86E-03   -2.59E-02
    # print(diabetes['target_filename'])
    # C:\Python\Python37\lib\site-packages\sklearn\datasets\data\diabetes_target.csv.gz
    # 壓縮包中有個y.csv文件，數據格式如下
    # 1.51E+02
    # 7.50E+01
    # 1.41E+02
return model_selection.train_test_split(diabetes.data,diabetes.target,
                                              test_size=0.25,random_state=)
# 線性回歸
def test_LinearRegression(*data):
    X_train, X_test, y_train, y_test = data
    # 線性回歸模型-最小二乘法線性回歸：
    # sklearn.linear_model.LinearRegression(fit_intercept=True, normalize=False,copy_X=True, n_jobs=1)
    # 主要參數說明：
    # fit_intercept：表示是否計算截距,布爾型，默認為True，
    #   若參數值為True時，代表訓練模型需要加一個截距項；
    #   若參數為False時，代表模型無需加截距項。
    # normalize：布爾型，默認為False，若fit_intercept參數設置False時，normalize參數無需設置；
    #   若normalize設置為True時，則輸入的樣本數據將( X - X均值) / | | X | |；
    #   若設置normalize = False時，在訓練模型前， 可以使用sklearn.preprocessing.StandardScaler進行標準化處理。
    # copy_X,如果為True，則復制X
    # n_jobs，并行任務時指定的CPU數量
    # 屬性：
    # coef_：回歸系數(斜率)
    # intercept_：截距項
    # 主要方法：
    # fit(X, y, sample_weight=None) 訓練模型
    # predict(X)    用模型進行預測
    # score(X, y, sample_weight=None)，返回預測得分
    #   其結果等于1 - (((y_true - y_pred) ** 2).sum() / ((y_true - y_true.mean()) ** 2).sum())
    #   score在-1范圍內，越大預測性能越好
    regr=linear_model.LinearRegression()
    regr.fit(X_train,y_train)

    coef=regr.coef_
    intercept=regr.intercept_
    trainscore=regr.score(X_train,y_train)
    testscore=regr.score(X_test,y_test)
    trainpredict=regr.predict(X_train)
    testpredict=regr.predict(X_test)
    meansquareerror=np.mean((regr.predict(X_test)-y_test)**2)
    equalscore=np.mean(regr.predict(X_test)==y_test)

    #print('Coefficients={},intercept={}'.format(coef,intercept))
    ## Coefficients=[ -43.26774487 -208.67053951  593.39797213  302.89814903 -560.27689824   261.47657106   -8.83343952  135.93715156  703.22658427   28.34844354]
    ## intercept=153.06798218266258
    #print('Residual sum of squares={}'.format(meansquareerror))
    ## Residual sum of squares=3180.1988368427274
    #print('trainscore={}'.format(trainscore))
    ## trainscore=0.555437148935302
    #print('testscore={}'.format(testscore))
    ## testscore=0.35940090989715534
    #print('equalscore={:.2f}'.format(equalscore))
    ## standardscore=0.00
    #print('trainpredict={}'.format(trainpredict))
    #print('testpredict={}'.format(testpredict))
# 嶺回歸
def test_Ridge_Regression(*data):
    # lasso回歸也是一種正則化的線性回歸，且也是約束系數使其接近于，
    # 不過其用到的方法不同，嶺回歸用到的是L2正則化，
    # 而lasso回歸用到的是L1正則化（L1是通過稀疏參數（減少參數的數量）來降低復雜度，即L1正則化使參數為零，L2是通過減小參數值的大小來降低復雜度，
    # Parameters
    #        alpha:正則化系數，較大的值指定更強的正則化。
    #        fit_intercept:是否計算模型的截距，默認為True，計算截距
    #        normalize:在需要計算截距時，如果值為True，則變量x在進行回歸之前先進行歸一化（）,如果需要進行標準化則normalize=False。若不計算截距，則忽略此參數。
    #        copy_X:默認為True，將復制X；否則，X可能在計算中被覆蓋。
    #        max_iter:共軛梯度求解器的最大迭代次數。對于sparse_cg和lsqr,默認值由scipy.sparse.linalg確定。對于sag求解器，默認值為1000.
    #        tol:float類型，指定計算精度。
    #        solver：求解器{auto,svd,cholesky,lsqr,sparse_cg,sag,saga}
    #                aotu:根據數據類型自動選擇求解器
    #                svd:使用X的奇異值分解計算嶺系數。奇異矩陣比cholesky更穩定
    #                cholesky:使用標準的scipy.linalg.solve函數獲得收斂的系數
    #                sparsr_cg:使用scipy.sparse.linalg.cg中的共軛梯度求解器。作為一種迭代算法，這個求解器比cholesky更適合大規模數據（設置tol和max_iter的可能性）
    #                lsqr:使用專用的正則化最小二乘方法scipy.sparse.linalg.lsqr。
    #                sag:使用隨機平均梯度下降，saga使用其改進的，無偏見的版本，兩種方法都使用迭代過程。
    #        random_state:隨機數生成器的種子。
    # Attributes
    #        coef_:返回模型的估計系數。
    #        intercept_:線性模型的獨立項，一維情形下的截距。
    #        n_iter:實際迭代次數。
    # Methods
    #        fit(X,y):使用數據訓練模型
    #        get_params([deep=True]):返回函數LinearRegression()內部的參數值
    #        predict(X):使用模型做預測
    #        score(X，y):返回模型的擬合優度判定系數
    #        為回歸平方和與總離差平方和的比值，介于-1之間，越接近1模型的擬合效果越顯著。
    X_train, X_test, y_train, y_test = data
    regr = linear_model.Ridge()
    regr.fit(X_train,y_train)
    coef = regr.coef_
    intercept = regr.intercept_
    trainscore = regr.score(X_train, y_train)
    testscore = regr.score(X_test, y_test)
    trainpredict = regr.predict(X_train)
    testpredict = regr.predict(X_test)
    meansquareerror = np.mean((regr.predict(X_test) - y_test) ** 2)
    equalscore = np.mean(regr.predict(X_test) == y_test)
    # print('Coefficients={},intercept={}'.format(coef,intercept))
    # # Coefficients=[  21.19927911  -60.47711393  302.87575204  179.41206395    8.90911449  -28.8080548  -149.30722541  112.67185758  250.53760873   99.57749017],intercept=152.4477761489962
    # # intercept=3192.3285539937624
    # print('Residual sum of squares={}'.format(meansquareerror))
    # # Residual sum of squares=3192.3285539937624
    # print('trainscore={}'.format(trainscore))
    # # trainscore=0.4625439622495925
    # print('testscore={}'.format(testscore))
    # # testscore=0.35695757658096805
    # print('equalscore={:.2f}'.format(equalscore))
    # # standardscore=0.00
    # print('trainpredict={}'.format(trainpredict))
    # print('testpredict={}'.format(testpredict))
def test_Ridge_alpha(*data):
    X_train, X_test, y_train, y_test = data
    alphas=[0.01,0.02,0.05,0.1,0.2,0.5,1,2,5,10,20,50,100,200,500,1000]
    scores=[]
for i,alpha in enumerate(alphas):
        regr=linear_model.Ridge(alpha=alpha)
        regr.fit(X_train,y_train)
        scores.append(regr.score(X_test,y_test))

    fig=plt.figure()
    ax=fig.add_subplot(1,1,1)
    ax.plot(alphas,scores)
    ax.set_xlabel(r'$\alpha$')
    ax.set_ylabel(r'score')
    ax.set_xscale('log')
    ax.set_title('Ridge')
plt.show()

# Lasso回歸
def test_Lasso_Regression(*data):
    # 嶺回歸是一種專用于共線性數據分析的有偏估計回歸方法，實質上是一種改良的最小二乘估計法，
    # 通過放棄最小二乘法的無偏性，以損失部分信息、降低精度為代價獲得回歸系數更為符合實際、更可靠的回歸方法，對病態數據的擬合要強于最小二乘法。
    # Parameters
    #   alpha : float, 可選，默認 1.0。當 alpha 為  時算法等同于普通最小二乘法
    #   fit_intercept : 是否計算模型的截距，默認為True，計算截距
    #   normalize : boolean, 可選, 默認 False;   若 True，則先 normalize 再 regression。若 fit_intercept 為 false 則忽略此參數。
    #   copy_X : 默認為True，將復制X；否則，X可能在計算中被覆蓋。
    #   precompute : True | False | array-like, 默認=False
    #   max_iter : int, 可選,最大循環次數。
    #   tol : float, 可選，優化容忍度 The tolerance for the optimization: 若更新后小于 tol，優化代碼檢查優化的 dual gap 并繼續直到小于 tol 為止。
    #   warm_start : bool, 可選。為 True 時, 重復使用上一次學習作為初始化，否則直接清除上次方案。
    #   positive : bool, 可選。設為 True 時，強制使系數為正。
    #   selection : str, 默認 ‘cyclic’
    #       若設為 ‘random’, 每次循環會隨機更新參數，而按照默認設置則會依次更新。設為隨機通常會極大地加速交點（convergence）的產生，尤其是 tol 比 1e-4 大的情況下。
    #   random_state : int, RandomState instance, 或者 None (默認值)
    # Attributes
    #        coef_:返回模型的估計系數。
    #        intercept_:線性模型的獨立項，一維情形下的截距。
    #        n_iter:實際迭代次數。
    # Methods
    #        fit(X,y):使用數據訓練模型
    #        get_params([deep=True]):返回函數LinearRegression()內部的參數值
    #        predict(X):使用模型做預測
    #        score(X，y):預測性能得分
    #           為回歸平方和與總離差平方和的比值，介于-1之間，越接近1模型的擬合效果越顯著。
    X_train, X_test, y_train, y_test = data
    regr = linear_model.Lasso()
    regr.fit(X_train, y_train)
    coef = regr.coef_
    intercept = regr.intercept_
    trainscore = regr.score(X_train, y_train)
    testscore = regr.score(X_test, y_test)
    trainpredict = regr.predict(X_train)
    testpredict = regr.predict(X_test)
    meansquareerror = np.mean((regr.predict(X_test) - y_test) ** 2)
    equalscore = np.mean(regr.predict(X_test) == y_test)
    # print('Coefficients={},intercept={}'.format(coef,intercept))
    # # Coefficients=[  0.          -0.         442.67992538   0.           0.   0.          -0.           0.         330.76014648   0.        ]
    # # intercept=152.52260710501807
    # print('Residual sum of squares={}'.format(meansquareerror))
    # # Residual sum of squares=3583.4215227615487
    # print('trainscore={}'.format(trainscore))
    # # trainscore=0.41412544493966097
    # print('testscore={}'.format(testscore))
    # # testscore=0.27817828862078764
    # print('equalscore={:.2f}'.format(equalscore))
    # # standardscore=0.00
    # print('trainpredict={}'.format(trainpredict))
    # print('testpredict={}'.format(testpredict))
def test_Lasso_alpha(*data):
    X_train, X_test, y_train, y_test = data
    alphas = [0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1, 2, 5, 10, 20, 50, 100, 200, 500, 1000]
    scores = []
for i, alpha in enumerate(alphas):
        regr = linear_model.Lasso(alpha=alpha)
        regr.fit(X_train, y_train)
        scores.append(regr.score(X_test, y_test))

    fig = plt.figure()
    ax = fig.add_subplot(1, 1, 1)
    ax.plot(alphas, scores)
    ax.set_xlabel(r'$\alpha$')
    ax.set_ylabel(r'score')
    ax.set_xscale('log')
    ax.set_title('Lasso')
plt.show()

# ElasticNet回歸
def test_ElasticNet_Regression(*data):
    # ElasticNet回歸是對Lasso回歸和Ridge回歸的融合，利用了L1和L2范數的融合，所以在參數中除了alpha之外還有L1_ratio 默認alpha=1，l1_ratio=0.5
    # Parameters
    #   alpha: a值。
    #   fit_intercept:一個布爾值，指定是否需要計算b值。如果為False，那么不計算b值（模型會認為你已經將數據中心化了）。
    #   max_iter:整數值，指定最大迭代次數。
    #   normalize：一個布爾值。如果為True，那么訓練樣本會在回歸之前被歸一化。
    #   copy_X：一個布爾值，如果為True，則會復制X值
    #   precompute：一個布爾值或者一個序列。他決定是否提前計算Gram矩陣來加速計算。
    #   tol：一個浮點數，指定判斷迭代收斂與否的閾值。
    #   warm_start：一個布爾值，如為True，那么使用前一次訓練結果繼續訓練。否則重頭開始訓練。
    #   positive：一個布爾值，如為Ture，那么強制要求全中響亮的分量都為整數。
    #   selection：一個字符串，可以為‘cyclic’（更新時候，從前向后一次選擇權重向量的一個分量來更新）或者‘random'（隨機選擇權重向量的一個分量來更新），他指定了當每輪迭代的時候，選擇權重向量的一個分量來更新
    #   random_state：一個整數或者一個RandomState實例，或者為None。
    # Attributes
    #        coef_:返回模型的估計系數。
    #        intercept_:線性模型的獨立項，一維情形下的截距。
    #        n_iter:實際迭代次數。
    # Methods
    #        fit(X,y):使用數據訓練模型
    #        get_params([deep=True]):返回函數LinearRegression()內部的參數值
    #        predict(X):使用模型做預測
    #        score(X，y):預測性能得分
    #           為回歸平方和與總離差平方和的比值，介于0-1之間，越接近1模型的擬合效果越顯著。
    X_train, X_test, y_train, y_test = data
    regr = linear_model.ElasticNet()
    regr.fit(X_train, y_train)
    coef = regr.coef_
    intercept = regr.intercept_
    trainscore = regr.score(X_train, y_train)
    testscore = regr.score(X_test, y_test)
    trainpredict = regr.predict(X_train)
    testpredict = regr.predict(X_test)
    meansquareerror = np.mean((regr.predict(X_test) - y_test) ** 2)
    equalscore = np.mean(regr.predict(X_test) == y_test)
    # print('Coefficients={},intercept={}'.format(coef,intercept))
    # # Coefficients=[ 0.40560736  0.          3.76542456  2.38531508  0.58677945  0.22891647  -2.15858149  2.33867566  3.49846121  1.98299707],intercept=151.92763641451165
    # # intercept=151.92763641451165
    # print('Residual sum of squares={}'.format(meansquareerror))
    # # Residual sum of squares=4922.355075721768
    # print('trainscore={}'.format(trainscore))
    # # trainscore=0.010304451830727368
    # print('testscore={}'.format(testscore))
    # # testscore=0.008472003027015784
    # print('equalscore={:.2f}'.format(equalscore))
    # # standardscore=0.00
    # print('trainpredict={}'.format(trainpredict))
    # print('testpredict={}'.format(testpredict))
def test_ElasticNet_alpha_rho(*data):
    X_train, X_test, y_train, y_test = data
    alphas = np.logspace(-2,2)  #log分布間距生成list
    rhos=np.linspace(0.01,1)     #取線性，均勻返回五是個值
    scores = []
    for alpha in alphas:
        for rho in rhos:
            regr = linear_model.ElasticNet(alpha=alpha,l1_ratio=rho)
            regr.fit(X_train, y_train)
            scores.append(regr.score(X_test, y_test))

    # 繪圖
    alphas,rhos=np.meshgrid(alphas,rhos)
    scores=np.array(scores).reshape(alphas.shape)
    from mpl_toolkits.mplot3d import Axes3D
    from matplotlib import cm
    fig = plt.figure(figsize=(10,5))
    ax=Axes3D(fig)
    surf=ax.plot_surface(alphas,rhos,scores,rstride=1,cstride=1,cmap=cm.jet,linewidth=0,antialiased=False)
    fig.colorbar(surf,shrink=0.5,aspect=5)
    ax.set_xlabel(r'$\alpha$')
    ax.set_ylabel(r'$\rho$')
    ax.set_zlabel('score')
    ax.set_title('ElasticNet')
plt.show()

# 加載鳶尾花數據
def load_iris_data():
    iris=datasets.load_iris()
    X_train=iris.data
    y_train=iris.target
    return model_selection.train_test_split(X_train,y_train,test_size=0.25,random_state=0,stratify=y_train)

# 邏輯回歸
def test_Logistic_Regression(*data):
    # logistic 回歸，雖然名字里有 “回歸” 二字，但實際上是解決分類問題的一類線性模型。
    # maximum-entropy classification（MaxEnt，最大熵分類），或 log-linear classifier（對數線性分類器）。
    # 該模型利用函數 logistic function 將單次試驗（single trial）的可能結果輸出為概率。
    # scikit-learn 中 logistic 回歸在 LogisticRegression 類中實現了二分類（binary）、一對多分類（one-vs-rest）及多項式 logistic 回歸，并帶有可選的 L1 和 L2 正則化。
    # Parameters
    #   penalty='l2' : 字符串‘l1’或‘l2’,默認‘l2’。
    #       用來指定懲罰的基準（正則化參數）。只有‘l2’支持‘newton-cg’、‘sag’和‘lbfgs’這三種算法。
    #       如果選擇‘l2’，solver參數可以選擇‘liblinear’、‘newton-cg’、‘sag’和‘lbfgs’這四種算法；如果選擇‘l1’的話就只能用‘liblinear’算法。
    #   dual=False : 對偶或者原始方法。Dual只適用于正則化相為l2的‘liblinear’的情況，通常樣本數大于特征數的情況下，默認為False。
    #   C=1.0 : C為正則化系數λ的倒數，必須為正數，默認為1。和SVM中的C一樣，值越小，代表正則化越強。
    #   fit_intercept=True : 是否存在截距，默認存在。
    #   intercept_scaling=1 : 僅在正則化項為‘liblinear’，且fit_intercept設置為True時有用。
    #   solver='liblinear' : solver參數決定了我們對邏輯回歸損失函數的優化方法，有四種算法可以選擇。
    #       a) liblinear：使用了開源的liblinear庫實現，內部使用了坐標軸下降法來迭代優化損失函數。
    #       b) lbfgs：擬牛頓法的一種，利用損失函數二階導數矩陣即海森矩陣來迭代優化損失函數。
    #       c) newton-cg：也是牛頓法家族的一種，利用損失函數二階導數矩陣即海森矩陣來迭代優化損失函數。
    #       d) sag：即隨機平均梯度下降，是梯度下降法的變種，和普通梯度下降法的區別是每次迭代僅僅用一部分的樣本來計算梯度，適合于樣本數據多的時候。
    #   multi_class='ovr' : 分類方式。
    #       ovr即one-vs-rest(OvR)，multinomial是many-vs-many(MvM)。
    #       如果是二元邏輯回歸，ovr和multinomial并沒有任何區別，區別主要在多元邏輯回歸上。
    #       ovr不論是幾元回歸，都當成二元回歸來處理。mvm從從多個類中每次選兩個類進行二元回歸。如果總共有T類，需要T(T-1)/2次分類。
    #       OvR相對簡單，但分類效果相對略差（大多數樣本分布情況）。而MvM分類相對精確，但是分類速度沒有OvR快。
    #       如果選擇了ovr，則4種損失函數的優化方法liblinear，newton-cg,lbfgs和sag都可以選擇。但是如果選擇了multinomial,則只能選擇newton-cg, lbfgs和sag了。
    #   class_weight=None : 類型權重參數。用于標示分類模型中各種類型的權重。默認不輸入，即所有的分類的權重一樣。
    #       選擇‘balanced’自動根據y值計算類型權重。
    #       自己設置權重，格式：{class_label: weight}。例如0,1分類的er'yuan二元模型，設置class_weight={:0.9, 1:0.1}，這樣類型的權重為90%，而類型1的權重為10%。
    #   random_state=None : 隨機數種子，默認為無。僅在正則化優化算法為sag,liblinear時有用。
    #   max_iter=100 : 算法收斂的最大迭代次數。
    #   tol=0.0001 : 迭代終止判據的誤差范圍。
    #   verbose= : 日志冗長度int：冗長度；：不輸出訓練過程；1：偶爾輸出；>1：對每個子模型都輸出
    #   warm_start=False : 是否熱啟動，如果是，則下一次訓練是以追加樹的形式進行（重新使用上一次的調用作為初始化）。布爾型，默認False。
    #   n_jobs=1 : 并行數，int：個數；-1：跟CPU核數一致；1:默認值。
    # Attributes
    #        coef_:返回模型的估計系數。
    #        intercept_:線性模型的獨立項，一維情形下的截距。
    #        n_iter:實際迭代次數。
    # Methods
    #   fit(X, y, sample_weight=None)
    #           擬合模型，用來訓練LR分類器，其中X是訓練樣本，y是對應的標記向量
    #           返回對象，self。
    #   fit_transform(X, y=None, **fit_params)
    #       fit與transform的結合，先fit后transform。返回X_new:numpy矩陣。
    #   predict(X)
    #       用來預測樣本，也就是分類，X是測試集。返回array。
    #   predict_proba(X)
    #       輸出分類概率。返回每種類別的概率，按照分類類別順序給出。如果是多分類問題，multi_class="multinomial"，則會給出樣本對于每種類別的概率。
    #       返回array-like。
    #   score(X, y, sample_weight=None)
    #       返回給定測試集合的平均準確率（mean accuracy），浮點型數值。
    #       對于多個分類返回，則返回每個類別的準確率組成的哈希矩陣。
    X_train, X_test, y_train, y_test = data
    regr = linear_model.LogisticRegression()
    regr.fit(X_train, y_train)
    coef = regr.coef_
    intercept = regr.intercept_
    trainscore = regr.score(X_train, y_train)
    testscore = regr.score(X_test, y_test)
    trainpredict = regr.predict(X_train)
    testpredict = regr.predict(X_test)
    meansquareerror = np.mean((regr.predict(X_test) - y_test) ** 2)
    equalscore = np.mean(regr.predict(X_test) == y_test)
    # print('Coefficients={},intercept={}'.format(coef,intercept))
    # # Coefficients=[[-0.38340846  0.86187824 -2.27003634 -0.9744431 ]
    # #  [ 0.34360292 -0.37876116 -0.03099424 -0.86880637]
    # #  [ 0.03980554 -0.48311708  2.30103059  1.84324947]]
    # # intercept=[  8.75830949   2.49431233 -11.25262182]
    # print('Residual sum of squares={}'.format(meansquareerror))
    # # Residual sum of squares=0.0
    # print('trainscore={:.2f}'.format(trainscore))
    # # trainscore=0.9553571428571429
    # print('testscore={:.2f}'.format(testscore))
    # # testscore=1.0
    # print('equalscore={:.2f}'.format(equalscore))
    # # standardscore=1.00
    # print('trainpredict={}'.format(trainpredict))
    # print('testpredict={}'.format(testpredict))
def test_Logistic_Regression_C(*data):
    X_train, X_test, y_train, y_test = data
    Cs=np.logspace(-2,4,num=100)
    scores = []
for C in Cs:
        regr = linear_model.LogisticRegression(C=C)
        regr.fit(X_train, y_train)
        scores.append(regr.score(X_test, y_test))

    fig = plt.figure()
    ax = fig.add_subplot(1, 1, 1)
    ax.plot(Cs, scores)
    ax.set_xlabel(r'C')
    ax.set_ylabel(r'score')
    ax.set_xscale('log')
    ax.set_title('LogisicRegrssion')
    plt.show()
# 線性判別分析回歸
def test_LDA(*data):
    # ElasticNet回歸是對Lasso回歸和Ridge回歸的融合，利用了L1和L2范數的融合，所以在參數中除了alpha之外還有L1_ratio 默認alpha=1，l1_ratio=0.5
    # Parameters
    #   solver：一個字符串，指定了求解最優化問題的算法，可以為如下的值。
    #       'svd'：奇異值分解。對于有大規模特征的數據，推薦用這種算法。
    #       'lsqr'：最小平方差，可以結合skrinkage參數。
    #       'eigen' ：特征分解算法，可以結合shrinkage參數。
    #   skrinkage：字符串‘auto’或者浮點數活者None。該參數通常在訓練樣本數量小于特征數量的場合下使用。該參數只有在solver=lsqr或者eigen下才有意義
    #       '字符串‘auto’：根據Ledoit-Wolf引理來自動決定shrinkage參數的大小。
    #       'None：不使用shrinkage參數。
    #       浮點數（位于~1之間）：指定shrinkage參數。
    #   priors：一個數組，數組中的元素依次指定了每個類別的先驗概率。如果為None，則認為每個類的先驗概率都是等可能的。
    #   n_components：一個整數。指定了數組降維后的維度（該值必須小于n_classes-1）。
    #   store_covariance：一個布爾值。如果為True，則需要額外計算每個類別的協方差矩陣。
    #   warm_start：一個布爾值。如果為True，那么使用前一次訓練結果繼續訓練，否則從頭開始訓練。
    #   tol：一個浮點數。它指定了用于SVD算法中評判迭代收斂的閾值。
    # ————————————————
    # Attributes
    #       coef_：權重向量。
    #       intercept：b值。
    #       covariance_：一個數組，依次給出了每個類別煩人協方差矩陣。
    #       means_：一個數組，依次給出了每個類別的均值向量。
    #       xbar_：給出了整體樣本的均值向量。
    #       n_iter_：實際迭代次數。
    # Methods
    #       fix(X,y)：訓練模型。
    #       predict(X)：用模型進行預測，返回預測值。
    #       score(X,y[,sample_weight])：返回（X，y）上的預測準確率（accuracy）。
    #       predict_log_proba（X）：返回一個數組，數組的元素一次是 X 預測為各個類別的概率的對數值。 
    #       predict_proba（X）：返回一個數組，數組元素一次是 X 預測為各個類別的概率的概率值。
    X_train, X_test, y_train, y_test = data
    lda = discriminant_analysis.LinearDiscriminantAnalysis()
    lda.fit(X_train, y_train)
    coef = lda.coef_
    intercept = lda.intercept_
    trainscore = lda.score(X_train, y_train)
    testscore = lda.score(X_test, y_test)
    trainpredict = lda.predict(X_train)
    testpredict = lda.predict(X_test)
    meansquareerror = np.mean((lda.predict(X_test) - y_test) ** 2)
    equalscore = np.mean(lda.predict(X_test) == y_test)
    # print('Coefficients={},intercept={}'.format(coef,intercept))
    # # Coefficients=[[  6.66775427   9.63817442 -14.4828516  -20.9501241 ][ -2.00416487  -3.51569814   4.27687513   2.44146469][ -4.54086336  -5.96135848   9.93739814  18.02158943]]
    # # intercept=[-15.46769144   0.60345075 -30.41543234]
    # print('Residual sum of squares={}'.format(meansquareerror))
    # # Residual sum of squares=0.9
    # print('trainscore={}'.format(trainscore))
    # # trainscore=0.9732142857142857
    # print('testscore={}'.format(testscore))
    # # testscore=1.0
    # print('equalscore={:.2f}'.format(equalscore))
    # # equalscore=0.00
    # print('trainpredict={}'.format(trainpredict))
    # print('testpredict={}'.format(testpredict))
def plot_LDA(converted_X,y):
    from mpl_toolkits.mplot3d import Axes3D
    fig=plt.figure(figsize=(10,5))
    ax=Axes3D(fig)
    colors='rgb'
    markers='o*s'
for target,color,marker in zip([,1,2],colors,markers):
        pos=(y==target).ravel()
        X=converted_X[pos,:]
        ax.scatter(X[:,],X[:,1],X[:,2],color=color,marker=marker,label='Label %d'%target)

    ax.legend(loc='best')
    fig.suptitle('Iirs')
    plt.show()

def plot_LDA_diff(*data):
    X_train, X_test, y_train, y_test = data
    X=np.vstack((X_train,X_test))
    Y=np.vstack((y_train.reshape(y_train.size,1),y_test.reshape(y_test.size,1)))
plot_LDA(X,Y)

lda=discriminant_analysis.LinearDiscriminantAnalysis()
    lda.fit(X,Y)
    convertedX=np.dot(X,np.transpose(lda.coef_))+lda.intercept_
plot_LDA(convertedX,Y)


def f(x):
    randa = np.random.uniform(, 0.5, size=x.shape)
    randb = np.random.uniform(, 2, size=x.shape)
    randc = np.random.uniform(, 2, size=x.shape)
return x*x*(randa+1)-x*(randb+2)-randc

def load_ploy_data():
    X=np.linspace(1,100,100)
    y = f(X)
    c = list(zip(X, y))
    np.random.shuffle(c)
    newX,newy=zip(*c)
    size=20
    newX=list(newX)
    newy=list(newy)
    X_train=np.array(newX[:size])
    y_train=np.array(newy[:size])
    X_test=np.array(newX[size:])
    y_test=np.array(newy[size:])

    X = X[:, np.newaxis]
    X_train = X_train[:, np.newaxis]
    y_train = y_train[:, np.newaxis]
    X_test = X_test[:, np.newaxis]
    y_test = y_test[:, np.newaxis]

return X_train, X_test, y_train, y_test,X,y

def test_PolynomialFeatures(degree,*data):
    # 機器學習中一種常見的模式，是使用線性模型訓練數據的非線性函數。
    # 這種方法保持了一般快速的線性方法的性能，同時允許它們適應更廣泛的數據范圍。
    # 主要參數
    #   degree：控制多項式的度
    #   interaction_only：默認為False，如果指定為True，那么就不會有特征自己和自己結合的項，上面的二次項中沒有a^2和b^2。
    #   include_bias：默認為True。如果為True的話，那么就會有上面的 1那一項。
    X_train, X_test, y_train, y_test = data

    model = Pipeline([('poly', preprocessing.PolynomialFeatures(degree=degree)),
                      ('linear', linear_model.LinearRegression())])
    model.fit(X_train,y_train)
    X=np.vstack((X_train,X_test))

    coef = model.named_steps['linear'].coef_
    intercept = model.named_steps['linear'].intercept_
    y_plot = model.predict(X)
print('Coefficients={},intercept={}'.format(coef, intercept))
    # Coefficients=[-6.52563764e-09  4.07601927e+01 -2.10719706e+02  5.42901460e+02...]
    # intercept=intercept=188.12644759943421
def test_PolynomialFeatures_degree(*data):
    X_train, X_test, y_train, y_test,X,y = data
    plt.scatter(X_train,y_train, color='navy', s=30, marker='o', label="training points")
    plt.scatter(X_test, y_test, color='green', s=30, marker='*', label="test points")
    colors = ['teal', 'yellowgreen', 'gold','black']
for count, degree in enumerate([2 ,3, 4, 5]):
        model = Pipeline([('poly', preprocessing.PolynomialFeatures(degree=degree)),
                          ('linear', linear_model.LinearRegression())])
        model.fit(X_train,y_train)
        y_plot=model.predict(X)
        plt.plot(X, y_plot, color=colors[count], linewidth=2,label="degree %d" % degree)
    plt.legend()
plt.show()

if __name__ == '__main__':
    X_train,X_test,y_train,y_test=load_data()
    test_LinearRegression(X_train,X_test,y_train,y_test)
    test_Ridge_Regression(X_train,X_test,y_train,y_test)
    test_Ridge_alpha(X_train,X_test,y_train,y_test)
    test_Lasso_Regression(X_train,X_test,y_train,y_test)
    test_Lasso_alpha(X_train,X_test,y_train,y_test)
    test_ElasticNet_Regression(X_train,X_test,y_train,y_test)
    test_ElasticNet_alpha_rho(X_train,X_test,y_train,y_test)
    X_train, X_test, y_train, y_test = load_iris_data()
    test_Logistic_Regression(X_train,X_test,y_train,y_test)
    test_Logistic_Regression_C(X_train,X_test,y_train,y_test)
    test_LDA(X_train,X_test,y_train,y_test)
    plot_LDA_diff(X_train,X_test,y_train,y_test)
    X_train, X_test, y_train, y_test,X,y = load_ploy_data()
    test_PolynomialFeatures(2,X_train,X_test,y_train,y_test)
    test_PolynomialFeatures_degree(X_train,X_test,y_train,y_test,X,y)

# 線性判別分析回歸