ColumnTransformer de Scikit-Learn

Introducción

En este laboratorio, aprenderemos a usar ColumnTransformer de Scikit-Learn en un conjunto de datos que contiene diferentes tipos de características. Esta técnica es útil cuando un conjunto de datos contiene componentes que requieren diferentes flujos de extracción y procesamiento de características.

Consejos sobre la VM

Una vez que se haya iniciado la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de las operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje sus comentarios después de la sesión y lo resolveremos rápidamente para usted.

Skills Graph

Conjunto de datos

Usaremos el conjunto de datos 20 newsgroups, que consta de publicaciones de grupos de noticias sobre 20 temas. El conjunto de datos se divide en subconjuntos de entrenamiento y prueba en función de los mensajes publicados antes y después de una fecha específica. Solo usaremos publicaciones de 2 categorías para acelerar el tiempo de ejecución.

categorias = ["sci.med", "sci.space"]
X_train, y_train = fetch_20newsgroups(
    random_state=1,
    subset="train",
    categorias=categorias,
    remove=("footers", "quotes"),
    return_X_y=True,
)
X_test, y_test = fetch_20newsgroups(
    random_state=1,
    subset="test",
    categorias=categorias,
    remove=("footers", "quotes"),
    return_X_y=True,
)

Creación de transformadores

Crearemos transformadores que extraigan características del conjunto de datos. Definiremos dos funciones que realicen la transformación de los datos y luego usaremos FunctionTransformer de Scikit-Learn para crear los transformadores.

def subject_body_extractor(posts):
    ## construye un arreglo de tipo objeto con dos columnas
    ## primera columna = 'asunto' y segunda columna = 'cuerpo'
    features = np.empty(shape=(len(posts), 2), dtype=object)
    for i, text in enumerate(posts):
        ## variable temporal `_` almacena '\n\n'
        headers, _, body = text.partition("\n\n")
        ## almacena el texto del cuerpo en la segunda columna
        features[i, 1] = body

        prefijo = "Asunto:"
        sub = ""
        ## guarda el texto después de 'Asunto:' en la primera columna
        for linea in headers.split("\n"):
            if linea.startswith(prefijo):
                sub = linea[len(prefijo) :]
                break
        features[i, 0] = sub

    return features

subject_body_transformer = FunctionTransformer(subject_body_extractor)

def text_stats(posts):
    return [{"longitud": len(text), "num_oraciones": text.count(".")} for text in posts]

text_stats_transformer = FunctionTransformer(text_stats)

Pipeline de clasificación

Crearemos una pipeline que extraiga características del conjunto de datos, las combine y entrene un clasificador en el conjunto combinado de características. Usaremos Pipeline y ColumnTransformer de Scikit-Learn para lograr esto.

pipeline = Pipeline(
    [
        ## Extraer asunto y cuerpo
        ("subjectbody", subject_body_transformer),
        ## Usar ColumnTransformer para combinar las características del asunto y el cuerpo
        (
            "union",
            ColumnTransformer(
                [
                    ## bolsa de palabras para el asunto (col 0)
                    ("subject", TfidfVectorizer(min_df=50), 0),
                    ## bolsa de palabras con descomposición para el cuerpo (col 1)
                    (
                        "body_bow",
                        Pipeline(
                            [
                                ("tfidf", TfidfVectorizer()),
                                ("best", TruncatedSVD(n_components=50)),
                            ]
                        ),
                        1,
                    ),
                    ## Pipeline para extraer estadísticas de texto del cuerpo del mensaje
                    (
                        "body_stats",
                        Pipeline(
                            [
                                (
                                    "stats",
                                    text_stats_transformer,
                                ),  ## devuelve una lista de diccionarios
                                (
                                    "vect",
                                    DictVectorizer(),
                                ),  ## lista de diccionarios -> matriz de características
                            ]
                        ),
                        1,
                    ),
                ],
                ## peso sobre las características de ColumnTransformer
                transformer_weights={
                    "subject": 0.8,
                    "body_bow": 0.5,
                    "body_stats": 1.0,
                },
            ),
        ),
        ## Usar un clasificador SVC en las características combinadas
        ("svc", LinearSVC(dual=False)),
    ],
    verbose=True,
)

Entrenamiento y prueba

Ajustaremos nuestra pipeline a los datos de entrenamiento y la usaremos para predecir los temas de X_test. Luego se imprimen las métricas de rendimiento de nuestra pipeline.

pipeline.fit(X_train, y_train)
y_pred = pipeline.predict(X_test)
print("Informe de clasificación:\n\n{}".format(classification_report(y_test, y_pred)))

Resumen

En este laboratorio, aprendimos cómo usar ColumnTransformer de Scikit-Learn en un conjunto de datos que contiene diferentes tipos de características. Creamos transformadores que extrajeron características del conjunto de datos y los usamos para entrenar un clasificador en el conjunto combinado de características. ColumnTransformer nos permitió procesar los diferentes tipos de características en una sola pipeline.