-
分類算法 -
回歸算法 -
聚類算法 -
降維算法 -
模型優化 -
文本預處理
其中分類算法和回歸算法又叫做監督學習，聚類算法和降維算法又叫做非監督學習。
1.分類算法
KNN算法
from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier()
'''
__init__函數
def __init__(self, n_neighbors=5,
weights='uniform', algorithm='auto', leaf_size=30,
p=2, metric='minkowski', metric_params=None, n_jobs=1,
**kwargs):
n_neighbors=5,指定以幾個最鄰近的樣本具有投票權
weight="uniform",每個擁有投票權的樣本是按照什么比重投票，"uniform"表示按照等比重投票，"distance"表示按距離反比投票,[callable]表示自己定義的一個函數，這個函數接收一個距離數組返回一個全職數組
algorithm="auto",內部采用什么樣的算法實現，有以下幾種方法，"ball_tree":球樹，"kd_tree":kd樹，"brute":暴力搜索。
"auto"表示自動根據數據類型和結構選擇合適的算法。一般來說，低維數據用kd_tree,高維數據用ball_tree
leaf_size=30:ball_tree或者kd_tree的葉子節點規模
matric="minkowski",怎樣度量距離，默認是閔式距離
p=2,閔式距離各種不同的距離參數
metric_params=None,距離度量函數的額外關鍵字參數，一般默認為None，不用管
n_jobs=1,並行的任務數
用法：
knn.fit(X_train, y_train)
y_pred = knn.predict(X_test)
knn.score(y_pred, y_test)
'''
朴素貝葉斯算法
from sklearn.naive_bayes import GaussianNB
gsn = GaussianNB()
'''
__init__函數
def __init__(self, priors=None):
self.priors = priors
priors=None,先驗概率
用法：
gsn.fit(X_train, y_train)
y_pred = gsn.predict(X_test)
'''
線性判別分析
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
lda = LinearDiscriminantAnalysis()
'''
__init__函數
def __init__(self, solver='svd', shrinkage=None, priors=None,
n_components=None, store_covariance=False, tol=1e-4):
self.solver = solver
self.shrinkage = shrinkage
self.priors = priors
self.n_components = n_components
self.store_covariance = store_covariance # used only in svd solver
self.tol = tol # used only in svd solver
solver="svd",求解算法，svd表示使用奇異值分解求解，不用計算協方差矩陣。
lsqr表示最小平方qr分解
eigen表示特征值分解
shrinkage=None,是否使用參數收縮
priors=None,用於LDA中貝葉斯規則的先驗概率
components,需要保留的特征個數，小於等於n-1
store_covariance，是否計算每個類的協方差矩陣，0.19版本刪除
用法：
lda.fit(X_train, y_train)
屬性：
covariances_：每個類的協方差矩陣， shape = [n_features, n_features]
means_：類均值，shape = [n_classes, n_features]
priors_：歸一化的先驗概率
rotations_：LDA分析得到的主軸，shape [n_features, n_component]
scalings_：數組列表，每個高斯分布的方差σ
'''
二次判斷分析
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
qda = QuadraticDiscriminantAnalysis()
'''
__init__函數
def __init__(self, priors=None, reg_param=0., store_covariance=False,
tol=1.0e-4, store_covariances=None):
self.priors = np.asarray(priors) if priors is not None else None
self.reg_param = reg_param
self.store_covariances = store_covariances
self.store_covariance = store_covariance
self.tol = tol
reg_param=None,正則化參數，規范化協方差
'''
支持向量機
from sklearn.svm import SVC
svc = SVC()
'''
__init__函數
def __init__(self, C=1.0, kernel='rbf', degree=3, gamma='auto',
coef0=0.0, shrinking=True, probability=False,
tol=1e-3, cache_size=200, class_weight=None,
verbose=False, max_iter=-1, decision_function_shape='ovr',
random_state=None):
C,錯誤項的懲罰系數，即對分錯樣本的懲罰程度越大，因此在訓練樣本中准確率越高，但是泛化能力降低，也就是對測試數據的分類准確率降低。
kernel，算法中采用的核函數類型
degree，這個參數只對多項式核函數有用，是指多項式核函數的階數n
gamma，核函數系數，默認為auto
coef0，核函數中的獨立項
probability，是否啟用概率估計
shrinking，是否采用啟發式收縮方式
tol，svm停止訓練的誤差精度
cache_size，指定訓練所需要的內存，以MB為單位，默認為200MB。
class_weight，給每個類別分別設置不同的懲罰參數C，如果沒有給，則會給所有類別都給C=1，即前面參數指出的參數C.
verbose，是否啟用詳細輸出。此設置利用libsvm中的每個進程運行時設置，如果啟用，可能無法在多線程上下文中正常工作。一般情況都設為False，不用管它。
max_iter，最大迭代次數，如果為-1，表示不限制
random_state，偽隨機數發生器的種子,在混洗數據時用於概率估計。
屬性：
svc.n_support_：各類各有多少個支持向量
svc.support_：各類的支持向量在訓練樣本中的索引
svc.support_vectors_：各類所有的支持向量
'''
神經網絡
from sklearn.neural_network import MLPClassifier
mlp = MLPClassifier()
'''
__init__函數
def __init__(self, hidden_layer_sizes=(100,), activation="relu",
solver='adam', alpha=0.0001,
batch_size='auto', learning_rate="constant",
learning_rate_init=0.001, power_t=0.5, max_iter=200,
shuffle=True, random_state=None, tol=1e-4,
verbose=False, warm_start=False, momentum=0.9,
nesterovs_momentum=True, early_stopping=False,
validation_fraction=0.1, beta_1=0.9, beta_2=0.999,
epsilon=1e-8):
hidden_layer_sizes，長度=n_layers-2, 默認(100，），第i個元素表示第i個隱藏層的神經元的個數。
activation，激活函數，默認為relu
solver，默認 ‘adam’，用來優化權重
alpha，可選的，默認0.0001,正則化項參數
batch_size，默認‘auto’,隨機優化的minibatches的大小
learning_rate，默認‘constant’，用於權重更新
max_iter，默認200，最大迭代次數。
random_state，可選，默認None，隨機數生成器的狀態或種子
shuffle，可選，默認True,只有當solver=’sgd’或者‘adam’時使用，判斷是否在每次迭代時對樣本進行清洗。
tol，可選，默認1e-4，優化的容忍度
learning_rate_int，默認0.001，初始學習率，控制更新權重的補償，只有當solver=’sgd’ 或’adam’時使用。
power_t，只有solver=’sgd’時使用，是逆擴展學習率的指數.當learning_rate=’invscaling’，用來更新有效學習率。
verbose，是否將過程打印到stdout
warm_start，當設置成True，使用之前的解決方法作為初始擬合，否則釋放之前的解決方法。
屬性：
- classes_:每個輸出的類標簽
- loss_:損失函數計算出來的當前損失值
- coefs_:列表中的第i個元素表示i層的權重矩陣
- intercepts_:列表中第i個元素代表i+1層的偏差向量
- n_iter_ ：迭代次數
- n_layers_:層數
- n_outputs_:輸出的個數
- out_activation_:輸出激活函數的名稱。
用法：
- fit(X,y):擬合
- get_params([deep]):獲取參數
- predict(X):使用MLP進行預測
- predic_log_proba(X):返回對數概率估計
- predic_proba(X)：概率估計
- score(X,y[,sample_weight]):返回給定測試數據和標簽上的平均准確度
-set_params(**params):設置參數。
'''
決策樹算法
from sklearn.tree import DecisionTreeClassifier
dtc = DecisionTreeClassifier()
'''
__init__函數
def __init__(self,
criterion="gini",
splitter="best",
max_depth=None,
min_samples_split=2,
min_samples_leaf=1,
min_weight_fraction_leaf=0.,
max_features=None,
random_state=None,
max_leaf_nodes=None,
min_impurity_decrease=0.,
min_impurity_split=None,
class_weight=None,
presort=False):
criterion，划分標准；可選項，默認值為”gini”，即基尼指數，”entropy”信息增益
max_depth，最大深度；可選項，默認值為”None”，即不限深度，直到達到某種閾值
min_samples_split，閾值；可選項，默認值為2，當某個結點的樣本數小於該值時，停止划分；
min_samples_leaf，葉結點中，樣本點的最小值；默認值為1
屬性：
n_classes_ 列出類數目
classes_ 列出類標簽
feature_importances_ 列出每一維特征的重要性
n_features_ 特征數目
用法：
fix(X,y) 擬合
get_params() 獲取參數表中的參數
predict(X) 返回預測出的結果
score(X,y) 返回准確率
'''
集成算法-Bagging
from sklearn.ensemble import BaggingClassifier
bgc = BaggingClassifier()
'''
__init__函數
def __init__(self,
base_estimator=None,
n_estimators=10,
max_samples=1.0,
max_features=1.0,
bootstrap=True,
bootstrap_features=False,
oob_score=False,
warm_start=False,
n_jobs=1,
random_state=None,
verbose=0):
base_estimator，基本的估計器，就是你要用到的算法，如果該參數沒有賦值，默認為決策樹。
這個信息告訴我們bagging，不僅可以用在決策樹上，還可以用於其他的算法模型上
n_estimators，基本估計器的個數，就是你要產生多少個子模型，用在決策樹時，即表示產生多少條決策樹用來融合。
max_samples，節點分裂參與判斷的最大樣本數
max_features，節點分裂參與判斷的最大特征數
bootstrap，是否有放回對樣本抽樣
bootstrap_features，是否有放回對特征抽樣
'''
集成算法-隨機森林
from sklearn.ensemble import RandomForestClassifier
rfc = RandomForestClassifier()
'''
__init__函數
def __init__(self,
n_estimators=10,
criterion="gini",
max_depth=None,
min_samples_split=2,
min_samples_leaf=1,
min_weight_fraction_leaf=0.,
max_features="auto",
max_leaf_nodes=None,
min_impurity_decrease=0.,
min_impurity_split=None,
bootstrap=True,
oob_score=False,
n_jobs=1,
random_state=None,
verbose=0,
warm_start=False,
class_weight=None):
min_samples_split，分裂所需要的最小樣本數
min_samples_leaf，葉節點最小樣本數
min_weight_fraction_leaf，葉子節點所需要的最小權值
bootstrap，是否有放回的采樣。
oob_score，在某次決策樹訓練中沒有被bootstrap選中的數據
warm_start，熱啟動，決定是否使用上次調用該類的結果然后增加新的。
class_weight，各個label的權重。
用法：
predict_proba(x)：給出帶有概率值的結果。每個點在所有label的概率和為1.
predict(x)：直接給出預測結果。內部還是調用的predict_proba()，根據概率的結果看哪個類型的預測值最高就是哪個類型。
predict_log_proba(x)：和predict_proba基本上一樣，只是把結果給做了log()處理。
'''
集成算法-Ada Boosting
from sklearn.ensemble import AdaBoostClassifier
abc = AdaBoostClassifier()
'''
__init__函數
def __init__(self,
base_estimator=None,
n_estimators=50,
learning_rate=1.,
algorithm='SAMME.R',
random_state=None):
learning_rate，學習效率
'''
集成算法-GDBT(Gradient Tree Boosting)
from sklearn.ensemble import GradientBoostingClassifier
gbc = GradientBoostingClassifier()
'''
__init__函數
def __init__(self, loss='deviance', learning_rate=0.1, n_estimators=100,
subsample=1.0, criterion='friedman_mse', min_samples_split=2,
min_samples_leaf=1, min_weight_fraction_leaf=0.,
max_depth=3, min_impurity_decrease=0.,
min_impurity_split=None, init=None,
random_state=None, max_features=None, verbose=0,
max_leaf_nodes=None, warm_start=False,
presort='auto'):
subsample，訓練每個決策樹所用到的子樣本占總樣本的比例，而對於子樣本的選擇是隨機的。
max_ leaf_ nodes，定義了樹里最多能有多少個終點節點。
'''
2.回歸算法
最小二乘法
from sklearn.linear_model import LinearRegression
lg = LinearRegression()
'''
__init__參數
def __init__(self, fit_intercept=True, normalize=False, copy_X=True,
n_jobs=1):
fit_intercept，是否存在截距，默認存在
normalize，標准化開關，默認關閉
用法：
lg.fit(X_train, y_train)
y_pred = lg.predict(X_test)
lg.score(y_pred, y_test)
'''
嶺回歸
from sklearn.linear_model import Ridge
clf = Ridge()
'''
__init__函數
def __init__(self, alpha=1.0, fit_intercept=True, normalize=False,
copy_X=True, max_iter=None, tol=1e-3, solver="auto",
random_state=None):
alpha，兩項之間的權重；
fit_intercept，默認為true，數據可以攔截，沒有中心化
normalize，輸入的樣本特征歸一化，默認false
copy_X，復制或者重寫
max_iter，最大迭代次數
tol，控制求解的精度
solver，求解器
用法：
clf.fit(X, y),輸入訓練樣本數據X，和對應的標記y
clf.predict(X),利用學習好的線性分類器，預測標記，一般在fit之后調用；
clf.corf_,回歸系數
clf.intercept_，截距
'''
核嶺回歸
from sklearn.kernel_ridge import KernelRidge
clf = KernelRidge()
'''
__init__函數
def __init__(self, alpha=1, kernel="linear", gamma=None, degree=3, coef0=1,
kernel_params=None):
kernel，核的類型
gamma，rbf，laplacian，poly，chi2，sigmoid核中的參數，使用其他核時無效。
degree，poly核中的參數d，使用其他核時無效
coef0，poly和sigmoid核中的0參數的替代值，使用其他核時無效。
屬性：
dual_coef_，核空間對應的模型參數
X_fit_，訓練數據，預測時也需要該值
'''
支撐向量機
from sklearn.svm import SVR
svr = SVR()
'''
__init__函數
def __init__(self, kernel='rbf', degree=3, gamma='auto', coef0=0.0,
tol=1e-3, C=1.0, epsilon=0.1, shrinking=True,
cache_size=200, verbose=False, max_iter=-1):
C，懲罰系數
'''
Lasso回歸
from sklearn.linear_model import Lasso
lasso = Lasso()
'''
__init__函數
def __init__(self, alpha=1.0, fit_intercept=True, normalize=False,
precompute=False, copy_X=True, max_iter=1000,
tol=1e-4, warm_start=False, positive=False,
random_state=None, selection='cyclic'):
alpha,可選，默認 1.0。當 alpha 為 0 時算法等同於普通最小二乘法，可通過 Linear Regression 實現，因此不建議將 alpha 設為 0.
fit_intercept,是否進行攔截計算
max_iter，最大循環次數。
tol，優化容忍度 The tolerance for the optimization
warm_start，為 True 時, 重復使用上一次學習作為初始化，否則直接清除上次方案
positive，設為 True 時，強制使系數為正。
selection，若設為 ‘random’, 每次循環會隨機更新參數，而按照默認設置則會依次更新
'''
彈性網絡回歸
from sklearn.linear_model import ElasticNet
etn = ElasticNet()
'''
__init__函數
def __init__(self, alpha=1.0, l1_ratio=0.5, fit_intercept=True,
normalize=False, precompute=False, max_iter=1000,
copy_X=True, tol=1e-4, warm_start=False, positive=False,
random_state=None, selection='cyclic'):
'''
貝葉斯回歸
from sklearn.linear_model import BayesianRidge
bys = BayesianRidge()
'''
__init__函數
def __init__(self, n_iter=300, tol=1.e-3, alpha_1=1.e-6, alpha_2=1.e-6,
lambda_1=1.e-6, lambda_2=1.e-6, compute_score=False,
fit_intercept=True, normalize=False, copy_X=True,
verbose=False):
'''
邏輯回歸
from sklearn.linear_model import LogisticRegression
clf = LogisticRegression()
'''
__init__函數
def __init__(self, penalty='l2', dual=False, tol=1e-4, C=1.0,
fit_intercept=True, intercept_scaling=1, class_weight=None,
random_state=None, solver='liblinear', max_iter=100,
multi_class='ovr', verbose=0, warm_start=False, n_jobs=1):
penalty，懲罰項，str類型，可選參數為l1和l2，默認為l2。
dual，對偶或原始方法，bool類型，默認為False。
tol，停止求解的標准，float類型，默認為1e-4。就是求解到多少的時候，停止，認為已經求出最優解
c，正則化系數λ的倒數，float類型，默認為1.0
fit_intercept，是否存在截距或偏差，bool類型，默認為True。
intercept_scaling，僅在正則化項為”liblinear”，且fit_intercept設置為True時有用。float類型，默認為1。
class_weight，用於標示分類模型中各種類型的權重，可以是一個字典或者’balanced’字符串，默認為不輸入，也就是不考慮權重，即為None。
solver，優化算法選擇參數
'''
穩健回歸
from sklearn.linear_model import RANSACRegressor
rsg = RANSACRegressor()
'''
__init__函數
def __init__(self, base_estimator=None, min_samples=None,
residual_threshold=None, is_data_valid=None,
is_model_valid=None, max_trials=100, max_skips=np.inf,
stop_n_inliers=np.inf, stop_score=np.inf,
stop_probability=0.99, residual_metric=None,
loss='absolute_loss', random_state=None):
'''
多項式回歸
from sklearn.preprocessing import PolynomialFeatures
pnf = PolynomialFeatures()
'''
__init__函數
def __init__(self, degree=2, interaction_only=False, include_bias=True):
degree,控制多項式的度
interaction_only,默認為False，如果指定為True，那么就不會有特征自己和自己結合的項
include_bias,是否包含截距，默認為True。
'''
偏最小二乘回歸
from sklearn.cross_decomposition import PLSRegression
plsr = PLSRegression()
'''
__init__函數
def __init__(self, n_components=2, scale=True,
max_iter=500, tol=1e-06, copy=True):
n_components，要保留的主成分數量,默認為2
scale，是否歸一化數據，默認為是
max_iter，使用NIPALS時的最大迭代次數
tol，迭代截止條件
'''
典型相關分析
from sklearn.cross_decomposition import CCA
cca = CCA()
'''
__init__函數
def __init__(self, n_components=2, scale=True,
max_iter=500, tol=1e-06, copy=True):
'''
3.聚類算法
近鄰算法
from sklearn.neighbors import NearestNeighbors
nbrs = NearestNeighbors()
'''
__init__函數
def __init__(self, n_neighbors=5, radius=1.0,
algorithm='auto', leaf_size=30, metric='minkowski',
p=2, metric_params=None, n_jobs=1, **kwargs):
n_neighbors，整數，可選（默認值為5）,用k_neighbors查找的近鄰數
radius，參數空間的范圍
'''
KMeans算法
from sklearn.cluster import KMeans
k = KMeans()
'''
__init__函數
def __init__(self, n_clusters=8, init='k-means++', n_init=10,
max_iter=300, tol=1e-4, precompute_distances='auto',
verbose=0, random_state=None, copy_x=True,
n_jobs=1, algorithm='auto'):
n_clusters，生成的聚類數，即產生的質心（centroids）數
max_iter，執行一次k-means算法所進行的最大迭代數。
n_init，用不同的質心初始化值運行算法的次數，最終解是在inertia意義下選出的最優結果。
init：有三個可選值：’k-means++’， ‘random’，或者傳遞一個ndarray向量。
此參數指定初始化方法，默認值為 ‘k-means++’。
（１）‘k-means++’ 用一種特殊的方法選定初始質心從而能加速迭代過程的收斂（即上文中的k-means++介紹）
（２）‘random’ 隨機從訓練數據中選取初始質心。
（３）如果傳遞的是一個ndarray，則應該形如 (n_clusters, n_features) 並給出初始質心。
precompute_distances，三個可選值，‘auto’，True 或者 False。預計算距離，計算速度更快但占用更多內存。
tol，默認值= 1e-4 與inertia結合來確定收斂條件。
random_state，用於初始化質心的生成器（generator）。如果值為一個整數，則確定一個seed。此參數默認值為numpy的隨機數生成器。
copy_x，當我們precomputing distances時，將數據中心化會得到更准確的結果。如果把此參數值設為True，則原始數據不會被改變。
如果是False，則會直接在原始數據上做修改並在函數返回值時將其還原。
但是在計算過程中由於有對數據均值的加減運算，所以數據返回后，原始數據和計算前可能會有細小差別。
用法：
fit(X[,y]):
計算k-means聚類。
fit_predictt(X[,y]):
計算簇質心並給每個樣本預測類別。
fit_transform(X[,y])：
計算簇並 transform X to cluster-distance space。
get_params([deep])：
取得估計器的參數。
predict(X):predict(X)
給每個樣本估計最接近的簇。
score(X[,y]):
計算聚類誤差
set_params(**params):
為這個估計器手動設定參數。
transform(X[,y]): 將X轉換為群集距離空間。
在新空間中，每個維度都是到集群中心的距離。 請注意，即使X是稀疏的，轉換返回的數組通常也是密集的。
'''
層次聚類
from sklearn.cluster import AgglomerativeClustering
agg = AgglomerativeClustering()
'''
__init__函數
def __init__(self, n_clusters=2, affinity="euclidean",
memory=None,
connectivity=None, compute_full_tree='auto',
linkage='ward', pooling_func=np.mean):
n_clusters，一個整數，指定分類簇的數量
connectivity，一個數組或者可調用對象或者None，用於指定連接矩陣
affinity，一個字符串或者可調用對象，用於計算距離。
memory，用於緩存輸出的結果，默認為不緩存
compute_full_tree，通常當訓練了n_clusters后，訓練過程就會停止，但是如果compute_full_tree=True，則會繼續訓練從而生成一顆完整的樹
linkage，一個字符串，用於指定鏈接算法
屬性：
labels：每個樣本的簇標記
n_leaves_：分層樹的葉節點數量
n_components：連接圖中連通分量的估計值
children：一個數組，給出了每個非節點數量
方法：
fit(X[,y])：訓練樣本
fit_predict(X[,y])：訓練模型並預測每個樣本的簇標記
'''
DBScan
from sklearn.cluster import DBSCAN
dbs = DBSCAN()
'''
__init__函數
def __init__(self, eps=0.5, min_samples=5, metric='euclidean',
metric_params=None, algorithm='auto', leaf_size=30, p=None,
n_jobs=1):
eps，DBSCAN算法參數，即我們的ϵ-鄰域的距離閾值，和樣本距離超過ϵ的樣本點不在ϵ-鄰域內。默認值是0.5。一般需要通過在多組值里面選擇一個合適的閾值。
eps過大，則更多的點會落在核心對象的ϵ-鄰域，此時我們的類別數可能會減少， 本來不應該是一類的樣本也會被划為一類。
反之則類別數可能會增大，本來是一類的樣本卻被划分開。
min_samples，DBSCAN算法參數，即樣本點要成為核心對象所需要的ϵ-鄰域的樣本數閾值。默認值是5. 一般需要通過在多組值里面選擇一個合適的閾值。
通常和eps一起調參。在eps一定的情況下，min_samples過大，則核心對象會過少，此時簇內部分本來是一類的樣本可能會被標為噪音點，類別數也會變多。
反之min_samples過小的話，則會產生大量的核心對象，可能會導致類別數過少。
metric，最近鄰距離度量參數
algorithm，最近鄰搜索算法參數
'''
3.降維算法
主成分分析法
from sklearn.decomposition import PCA
pca = PCA()
'''
__init__函數
def __init__(self, n_components=None, copy=True, whiten=False,
svd_solver='auto', tol=0.0, iterated_power='auto',
random_state=None):
n_components，PCA算法中所要保留的主成分個數n，即保留下來的特征個數n
copy，表示是否在運行算法時，將原始訓練數據復制一份。
whiten，白化，使得每個特征具有相同的方差
'''
核函主成分
from sklearn.decomposition import KernelPCA
kpca = KernelPCA()
'''
__init__函數
def __init__(self, n_components=None, kernel="linear",
gamma=None, degree=3, coef0=1, kernel_params=None,
alpha=1.0, fit_inverse_transform=False, eigen_solver='auto',
tol=0, max_iter=None, remove_zero_eig=False,
random_state=None, copy_X=True, n_jobs=1):
'''
from sklearn.decomposition import FactorAnalysis
fac = FactorAnalysis()
'''
__init__函數
def __init__(self, n_components=None, tol=1e-2, copy=True, max_iter=1000,
noise_variance_init=None, svd_method='randomized',
iterated_power=3, random_state=0):
'''
4.數據預處理
from sklearn.preprocessing import scale
import numpy as np
x = np.array([[1., -1., 2.],
[2., 0., 0.],
[0., 1., -1.]])
# 將每一列特征標准化為標准正太分布，注意，標准化是針對每一列而言的
x_scale = scale(x)
x_scale.mean(axis=0)
x_scale.mean(axis=1)
x_scale.std(axis=0)
'''
preprocessing這個模塊還提供了一個實用類StandarScaler，
它可以在訓練數據集上做了標准轉換操作之后，把相同的轉換應用到測試訓練集中。
'''
from sklearn.preprocessing import StandardScaler
# 調用fit方法，根據已有的訓練數據創建一個標准化的轉換器
scaler = StandardScaler().fit(x)
# 使用上面這個轉換器去轉換訓練數據x,調用transform方法
scaler.transform(x)
# 規模化特征到一定的范圍內
from sklearn.preprocessing import MinMaxScaler
min_max_scaler = MinMaxScaler()
x_minmax = min_max_scaler.fit_transform(x)
# MaxAbsScaler
'''
原理與上面的很像，只是數據會被規模化到[-1,1]之間。
也就是特征中，所有數據都會除以最大值。這個方法對那些已經中心化均值維0或者稀疏的數據有意義。
'''
from sklearn.preprocessing import MaxAbsScaler
max_abs_scaler = MaxAbsScaler()
x_train_maxsbs = max_abs_scaler.fit_transform(x)
# 正則化Normalization
'''
正則化是將樣本在向量空間模型上的一個轉換，經常被使用在分類與聚類中。
函數normalize 提供了一個快速有簡單的方式在一個單向量上來實現這正則化的功能
'''
from sklearn.preprocessing import normalize
x_normalized = normalize(x, norm='l2')
from sklearn.preprocessing import Normalizer
# 根據訓練數據創建一個正則器
normalizer = Normalizer().fit(x)
# 對訓練數據進行正則
normalizer.transform(x)
# 二值化–特征的二值化
from sklearn.preprocessing import Binarizer
binarizer = Binarizer().fit(x)
binarizer.transform(x)