sklearn可实现的函数或者功能可分为如下几个方面

1.分类算法
2.回归算法
3.聚类算法
4.降维算法
5.模型优化
6.文本预处理

其中分类算法和回归算法又叫监督学习，聚类算法和降维算法又叫非监督学习

分类算法

# 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()处理。
'''
 
# 集成算法-AdaBoost
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，学习效率
'''
 
# 集成算法-GBDT（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，定义了树里最多能有多少个终点节点。
'''

回归算法

# 最小二乘回归
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，惩罚系数
'''
 
# 套索回归
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):
'''

聚类算法

# knn算法
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，最近邻搜索算法参数
'''

降维算法

# 主成分分析法
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):
'''

数据预处理

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)

posted @ 2019-08-23 08:56 不夜男人阅读(777) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

不夜男人

sklearn可实现的函数或者功能可分为如下几个方面

1.分类算法2.回归算法3.聚类算法4.降维算法5.模型优化6.文本预处理

其中分类算法和回归算法又叫监督学习，聚类算法和降维算法又叫非监督学习

分类算法

回归算法

聚类算法

降维算法

数据预处理

公告

1.分类算法
2.回归算法
3.聚类算法
4.降维算法
5.模型优化
6.文本预处理