현재 우리는 이미 예처리와 예처리 과정을 완성했고 자동적으로 모델을 생성하는 과정을 완성했다.

Nota: Por lo que entiendo, en español se le llama tubería, pero como no me siento cómodo hablando de plomería, la llamaré con su nombre en ingles; pipeline.

Ahora sin más,comenzemos:
Lo primero es importar el objetopipeline de Scikit 학습:

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import MinMaxScaler
from sklearn.svm import SVC

pipe = Pipeline([('scaler', MinMaxScaler()), ('svm', SVC())])

Aquihemos creado dos pasos:el primero,llamado“scaler”,es una instancia deMinMaxScaler,y el segundo,llamado“svm”,es una instancia deSVC.Ahora,podemos Enternar nuestra pipeline,como cualquier otro estimador de Scikit Learn:

pipe.fit(X_train, y_train)

Usando pipelines con 메쉬 검색

Primero, creamos una grilla de par á metros(매개 변수 격자):

param_grid = {'svm__C': [0.001, 0.01, 0.1, 1, 10, 100],
              'svm__gamma': [0.001, 0.01, 0.1, 1, 10, 100]}

Con esta grilla,usamosGridSearchCVcomo siempre:

grid = GridSearchCV(pipe, param_grid=param_grid, cv=5) # we call the pipeline as an attribute
grid.fit(X_train, y_train)
print("Best cross-validation accuracy: {:.2f}".format(grid.best_score_))
print("Test set score: {:.2f}".format(grid.score(X_test, y_test)))
print("Best parameters: {}".format(grid.best_params_))

Código completo en este link.

Una mejor froma de hacer 파이프

Usandomake_pipeline de Scikit Learn, es mucho m á s sencillo crear una 파이프:

from sklearn.pipeline import make_pipeline
# sintaxis estandar
pipe_long = Pipeline([("scaler", MinMaxScaler()), ("svm", SVC(C=100))])
# sintaxis abreviada
pipe_short = make_pipeline(MinMaxScaler(), SVC(C=100))

Accediendo a los atributos de los pasos 회사

En algún momento querrás inspeccionar los atributos de uno de los pasos de la pipeline.Por Ejempo,los coeficients de un modelo lineal o los components extraidos Por PCA(주성분 분석).La forma mas facil de accepter a estos pasos en una pipeline es a través del atributonamed_steps,que es un diccionario con los nombres de los atributos como estimadores:

from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA

pipe = make_pipeline(StandardScaler(), PCA(n_components=2), StandardScaler())
print("Pipeline steps:\n{}".format(pipe.steps))

pipe.fit(cancer.data)
# extrae los primeros dos componentes principales del paso de "pca"
components = pipe.named_steps['pca'].components_

print("components.shape: {}".format(components.shape))

Accediendo a atributos en una pipeline con Grid 검색

Vamos a realizar una grid search en un clasificador de regresión lineal,usando una pipeline y unStandardScalerpara escalar los datos antes de pasarlos al clasificador.

from sklearn.linear_model import LogisticRegression

pipe = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000))

El parametro de la regularización para ajustar en regresión logistica es El parámetroc:

param_grid = {'logisticregression__C': [0.01, 0.1, 1, 10, 100]}

Recuerda: La sintaxis para definir una cuadrícula de parámetros para una pipeline es especificar para cada parámetro el nombre del paso, seguido por __ (doble guion bajo), seguido por el nombre del parámetro. Por ejemplo, para acceder al parámetro gamma de un modelo svm, llamamos a svm__gamma, para el parametro C de un modelo LogisticRegression, llamamos a logisticregression__C.

Divide el dataset y entrena el modelo:

X_train, X_test, y_train, y_test = train_test_split(cancer.data, cancer.target, random_state=4)

grid = GridSearchCV(pipe, param_grid, cv=5)
grid.fit(X_train, y_train)

?Asíque cómo accessimos a los coeficientes del mejor modelo de regresión logistica que fue encontrado porGridSearchCV?

print('Best estimator:\n{}'.format(grid.best_estimator_))

En este caso,elbest_estimator_es una pipeline con dos pasos,StandardScaleryLogisticRegression.Para accepter al pasoLogisticRegression,podemos usar el atributonamed_stepsde la pipeline:

print("Logistic regression step:\n".format(grid.best_estimator_.named_steps['logisticregression']))

Ahora que ya tenemos la regresión logística entrenada,podemos accepter a los coeficientes asociados a cada atributo de entrada:

print("Logistic regression coefficients:\n{}".format(grid.best_estimator_.named_steps['logisticregression'].coef_)) 

Link a GitHub

Obteniendo pasos de pre procesamiento con Grid 검색

Usando 파이프, podemos 봉인 todos los pasos de pre procesamiento en nuestro proceso de aprendizaje autom ático es un solo estimador de Scikit Learn.Otro beneficio de hacer esto es que podemos ajustar los parámetros del pre procesamiento usando el resultado de una tarea supervisoriada como regresión o clasificación.

from sklearn.datasets import load_boston
boston = load_boston()
from sklearn.linear_model import Ridge

X_train, X_test, y_train, y_test = train_test_split(
    boston.data, boston.target, random_state=0)

from sklearn.preprocessing import PolynomialFeatures
pipe = make_pipeline(StandardScaler(), PolynomialFeatures(), Ridge())

?Cómo sabemos que grados de polinomios elegir,o si elegir polinomios o interaciones?Idealmente,queremos Selecciator el pará metro de grado en función del resultado de la clasificación. Usando nuestra 파이프,podemos buscar sobre el pará metro de grado junto con el pará metro alpha Ridge.
Para hacer esto,definimos unaparam_gridque contiene ambos,pre fijados apropiadamente por el nombre de los pasos:

param_grid = {'polynomialfeatures__degree': [1, 2, 3],
              'ridge__alpha': [0.001, 0.01, 0.1, 1, 10, 100]}

Ahora podemos correr de nuevo la grilla de parametros:

grid = GridSearchCV(pipe, param_grid=param_grid, cv=5, n_jobs=-1)
grid.fit(X_train, y_train)

Ahora podemos visualizar los resultados de la validacion cruzada(교차 검증) usando un 열도:

plt.matshow(grid.cv_results_['mean_test_score'].reshape(3, -1),
            vmin=0, cmap='viridis')
plt.xlabel("ridge__alpha")
plt.ylabel("polynomialfeatures__degree")
plt.xticks(range(len(param_grid['ridge__alpha'])), param_grid['ridge__alpha'])
plt.yticks(range(len(param_grid['polynomialfeatures__degree'])),
           param_grid['polynomialfeatures__degree'])
plt.colorbar()

Usando 격자 검색 para saberque modelo usar

Aquidejo un ejemplo comparando unRandomForestClassifiery unSVC.Sabemos que elSVCQuikeás necesite datos escalados,asíque tambien buscamos sobre usarStandardScalero no pre procesar los datos.elRandomForestClassifier단으로 미리 처리할 필요가 없습니다.
Comenzamos definiendo la 파이프.아규, nombramos los pasos explicitamente.Queremos dos pasos,uno de pre procesamiento y despues el clasificador.Podemos instanciar esto usandoSVCyStandardScaler:

pipe = Pipeline([('preprocessing', StandardScaler()), ('classifier', SVC())])

아호라 보드모스는 파라 지하철역의 실현 방식을 정의했다.Queremos que el clasificador sea unRandomForestClassifieroSVC.Como tienen differentes parámetros a ajustar,y necesitan differentes pre procesamientos,podemos hacer una lista de grillas de búsqueda:

from sklearn.ensemble import RandomForestClassifier

param_grid = [
              {'classifier': [SVC()], 'preprocessing': [StandardScaler(), None],
               'classifier__gamma': [0.001, 0.01, 0.1, 1, 10, 100],
               'classifier__C': [0.001, 0.01, 0.1, 1, 10, 100]},
              {'classifier': [RandomForestClassifier (n_estimators=100)],
               'preprocessing': [None], 'classifier__max_features': [1, 2, 3]}]

Ahora instanciamos y corremos la grilla como siempre:

X_train, X_test, y_train, y_test = train_test_split(
    cancer.data, cancer.target, random_state=0)

grid = GridSearchCV(pipe, param_grid, cv=5)
grid.fit(X_train, y_train)

print("Best params:\n{}\n".format(grid.best_params_))
print("Best cross-validation score: {:.2f}".format(grid.best_score_))
print("Test-set score: {:.2f}".format(grid.score(X_test, y_test)))

Y de esta sencilla manera,obtenemos el mejor modelo con sus mejores parámetros incluidos.

결론

Crear Pipeline es una gran manera de ahorrar mucho tiempo en nuestros proyectos.Espero que este articulo les haya servido,y si llegaste hasta aqueí,muchas gracias."행운을 빌어요!