電子發(fā)燒友App
由于高等數(shù)學底子太差的原因，機器學習無法深入學習下去，只能做一個簡單的嘗試者，甚至連調(diào)優(yōu)也未必能算的上，不過這樣也好，可以把重心放到對業(yè)務(wù)的理解上，以及業(yè)務(wù)和模型的選擇上。
線性模型包括了傳統(tǒng)的線性回歸、嶺回歸、Lasso回歸，主要用于連續(xù)值的預(yù)測；邏輯回歸雖然也是回歸，但卻是一種分類方法；LDA線性判別分析，則是一種降維方法；多項式回歸，是使用線性模型訓練數(shù)據(jù)的非線性函數(shù)。
總的來說，嘗試著回顧一下，也挺有意思的。
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文件，數(shù)據(jù)格式如下 # 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文件，數(shù)據(jù)格式如下 # 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) # 主要參數(shù)說明： # fit_intercept：表示是否計算截距,布爾型，默認為True， # 若參數(shù)值為True時，代表訓練模型需要加一個截距項； # 若參數(shù)為False時，代表模型無需加截距項。 # normalize：布爾型，默認為False，若fit_intercept參數(shù)設(shè)置False時，normalize參數(shù)無需設(shè)置； # 若normalize設(shè)置為True時，則輸入的樣本數(shù)據(jù)將( X - X均值) / | | X | |； # 若設(shè)置normalize = False時，在訓練模型前， 可以使用sklearn.preprocessing.StandardScaler進行標準化處理。 # copy_X,如果為True，則復制X # n_jobs，并行任務(wù)時指定的CPU數(shù)量 # 屬性： # coef_：回歸系數(shù)(斜率) # intercept_：截距項 # 主要方法： # fit(X, y, sample_weight=None) 訓練模型 # predict(X) 用模型進行預(yù)測 # score(X, y, sample_weight=None)，返回預(yù)測得分 # 其結(jié)果等于1 - (((y_true - y_pred) ** 2).sum() / ((y_true - y_true.mean()) ** 2).sum()) # score在-1范圍內(nèi)，越大預(yù)測性能越好 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回歸也是一種正則化的線性回歸，且也是約束系數(shù)使其接近于， # 不過其用到的方法不同，嶺回歸用到的是L2正則化， # 而lasso回歸用到的是L1正則化（L1是通過稀疏參數(shù)（減少參數(shù)的數(shù)量）來降低復雜度，即L1正則化使參數(shù)為零，L2是通過減小參數(shù)值的大小來降低復雜度， # Parameters # alpha:正則化系數(shù)，較大的值指定更強的正則化。 # fit_intercept:是否計算模型的截距，默認為True，計算截距 # normalize:在需要計算截距時，如果值為True，則變量x在進行回歸之前先進行歸一化（）,如果需要進行標準化則normalize=False。若不計算截距，則忽略此參數(shù)。 # copy_X:默認為True，將復制X；否則，X可能在計算中被覆蓋。 # max_iter:共軛梯度求解器的最大迭代次數(shù)。對于sparse_cg和lsqr,默認值由scipy.sparse.linalg確定。對于sag求解器，默認值為1000. # tol:float類型，指定計算精度。 # solver：求解器{auto,svd,cholesky,lsqr,sparse_cg,sag,saga} # aotu:根據(jù)數(shù)據(jù)類型自動選擇求解器 # svd:使用X的奇異值分解計算嶺系數(shù)。奇異矩陣比cholesky更穩(wěn)定 # cholesky:使用標準的scipy.linalg.solve函數(shù)獲得收斂的系數(shù) # sparsr_cg:使用scipy.sparse.linalg.cg中的共軛梯度求解器。作為一種迭代算法，這個求解器比cholesky更適合大規(guī)模數(shù)據(jù)（設(shè)置tol和max_iter的可能性） # lsqr:使用專用的正則化最小二乘方法scipy.sparse.linalg.lsqr。 # sag:使用隨機平均梯度下降，saga使用其改進的，無偏見的版本，兩種方法都使用迭代過程。 # random_state:隨機數(shù)生成器的種子。 # Attributes # coef_:返回模型的估計系數(shù)。 # intercept_:線性模型的獨立項，一維情形下的截距。 # n_iter:實際迭代次數(shù)。 # Methods # fit(X,y):使用數(shù)據(jù)訓練模型 # get_params([deep=True]):返回函數(shù)LinearRegression()內(nèi)部的參數(shù)值 # predict(X):使用模型做預(yù)測 # score(X，y):返回模型的擬合優(yōu)度判定系數(shù) # 為回歸平方和與總離差平方和的比值，介于-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): # 嶺回歸是一種專用于共線性數(shù)據(jù)分析的有偏估計回歸方法，實質(zhì)上是一種改良的最小二乘估計法， # 通過放棄最小二乘法的無偏性，以損失部分信息、降低精度為代價獲得回歸系數(shù)更為符合實際、更可靠的回歸方法，對病態(tài)數(shù)據(jù)的擬合要強于最小二乘法。 # Parameters # alpha : float, 可選，默認 1.0。當 alpha 為 時算法等同于普通最小二乘法 # fit_intercept : 是否計算模型的截距，默認為True，計算截距 # normalize : boolean, 可選, 默認 False; 若 True，則先 normalize 再 regression。若 fit_intercept 為 false 則忽略此參數(shù)。 # copy_X : 默認為True，將復制X；否則，X可能在計算中被覆蓋。 # precompute : True | False | array-like, 默認=False # max_iter : int, 可選,最大循環(huán)次數(shù)。 # tol : float, 可選，優(yōu)化容忍度 The tolerance for the optimization: 若更新后小于 tol，優(yōu)化代碼檢查優(yōu)化的 dual gap 并繼續(xù)直到小于 tol 為止。 # warm_start : bool, 可選。為 True 時, 重復使用上一次學習作為初始化，否則直接清除上次方案。 # positive : bool, 可選。設(shè)為 True 時，強制使系數(shù)為正。 # selection : str, 默認 ‘cyclic’ # 若設(shè)為 ‘random’, 每次循環(huán)會隨機更新參數(shù)，而按照默認設(shè)置則會依次更新。設(shè)為隨機通常會極大地加速交點（convergence）的產(chǎn)生，尤其是 tol 比 1e-4 大的情況下。 # random_state : int, RandomState instance, 或者 None (默認值) # Attributes # coef_:返回模型的估計系數(shù)。 # intercept_:線性模型的獨立項，一維情形下的截距。 # n_iter:實際迭代次數(shù)。 # Methods # fit(X,y):使用數(shù)據(jù)訓練模型 # get_params([deep=True]):返回函數(shù)LinearRegression()內(nèi)部的參數(shù)值 # predict(X):使用模型做預(yù)測 # score(X，y):預(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范數(shù)的融合，所以在參數(shù)中除了alpha之外還有L1_ratio 默認alpha=1，l1_ratio=0.5 # Parameters # alpha: a值。 # fit_intercept:一個布爾值，指定是否需要計算b值。如果為False，那么不計算b值（模型會認為你已經(jīng)將數(shù)據(jù)中心化了）。 # max_iter:整數(shù)值，指定最大迭代次數(shù)。 # normalize：一個布爾值。如果為True，那么訓練樣本會在回歸之前被歸一化。 # copy_X：一個布爾值，如果為True，則會復制X值 # precompute：一個布爾值或者一個序列。他決定是否提前計算Gram矩陣來加速計算。 # tol：一個浮點數(shù)，指定判斷迭代收斂與否的閾值。 # warm_start：一個布爾值，如為True，那么使用前一次訓練結(jié)果繼續(xù)訓練。否則重頭開始訓練。 # positive：一個布爾值，如為Ture，那么強制要求全中響亮的分量都為整數(shù)。 # selection：一個字符串，可以為‘cyclic’（更新時候，從前向后一次選擇權(quán)重向量的一個分量來更新）或者‘random'（隨機選擇權(quán)重向量的一個分量來更新），他指定了當每輪迭代的時候，選擇權(quán)重向量的一個分量來更新 # random_state：一個整數(shù)或者一個RandomState實例，或者為None。 # Attributes # coef_:返回模型的估計系數(shù)。 # intercept_:線性模型的獨立項，一維情形下的截距。 # n_iter:實際迭代次數(shù)。 # Methods # fit(X,y):使用數(shù)據(jù)訓練模型 # get_params([deep=True]):返回函數(shù)LinearRegression()內(nèi)部的參數(shù)值 # predict(X):使用模型做預(yù)測 # score(X，y):預(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() # 加載鳶尾花數(shù)據(jù) 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（對數(shù)線性分類器）。 # 該模型利用函數(shù) logistic function 將單次試驗（single trial）的可能結(jié)果輸出為概率。 # scikit-learn 中 logistic 回歸在 LogisticRegression 類中實現(xiàn)了二分類（binary）、一對多分類（one-vs-rest）及多項式 logistic 回歸，并帶有可選的 L1 和 L2 正則化。 # Parameters # penalty='l2' : 字符串‘l1’或‘l2’,默認‘l2’。 # 用來指定懲罰的基準（正則化參數(shù)）。只有‘l2’支持‘newton-cg’、‘sag’和‘lbfgs’這三種算法。 # 如果選擇‘l2’，solver參數(shù)可以選擇‘liblinear’、‘newton-cg’、‘sag’和‘lbfgs’這四種算法；如果選擇‘l1’的話就只能用‘liblinear’算法。 # dual=False : 對偶或者原始方法。Dual只適用于正則化相為l2的‘liblinear’的情況，通常樣本數(shù)大于特征數(shù)的情況下，默認為False。 # C=1.0 : C為正則化系數(shù)λ的倒數(shù)，必須為正數(shù)，默認為1。和SVM中的C一樣，值越小，代表正則化越強。 # fit_intercept=True : 是否存在截距，默認存在。 # intercept_scaling=1 : 僅在正則化項為‘liblinear’，且fit_intercept設(shè)置為True時有用。 # solver='liblinear' : solver參數(shù)決定了我們對邏輯回歸損失函數(shù)的優(yōu)化方法，有四種算法可以選擇。 # a) liblinear：使用了開源的liblinear庫實現(xiàn)，內(nèi)部使用了坐標軸下降法來迭代優(yōu)化損失函數(shù)。 # b) lbfgs：擬牛頓法的一種，利用損失函數(shù)二階導數(shù)矩陣即海森矩陣來迭代優(yōu)化損失函數(shù)。 # c) newton-cg：也是牛頓法家族的一種，利用損失函數(shù)二階導數(shù)矩陣即海森矩陣來迭代優(yōu)化損失函數(shù)。 # d) sag：即隨機平均梯度下降，是梯度下降法的變種，和普通梯度下降法的區(qū)別是每次迭代僅僅用一部分的樣本來計算梯度，適合于樣本數(shù)據(jù)多的時候。 # multi_class='ovr' : 分類方式。 # ovr即one-vs-rest(OvR)，multinomial是many-vs-many(MvM)。 # 如果是二元邏輯回歸，ovr和multinomial并沒有任何區(qū)別，區(qū)別主要在多元邏輯回歸上。 # ovr不論是幾元回歸，都當成二元回歸來處理。mvm從從多個類中每次選兩個類進行二元回歸。如果總共有T類，需要T(T-1)/2次分類。 # OvR相對簡單，但分類效果相對略差（大多數(shù)樣本分布情況）。而MvM分類相對精確，但是分類速度沒有OvR快。 # 如果選擇了ovr，則4種損失函數(shù)的優(yōu)化方法liblinear，newton-cg,lbfgs和sag都可以選擇。但是如果選擇了multinomial,則只能選擇newton-cg, lbfgs和sag了。 # class_weight=None : 類型權(quán)重參數(shù)。用于標示分類模型中各種類型的權(quán)重。默認不輸入，即所有的分類的權(quán)重一樣。 # 選擇‘balanced’自動根據(jù)y值計算類型權(quán)重。 # 自己設(shè)置權(quán)重，格式：{class_label: weight}。例如0,1分類的er'yuan二元模型，設(shè)置class_weight={:0.9, 1:0.1}，這樣類型的權(quán)重為90%，而類型1的權(quán)重為10%。 # random_state=None : 隨機數(shù)種子，默認為無。僅在正則化優(yōu)化算法為sag,liblinear時有用。 # max_iter=100 : 算法收斂的最大迭代次數(shù)。 # tol=0.0001 : 迭代終止判據(jù)的誤差范圍。 # verbose= : 日志冗長度int：冗長度；：不輸出訓練過程；1：偶爾輸出；>1：對每個子模型都輸出 # warm_start=False : 是否熱啟動，如果是，則下一次訓練是以追加樹的形式進行（重新使用上一次的調(diào)用作為初始化）。布爾型，默認False。 # n_jobs=1 : 并行數(shù)，int：個數(shù)；-1：跟CPU核數(shù)一致；1:默認值。 # Attributes # coef_:返回模型的估計系數(shù)。 # intercept_:線性模型的獨立項，一維情形下的截距。 # n_iter:實際迭代次數(shù)。 # Methods # fit(X, y, sample_weight=None) # 擬合模型，用來訓練LR分類器，其中X是訓練樣本，y是對應(yīng)的標記向量 # 返回對象，self。 # fit_transform(X, y=None, **fit_params) # fit與transform的結(jié)合，先fit后transform。返回X_new:numpy矩陣。 # predict(X) # 用來預(yù)測樣本，也就是分類，X是測試集。返回array。 # predict_proba(X) # 輸出分類概率。返回每種類別的概率，按照分類類別順序給出。如果是多分類問題，multi_class="multinomial"，則會給出樣本對于每種類別的概率。 # 返回array-like。 # score(X, y, sample_weight=None) # 返回給定測試集合的平均準確率（mean accuracy），浮點型數(shù)值。 # 對于多個分類返回，則返回每個類別的準確率組成的哈希矩陣。 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范數(shù)的融合，所以在參數(shù)中除了alpha之外還有L1_ratio 默認alpha=1，l1_ratio=0.5 # Parameters # solver：一個字符串，指定了求解最優(yōu)化問題的算法，可以為如下的值。 # 'svd'：奇異值分解。對于有大規(guī)模特征的數(shù)據(jù)，推薦用這種算法。 # 'lsqr'：最小平方差，可以結(jié)合skrinkage參數(shù)。 # 'eigen' ：特征分解算法，可以結(jié)合shrinkage參數(shù)。 # skrinkage：字符串‘a(chǎn)uto’或者浮點數(shù)活者None。該參數(shù)通常在訓練樣本數(shù)量小于特征數(shù)量的場合下使用。該參數(shù)只有在solver=lsqr或者eigen下才有意義 # '字符串‘a(chǎn)uto’：根據(jù)Ledoit-Wolf引理來自動決定shrinkage參數(shù)的大小。 # 'None：不使用shrinkage參數(shù)。 # 浮點數(shù)（位于~1之間）：指定shrinkage參數(shù)。 # priors：一個數(shù)組，數(shù)組中的元素依次指定了每個類別的先驗概率。如果為None，則認為每個類的先驗概率都是等可能的。 # n_components：一個整數(shù)。指定了數(shù)組降維后的維度（該值必須小于n_classes-1）。 # store_covariance：一個布爾值。如果為True，則需要額外計算每個類別的協(xié)方差矩陣。 # warm_start：一個布爾值。如果為True，那么使用前一次訓練結(jié)果繼續(xù)訓練，否則從頭開始訓練。 # tol：一個浮點數(shù)。它指定了用于SVD算法中評判迭代收斂的閾值。 # ———————————————— # Attributes # coef_：權(quán)重向量。 # intercept：b值。 # covariance_：一個數(shù)組，依次給出了每個類別煩人協(xié)方差矩陣。 # means_：一個數(shù)組，依次給出了每個類別的均值向量。 # xbar_：給出了整體樣本的均值向量。 # n_iter_：實際迭代次數(shù)。 # Methods # fix(X,y)：訓練模型。 # predict(X)：用模型進行預(yù)測，返回預(yù)測值。 # score(X,y[,sample_weight])：返回（X，y）上的預(yù)測準確率（accuracy）。 # predict_log_proba（X）：返回一個數(shù)組，數(shù)組的元素一次是 X 預(yù)測為各個類別的概率的對數(shù)值。 # predict_proba（X）：返回一個數(shù)組，數(shù)組元素一次是 X 預(yù)測為各個類別的概率的概率值。 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): # 機器學習中一種常見的模式，是使用線性模型訓練數(shù)據(jù)的非線性函數(shù)。 # 這種方法保持了一般快速的線性方法的性能，同時允許它們適應(yīng)更廣泛的數(shù)據(jù)范圍。 # 主要參數(shù) # degree：控制多項式的度 # interaction_only：默認為False，如果指定為True，那么就不會有特征自己和自己結(jié)合的項，上面的二次項中沒有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)
# 線性判別分析回歸
工商網(wǎng)監(jiān)
評論