sklearn学习笔记3——pipeline

最新推荐文章于 2022-03-04 09:39:06 发布
最新推荐文章于 2022-03-04 09:39:06 发布
阅读量311 收藏 2
点赞数
本文介绍sklearn中Pipeline和FeatureUnion的使用方法，包括串行化数据处理流程及并行化特征处理，展示了如何简化机器学习工作流，提高模型训练效率。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

sklearn学习笔记3——pipeline

2016年12月28日 16:24:16 阅读数：7031

pipeline为方便数据处理，提供了两种模式：串行化和并行化


1.串行化，通过Pipeline类实现

通过steps参数，设定数据处理流程。格式为('key','value')，key是自己为这一step设定的名称，value是对应的处理类。最后通过list将这些step传入。前n-1个step中的类都必须有transform函数，最后一步可有可无，一般最后一步为模型。pipe继承了最后一个类的所有方法。


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     In [
     
     42]: 
     
     from sklearn.pipeline 
     
     import Pipeline
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         ...: 
     
     from sklearn.svm 
     
     import SVC
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         ...: 
     
     from sklearn.decomposition 
     
     import PCA
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         ...: pipe=Pipeline(steps=[(
     
     'pca',PCA()),(
     
     'svc',SVC())])
    
    
    
   
   
  5. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         ...:
    
    
    
   
   
  6. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         ...: 
     
     from sklearn.datasets 
     
     import load_iris
    
    
    
   
   
  7. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         ...: iris=load_iris()
    
    
    
   
   
  8. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         ...: pipe.fit(iris.data,iris.target)
    
    
    
   
   
  9. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         ...:
    
    
    
   
   
  10. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     Out[
     
     42]:
    
    
    
   
   
  11. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     Pipeline(steps=[(
     
     'pca', PCA(copy=
     
     True, iterated_power=
     
     'auto', n_components=
     
     None,
    
    
    
   
   
  12. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
      random_state=
     
     None,
    
    
    
   
   
  13. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
       svd_solver=
     
     'auto', tol=
     
     0.0, whiten=
     
     False)), (
     
     'svc', SVC(C=
     
     1.0, cache_size=
     
     200,
    
    
    
   
   
  14. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
      class_weight=
     
     None, coef0=
     
     0.0,
    
    
    
   
   
  15. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
       decision_function_shape=
     
     None, degree=
     
     3, gamma=
     
     'auto', kernel=
     
     'rbf',
    
    
    
   
   
  16. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
       max_iter=
     
     -1, probability=
     
     False, random_state=
     
     None, shrinking=
     
     True,
    
    
    
   
   
  17. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
       tol=
     
     0.001, verbose=
     
     False))])

训练得到的是一个模型，可直接用来预测，预测时，数据会从step1开始进行转换，避免了模型用来预测的数据还要额外写代码实现。还可通过pipe.score(X,Y)得到这个模型在X训练集上的正确率。 



 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     In [
     
     46]: pipe.predict(iris.data)
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     Out[
     
     46]:
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     array([
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0,
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
           
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0,
    
    
    
   
   
  5. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
           
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1,
    
    
    
   
   
  6. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
           
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     2, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     2, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1,
    
    
    
   
   
  7. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
           
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2,
    
    
    
   
   
  8. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
           
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2,
    
    
    
   
   
  9. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
           
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2])
    
    
    
   
   
  10. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  11. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     In [
     
     47]: iris.target
    
    
    
   
   
  12. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     Out[
     
     47]:
    
    
    
   
   
  13. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     array([
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0,
    
    
    
   
   
  14. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
           
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     0,
    
    
    
   
   
  15. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
           
     
     0, 
     
     0, 
     
     0, 
     
     0, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1,
    
    
    
   
   
  16. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
           
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1,
    
    
    
   
   
  17. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
           
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     1, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2,
    
    
    
   
   
  18. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
           
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2,
    
    
    
   
   
  19. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
           
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2, 
     
     2])
make_pipeline函数是Pipeline类的简单实现，只需传入每个step的类实例即可，不需自己命名，自动将类的小写设为该step的名。 


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     In [
     
     50]: make_pipeline(StandardScaler(),GaussianNB())
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     Out[
     
     50]: Pipeline(steps=[(
     
     'standardscaler', StandardScaler(copy=
     
     True, with_mean=
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     True, with_std=
     
     True)), (
     
     'gaussiannb', GaussianNB(priors=
     
     None))])
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  5. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     In [
     
     51]: p=make_pipeline(StandardScaler(),GaussianNB())
    
    
    
   
   
  6. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  7. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     In [
     
     52]: p.steps
    
    
    
   
   
  8. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     Out[
     
     52]:
    
    
    
   
   
  9. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     [(
     
     'standardscaler', StandardScaler(copy=
     
     True, with_mean=
     
     True, with_std=
     
     True)),
    
    
    
   
   
  10. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
      (
     
     'gaussiannb', GaussianNB(priors=
     
     None))]

同时可以通过set_params重新设置每个类里边需传入的参数，设置方法为step的name__parma名=参数值 


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     In [
     
     59]: p.set_params(standardscaler__with_mean=
     
     False)
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     Out[
     
     59]: Pipeline(steps=[(
     
     'standardscaler', StandardScaler(copy=
     
     True, with_mean=
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     False, with_std=
     
     True)), (
     
     'gaussiannb', GaussianNB(priors=
     
     None))])

2.并行化，通过FeatureUnion实现
FeatureUnion，同样通过(key，value)对来设置，通过set_params设置参数。不同的是，每一个step分开计算，FeatureUnion最后将它们计算得到的结果合并到一块，返回的是一个数组，不具备最后一个estimator的方法。有些数据需要标准化，或者取对数，或onehot编码最后形成多个特征项，再选择重要特征，这时候FeatureUnion非常管用。 



 
 
In [60]: from sklearn.pipeline import FeatureUnion
  
  

 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     In [
     
     61]: 
     
     from sklearn.preprocessing 
     
     import StandardScaler
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     In [
     
     63]: 
     
     from sklearn.preprocessing 
     
     import FunctionTransformer
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     In [
     
     64]: 
     
     from numpy 
     
     import log1p
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  5. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     In [
     
     65]: step1=(
     
     'Standar',StandardScaler())
    
    
    
   
   
  6. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     In [
     
     66]: step2=(
     
     'ToLog',FunctionTransformer(log1p))
    
    
    
   
   
  7. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     In [
     
     67]: steps=FeatureUnion(transformer_list=[step1,step2])
    
    
    
   
   
  8. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  9. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     In [
     
     68]: steps.fit_transform(iris.data)
    
    
    
   
   
  10. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     Out[
     
     68]:
    
    
    
   
   
  11. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     array([[
     
     -0.90068117,  
     
     1.03205722, 
     
     -1.3412724 , ...,  
     
     1.5040774 ,
    
    
    
   
   
  12. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
             
     
     0.87546874,  
     
     0.18232156],
    
    
    
   
   
  13. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
            [
     
     -1.14301691, 
     
     -0.1249576 , 
     
     -1.3412724 , ...,  
     
     1.38629436,
    
    
    
   
   
  14. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
             
     
     0.87546874,  
     
     0.18232156],
    
    
    
   
   
  15. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
            [
     
     -1.38535265,  
     
     0.33784833, 
     
     -1.39813811, ...,  
     
     1.43508453,
    
    
    
   
   
  16. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
             
     
     0.83290912,  
     
     0.18232156],
    
    
    
   
   
  17. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
            ...,
    
    
    
   
   
  18. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
            [ 
     
     0.79566902, 
     
     -0.1249576 ,  
     
     0.81962435, ...,  
     
     1.38629436,
    
    
    
   
   
  19. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
             
     
     1.82454929,  
     
     1.09861229],
    
    
    
   
   
  20. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
            [ 
     
     0.4321654 ,  
     
     0.80065426,  
     
     0.93335575, ...,  
     
     1.48160454,
    
    
    
   
   
  21. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
             
     
     1.85629799,  
     
     1.19392247],
    
    
    
   
   
  22. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
            [ 
     
     0.06866179, 
     
     -0.1249576 ,  
     
     0.76275864, ...,  
     
     1.38629436,
    
    
    
   
   
  23. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
             
     
     1.80828877,  
     
     1.02961942]])
    
    
    
   
   
  24. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  25. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     In [
     
     69]: data=steps.fit_transform(iris.data)
    
    
    
   
   
  26. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  27. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     In [
     
     70]: data.shape  
     
     #最后有8个特征，标准化后4个，log后4个，共个
    
    
    
   
   
  28. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     Out[
     
     70]: (
     
     150, 
     
     8)
    
    
    
   
   
  29. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  30. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     In [
     
     71]: iris.data.shape
    
    
    
   
   
  31. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     Out[
     
     71]: (
     
     150, 
     
     4)
    
    
    
   
   

 
 

 

 

 

 


 参考：
 

http://scikit-learn.org/stable/modules/pipeline.html
 


                

                
                
        

    

  



    

      

        

            

              
                
                  Ivan王12138
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
sklearn.pipeline.Pipeline()

				
			

			

				

					xiaohutong1991的专栏
				

				

					08-11
					
					2402
					
				

			

		

		

			
				
方法


			
		

	



                

            
              



	

		

			

				
					
机器学习笔记（六）——机器学习概念：多项式回归与pipeline、偏差和方差、L1正则与L2正则

				
			

			

				

					weixin_43312354的博客
				

				

					04-05
					
					1078
					
				

			

		

		

			
				
一、多项式回归与sklearn中的Pipeline
之前已经学习了简单线性回归，其输入特征值有一维，即y=θ0+θ1x1;y=\theta_0+\theta_1x_1;y=θ0​+θ1​x1​;当推广到多维特征，即多元线性回归：y=θ0+θ1x1+θ2x2+…+θnxn。y=\theta_0+\theta_1x_1+\theta_2x_2+…+\theta_nx_n。y=θ0​+θ1​x1​+θ2...

			
		

	



              


  
              

                


	

		

			

				
					
sklearn.pipeline.Pipeline类的用法

					
热门推荐

				
			

			

				

					XXiaoLEI的专栏
				

				

					11-02
					
					1万+
					
				

			

		

		

			
				
这一篇我会总结sklearn.pipeline.Pipeline。
１、sklearn.pipeline.Pipeline类
先给出官方的文档链接：http://scikit-learn.org/stable/modules/generated/sklearn.pipeline.Pipeline.html


class sklearn.pipeline.Pipeline(steps)

			
		

	





	

		

			

				
					
sklearn中的pipeline.Pipeline以及preprocessing.Polynomialfeatures的解释与应用

				
			

			

				

					weixin_42542536的博客
				

				

					05-18
					
					1171
					
				

			

		

		

			
				
pipeline.Pipeline

sklearn pipeline的使用

（1）简介
当我们对训练集应用各种预处理操作时（特征标准化、主成分分析等等），
我们都需要对测试集重复利用这些参数。
pipeline 实现了对全部步骤的流式化封装和管理，可以很方便地使参数集在新数据集上被重复使用。
pipeline 可以用于下面几处：
模块化 Feature Transform，只需写很少的代码就能...

			
		

	



		

			
		



	

		

			

				
					
sklearn之pipeline：pipeline函数/make_pipeline函数的简介及其区别联系、使用技巧、案例应用之详细攻略

				
			

			

				

					头部AI社区如有邀博主AI主题演讲请私信—心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，专注，谦虚，自律，反思，成长，还算比较正能量的博主，公益免费传播…内心特别想在AI界做出一些可以推进历史进程影响力的技术(兴趣使然，有点小情怀，也有点使命感呀
				

				

					08-28
					
					1万+
					
				

			

		

		

			
				
​
sklearn之pipeline：pipeline函数/make_pipeline函数的简介及其区别联系、使用技巧、案例应用之详细攻略

目录

sklearn.pipeline函数简介






pipeline的案例应用







sklearn.pipeline函数简介
     转换器Transformers 通常与分类器、回归器或其他估计器相结合，构成一个复合估计器。最常见的工具是pipeline。pipeline通常与特征结合使用，特征结合将变压器的输出连接到一个复合特征空间

			
		

	





	

		

			

				
					
sklearn中pipeline机制

				
			

			

				

					weixin_41512727的博客
				

				

					08-01
					
					818
					
				

			

		

		

			
				

from sklearn import Pipeline

管道机制在机器学习算法中得以应用的根源在于，参数集在新数据集（比如测试集）上的重复使用。

管道机制实现了对全部步骤的流式化封装和管理（streaming workflows with pipelines）。

注意：管道机制更像是编程技巧的创新，而非算法的创新。

 

待写。。。

 

参考：https://blog.csdn.n...

			
		

	





	

		

			

				
					
Jupyter notebook学习笔记——线性回归、多项式回归

				
			

			

				

					Wlis的博客
				

				

					01-04
					
					6108
					
				

			

		

		

			
				
import numpy as np
X=2*np.random.rand(100,1)
y=4+3*X+np.random.randn(100,1)
from sklearn.linear_model import LinearRegression
lin_reg=LinearRegression()
lin_reg.fit(X,y)

LinearRegression(copy_X=True,...

			
		

	





	

		

			

				
					
Scikit-Learn学习笔记——特征工程

				
			

			

				

					Little Garden
				

				

					08-20
					
					398
					
				

			

		

		

			
				
特征工程


  工程中的数据挖掘用到的数据很少拥有干净的特征矩阵——很多特征的取值是非数值的，这些特征不能直接被计算机直接用于计算。因此，机器学习实践中更重要的步骤之一是特征工程——找到与问题有关的任何信息，把它们转换成特征矩阵的数值。




分类特征


  一种常见的非数值特征是分类数据。例如，浏览房屋数据的时候，除了看到“房价”（price）和“面积”（square）之类的数值特征，还会...

			
		

	





	

		

			

				
					
Scikit-Learn学习笔记——模型验证与超参数网格搜索

				
			

			

				

					Little Garden
				

				

					08-20
					
					1562
					
				

			

		

		

			
				
超参数与模型验证


  模型验证就是在选择模型和超参数之后，通过对训练数据进行学习，对比模型对已知数据的预测值与实际值的差异。模型验证的正确方法是使用留出集评估模型性能，即先从训练模型中的数据中留出一部分，然后用这部分留出来的数据检验模型性能。
  
  但是，使用留出集使得模型失去了一部分训练机会，解决这个问题的方法是交叉验证,也就是做一组拟合，让数据的每个子集既是训练集，又是验证集。



...

			
		

	





	

		

			

				
					
Scikit-Learn学习笔记——SVM应用：人脸识别

				
			

			

				

					Little Garden
				

				

					08-21
					
					6857
					
				

			

		

		

			
				
SVM应用——人脸识别



#下载数据
from sklearn.datasets import fetch_lfw_people
faces = fetch_lfw_people(min_faces_per_person=60)
print(faces.target_names)
print(faces.images.shape)

#输出结果
['Ariel Sharon' 'Colin P...

			
		

	





	

		

			

				
					
sklearn Pipeline 函数用法

				
			

			

				

					qq_39758080的博客
				

				

					03-04
					
					2290
					
				

			

		

		

			
				
Sklearn Pipeline

			
		

	





	

		

			

				
					
sklearn Pipeline使用

				
			

			

				

					搬砖小工053
				

				

					07-31
					
					1万+
					
				

			

		

		

			
				
简介Pipeline按顺序构建一系列转换和一个模型，最后的一步是模型。Pipeline中间的步骤必须是转换过程，它们必须包含fit和transform方法。最后一步模型只要有fit方法。Pipeline的目的是能组合好几个步骤，当设置不同参数的时候，可以在一起做交叉验证。可以通过【pipeline的名称+ “_” + 参数名称】的方式设置多个步骤的参数。参数
  名称
  类型
  说明  step

			
		

	





	

		

			

				
					
jenkins pipeline step同时执行

				
			

			

				

					s7799653的博客
				

				

					10-27
					
					990
					
				

			

		

		

			
				
//语法
parallel 'branch 1':{},'branch 2':{}
//例如
            stage('scaner,build and deploy'){
                /*
                parallel 'branch 1':{},&#...

			
		

	





	

		

			

				
					
Devops之jenkins之pipeline初探

				
			

			

				

					blissnmx的博客
				

				

					01-07
					
					897
					
				

			

		

		

			
				
jenkins最佳实践之pipeline入门

			
		

	





	

		

			

				
					
《Python机器学习基础教程》构建管道(make_pipeline)

				
			

			

				

					elma_tww的博客
				

				

					03-12
					
					1万+
					
				

			

		

		

			
				
《Python机器学习基础教程》笔记

    大多数机器学习应用不仅需要应用单个算法，而且还需要将许多不同的处理步骤和机器学习模型链接在一起，例如对数据进行缩放，然后手动合并特征，再利用无监督学习来学习特征。为了简化构建变换和模型链的过程，Scikit-Learn提供了pipeline类，可以将多个处理步骤合并为单个Scikit-Learn估计器。pipeline类本身具有fit、pre...

			
		

	





	

		

			

				
					
学习笔记：Sklearn中Pipeline的使用

				
			

			

				

					qq_41598851的博客
				

				

					07-08
					
					1万+
					
				

			

		

		

			
				
学习笔记：通过学习很多大佬的博客然后综合总结，有些用的是大佬的原代码加上自己的理解1.Pipeline的作用：        Pipeline可以将许多算法模型串联起来，可以用于把多个estamitors级联成一个estamitor,比如将特征提取、归一化、分类组织在一起形成一个典型的机器学习问题工作流。Pipleline中最后一个之外的所有estimators都必须是变换器（transforme...

			
		

	





	

		

			

				
					
Pipeline学习器流水线

				
			

			

				

					cicilover的专栏
				

				

					09-10
					
					5972
					
				

			

		

		

			
				
sklearn提供了Pipeline将多个学习器组成流水线。通常，流水线的形式为：将数据标准化的学习器-->特征提取的学习器-->执行预测的学习器。除了最后一个学习器之外，之前的所有学习器必须提供tranform方法，该方法用于数据变换（如归一化，正则化，以及特征提取等）。
Pipeline的原型为：
class sklearn.pipeline.Pipeline(steps)


参数

			
		

	





	

		

			

				
					
from sklearn.pipeline import make_pipeline

					
最新发布

				
			

			

				

					09-16
				

			

		

		

			
				
`from sklearn.pipeline import make_pipeline` 是 scikit-learn 库中的一个功能，用于创建机器学习管道（Pipeline）。sklearn 的 Pipeline 是一种组织多个数据转换和模型训练步骤的方法，这些步骤按照一定的顺序组合在一起形成一个单一的对象。这个工具在数据预处理（例如特征缩放、编码）和模型训练过程中非常有用，因为它能够确保每个步骤都在同一个上下文中进行，同时也可以方便地调整或保存整个分析过程。

具体来说，`make_pipeline` 函数接受一系列 `transformers` 和 `estimator` 对象，其中 transformers 是用于数据转换的预处理步骤，而 estimator 是最终的模型。函数返回的是一个 Pipeline 实例，可以通过 `.fit()` 和 `.predict()` 方法对整个流水线进行训练和预测操作。

举个例子：

```python
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression

# 创建一个包含标准化和逻辑回归的管道
pipe = make_pipeline(StandardScaler(), LogisticRegression())

# 使用训练数据拟合模型
pipe.fit(X_train, y_train)

# 预测新数据
predictions = pipe.predict(X_test)
```

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值