Transformador de Colunas Scikit-Learn

Introdução

Neste laboratório, aprenderemos a utilizar o ColumnTransformer do Scikit-Learn num conjunto de dados que contém diferentes tipos de características. Esta técnica é útil quando um conjunto de dados contém componentes que requerem diferentes pipelines de extração e processamento de características.

Dicas da Máquina Virtual

Após o arranque da máquina virtual, clique no canto superior esquerdo para mudar para a aba Notebook para aceder ao Jupyter Notebook para a prática.

Por vezes, pode ser necessário esperar alguns segundos para o Jupyter Notebook terminar de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se tiver problemas durante o aprendizado, não hesite em contactar o Labby. Forneça feedback após a sessão e resolveremos o problema rapidamente para si.

Conjunto de Dados

Utilizaremos o conjunto de dados 20 newsgroups, que consiste em mensagens de grupos de notícias sobre 20 tópicos. O conjunto de dados é dividido em subconjuntos de treino e teste com base nas mensagens publicadas antes e depois de uma data específica. Utilizaremos apenas mensagens de 2 categorias para acelerar o tempo de execução.

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

Criando Transformadores

Criaremos transformadores que extraem características do conjunto de dados. Definiremos duas funções que realizam a transformação de dados e, em seguida, usaremos o FunctionTransformer do Scikit-Learn para criar os transformadores.

def subject_body_extractor(posts):
    ## constrói um array de tipo objeto com duas colunas
    ## primeira coluna = 'assunto' e segunda coluna = 'corpo'
    features = np.empty(shape=(len(posts), 2), dtype=object)
    for i, text in enumerate(posts):
        ## variável temporária `_` armazena '\n\n'
        headers, _, body = text.partition("\n\n")
        ## armazena o texto do corpo na segunda coluna
        features[i, 1] = body

        prefix = "Subject:"
        sub = ""
        ## salva o texto após 'Subject:' na primeira coluna
        for line in headers.split("\n"):
            if line.startswith(prefix):
                sub = line[len(prefix) :]
                break
        features[i, 0] = sub

    return features

subject_body_transformer = FunctionTransformer(subject_body_extractor)

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

text_stats_transformer = FunctionTransformer(text_stats)

Pipeline de Classificação

Criaremos um pipeline que extrai características do conjunto de dados, as combina e treina um classificador no conjunto combinado de características. Usaremos o Pipeline e o ColumnTransformer do Scikit-Learn para isso.

pipeline = Pipeline(
    [
        ## Extrair assunto e corpo
        ("subjectbody", subject_body_transformer),
        ## Usar ColumnTransformer para combinar as características de assunto e corpo
        (
            "union",
            ColumnTransformer(
                [
                    ## vetorização bag-of-words para o assunto (coluna 0)
                    ("subject", TfidfVectorizer(min_df=50), 0),
                    ## vetorização bag-of-words com decomposição para o corpo (coluna 1)
                    (
                        "body_bow",
                        Pipeline(
                            [
                                ("tfidf", TfidfVectorizer()),
                                ("best", TruncatedSVD(n_components=50)),
                            ]
                        ),
                        1,
                    ),
                    ## Pipeline para extrair estatísticas de texto do corpo da mensagem
                    (
                        "body_stats",
                        Pipeline(
                            [
                                (
                                    "stats",
                                    text_stats_transformer,
                                ),  ## retorna uma lista de dicionários
                                (
                                    "vect",
                                    DictVectorizer(),
                                ),  ## lista de dicionários -> matriz de características
                            ]
                        ),
                        1,
                    ),
                ],
                ## pesos das características do ColumnTransformer
                transformer_weights={
                    "subject": 0.8,
                    "body_bow": 0.5,
                    "body_stats": 1.0,
                },
            ),
        ),
        ## Usar um classificador SVC nas características combinadas
        ("svc", LinearSVC(dual=False)),
    ],
    verbose=True,
)

Treinamento e Teste

Ajustaremos nosso pipeline aos dados de treinamento e o usaremos para prever tópicos para X_test. As métricas de desempenho do nosso pipeline são então impressas.

pipeline.fit(X_train, y_train)
y_pred = pipeline.predict(X_test)
print("Relatório de classificação:\n\n{}".format(classification_report(y_test, y_pred)))

Resumo

Neste laboratório, aprendemos como usar o ColumnTransformer do Scikit-Learn em um conjunto de dados contendo diferentes tipos de recursos. Criamos transformadores que extraíram recursos do conjunto de dados e os usamos para treinar um classificador no conjunto combinado de recursos. O ColumnTransformer permitiu que processássemos os diferentes tipos de recursos em um único pipeline.