google traduit http://scikit-learn.org/0.18/modules/pipeline.html [scikit-learn 0.18 User Guide 4. Dataset Conversion](http://qiita.com/nazoking@github/items/267f2371757516f8c168#4-%E3%83%87%E3%83%BC%E3%82%BF % E3% 82% BB% E3% 83% 83% E3% 83% 88% E5% A4% 89% E6% 8F% 9B)

4.1. Union des pipelines et des caractéristiques: combinaison d'estimateur

4.1.1. Pipeline: estimation en chaîne

Pipeline (http://scikit-learn.org/0.18/modules/generated/sklearn.pipeline.Pipeline.html#sklearn.pipeline.Pipeline) vous permet de combiner plusieurs estimateurs en un seul. Je peux le faire. C'est pratique car les étapes de traitement des données, telles que la sélection des caractéristiques, la normalisation et la classification, sont souvent fixes. Le pipeline sert ici deux objectifs.

** Commodité **: Pour ajuster la séquence entière des estimateurs, il suffit d'appeler «fit» et de «prédire» les données une fois.
** Sélection conjointe des paramètres **: Recherchez dans la grille tous les paramètres d'estimateur dans le pipeline à la fois (http://scikit-learn.org/0.18/modules/grid_search.html#grid-search )Je peux le faire.

Tous les estimateurs du pipeline à l'exception du dernier pipeline doivent être des transformateurs (nécessite la méthode transform). L'estimateur final peut être de tout type (convertisseur, classifieur, etc.).

4.1.1.1. Utilisation

Le pipeline est créé à l'aide d'une liste de paires (clé, valeur). key est la chaîne de nom pour cette étape et value est l'instance d'estimateur.

>>> from sklearn.pipeline import Pipeline
>>> from sklearn.svm import SVC
>>> from sklearn.decomposition import PCA
>>> estimators = [('reduce_dim', PCA()), ('clf', SVC())]
>>> pipe = Pipeline(estimators)
>>> pipe 
Pipeline(steps=[('reduce_dim', PCA(copy=True, iterated_power='auto',
n_components=None, random_state=None, svd_solver='auto', tol=0.0,
whiten=False)), ('clf', SVC(C=1.0, cache_size=200, class_weight=None,
coef0=0.0, decision_function_shape=None, degree=3, gamma='auto',
kernel='rbf', max_iter=-1, probability=False, random_state=None,
shrinking=True, tol=0.001, verbose=False))])

La fonction utilitaire make_pipeline est une abréviation pour construire un pipeline. Renvoie un pipeline avec plusieurs estimateurs comme arguments. Le nom est décidé automatiquement:

>>> from sklearn.pipeline import make_pipeline
>>> from sklearn.naive_bayes import MultinomialNB
>>> from sklearn.preprocessing import Binarizer
>>> make_pipeline(Binarizer(), MultinomialNB()) 
Pipeline(steps=[('binarizer', Binarizer(copy=True, threshold=0.0)),
                ('multinomialnb', MultinomialNB(alpha=1.0,
                                                class_prior=None,
                                                fit_prior=True))])

Les estimateurs du pipeline sont stockés sous forme de liste dans l'attribut steps.

>>> pipe.steps[0]
('reduce_dim', PCA(copy=True, iterated_power='auto', n_components=None, random_state=None,
  svd_solver='auto', tol=0.0, whiten=False))

Aussi comme dict to named_steps:

>>> pipe.named_steps['reduce_dim']
PCA(copy=True, iterated_power='auto', n_components=None, random_state=None,
  svd_solver='auto', tol=0.0, whiten=False)

Les paramètres estimés dans le pipeline sont accessibles à l'aide de la syntaxe <estimator> __ <parameter>.

>>> pipe.set_params(clf__C=10) 
Pipeline(steps=[('reduce_dim', PCA(copy=True, iterated_power='auto',
    n_components=None, random_state=None, svd_solver='auto', tol=0.0,
    whiten=False)), ('clf', SVC(C=10, cache_size=200, class_weight=None,
    coef0=0.0, decision_function_shape=None, degree=3, gamma='auto',
    kernel='rbf', max_iter=-1, probability=False, random_state=None,
    shrinking=True, tol=0.001, verbose=False))])

Ceci est particulièrement important lors des recherches de grille.

>>> from sklearn.model_selection import GridSearchCV
>>> params = dict(reduce_dim__n_components=[2, 5, 10],
...               clf__C=[0.1, 10, 100])
>>> grid_search = GridSearchCV(pipe, param_grid=params)

Les étapes individuelles sont également remplacées en tant que paramètres, les étapes non finales sont ignorées et définies sur "Aucune".

>>>
>>> from sklearn.linear_model import LogisticRegression
>>> params = dict(reduce_dim=[None, PCA(5), PCA(10)],
...               clf=[SVC(), LogisticRegression()],
...               clf__C=[0.1, 10, 100])
>>> grid_search = GridSearchCV(pipe, param_grid=params)

--Exemple:

Pipeline ANOVA SVM
[Exemple de pipeline pour l'extraction et l'évaluation des fonctionnalités de texte](http://scikit-learn.org/0.18/auto_examples/model_selection/grid_search_text_feature_extraction.html#sphx-glr-auto-examples-model-selection-grid- search-text-feature-extraction-py)
Pipelining: Chain of PCA and Logistic Recursion
Approximation explicite de la carte des caractéristiques du noyau RBF
[SVM-Anova: SVM avec sélection de fonctionnalités univariée](http://scikit-learn.org/0.18/auto_examples/svm/plot_svm_anova.html#sphx-glr-auto-examples-svm-plot-svm-anova -py) --Référence:
Réglage des hyper paramètres de l'estimateur

4.1.1.2. Remarques

Appeler fit sur le pipeline revient à appeler fit à chaque estimateur tour à tour, en transformant l'entrée et en la passant à l'étape suivante. Le pipeline contient toutes les méthodes du dernier estimateur du pipeline. Autrement dit, si le dernier estimateur est un classificateur, le pipeline peut être utilisé comme classificateur. Si le dernier estimateur est un convertisseur, le pipeline l'est aussi.

4.1.2. FeatureUnion: espace d'entités composites

FeatureUnion combine plusieurs objets convertisseur avec leur sortie. Combinez avec un nouveau convertisseur. FeatureUnion prend une liste d'objets convertisseur. Lors de l'ajustement, chacun de ces ajustements aux données individuellement. Pour transformer les données, les transformations sont appliquées en parallèle et les vecteurs d'échantillons qu'elles produisent sont concaténés de bout en bout en grands vecteurs. FeatureUnion a le même objectif que la commodité du pipeline et l'estimation et la validation des paramètres communs. Vous pouvez combiner Feature Union et pipelines pour créer des modèles complexes. (FeatureUnion n'a aucun moyen de vérifier si deux transformations produisent la même fonctionnalité, seulement si les ensembles de fonctionnalités sont disjoints, cela ne générera qu'une union et s'assurera que c'est la responsabilité de l'appelant).

4.1.2.1. Utilisation

FeatureUnions sont construits à l'aide d'une liste de paires (clé, valeur). Où clé est le nom que vous donnez à la conversion (cela ne fonctionne que comme une chaîne arbitraire, un identificateur). «value» est un objet estimateur.

>>> from sklearn.pipeline import FeatureUnion
>>> from sklearn.decomposition import PCA
>>> from sklearn.decomposition import KernelPCA
>>> estimators = [('linear_pca', PCA()), ('kernel_pca', KernelPCA())]
>>> combined = FeatureUnion(estimators)
>>> combined 
FeatureUnion(n_jobs=1, transformer_list=[('linear_pca', PCA(copy=True,
    iterated_power='auto', n_components=None, random_state=None,
    svd_solver='auto', tol=0.0, whiten=False)), ('kernel_pca',
    KernelPCA(alpha=1.0, coef0=1, copy_X=True, degree=3,
    eigen_solver='auto', fit_inverse_transform=False, gamma=None,
    kernel='linear', kernel_params=None, max_iter=None, n_components=None,
    n_jobs=1, random_state=None, remove_zero_eig=False, tol=0))],
    transformer_weights=None)

Comme les pipelines, les unions de fonctionnalités ne nécessitent pas de dénomination explicite des composants, [make_union](http://scikit-learn.org/0.18/modules/generated/sklearn.pipeline.make_union.html#sklearn Il existe un constructeur concis appelé .pipeline.make_union).

>>> combined.set_params(kernel_pca=None) 
FeatureUnion(n_jobs=1, transformer_list=[('linear_pca', PCA(copy=True,
      iterated_power='auto', n_components=None, random_state=None,
      svd_solver='auto', tol=0.0, whiten=False)), ('kernel_pca', None)],
    transformer_weights=None)

Comme pour le pipeline, les étapes individuelles sont remplacées à l'aide de set_params et sont ignorées lorsqu'elles sont définies sur None.