Classificação Semi-Supervisionada de Texto

Introdução

Neste laboratório, aprenderá a realizar classificação semi-supervisionada num conjunto de dados de texto utilizando o scikit-learn. O aprendizado semi-supervisionado é um tipo de aprendizado de máquina onde um modelo é treinado com dados rotulados e não rotulados. Este laboratório abordará como utilizar os algoritmos Self-Training e LabelSpreading para classificação de texto semi-supervisionada. Utilizaremos o conjunto de dados 20 newsgroups para treinar e testar nossos modelos.

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 aguardar alguns segundos para o Jupyter Notebook terminar o carregamento. 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.

Carregar o Conjunto de Dados

Utilizaremos o conjunto de dados 20 newsgroups, que contém cerca de 18.000 mensagens de grupos de notícias sobre 20 tópicos. Nesta etapa, carregaremos o conjunto de dados e imprimiremos algumas informações básicas sobre ele.

import numpy as np
from sklearn.datasets import fetch_20newsgroups

## Carregar o conjunto de dados com as cinco primeiras categorias
data = fetch_20newsgroups(
    subset="train",
    categories=[
        "alt.atheism",
        "comp.graphics",
        "comp.os.ms-windows.misc",
        "comp.sys.ibm.pc.hardware",
        "comp.sys.mac.hardware",
    ],
)

## Imprimir informações sobre o conjunto de dados
print("%d documentos" % len(data.filenames))
print("%d categorias" % len(data.target_names))

Criar o Pipeline para Aprendizagem Supervisionada

Nesta etapa, criaremos um pipeline para aprendizado supervisionado. O pipeline consistirá em um CountVectorizer para converter os dados de texto em uma matriz de contagens de tokens, um TfidfTransformer para aplicar a normalização de frequência de termo-inversa de documento à matriz de contagens e um SGDClassifier para treinar o modelo.

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfTransformer
from sklearn.linear_model import SGDClassifier
from sklearn.pipeline import Pipeline

## Parâmetros para o SGDClassifier
sdg_params = dict(alpha=1e-5, penalty="l2", loss="log_loss")

## Parâmetros para o CountVectorizer
vectorizer_params = dict(ngram_range=(1, 2), min_df=5, max_df=0.8)

## Criar o pipeline
pipeline = Pipeline(
    [
        ("vect", CountVectorizer(**vectorizer_params)),
        ("tfidf", TfidfTransformer()),
        ("clf", SGDClassifier(**sdg_params)),
    ]
)

Treinar e Avaliar o Modelo Supervisionado

Nesta etapa, dividiremos o conjunto de dados em conjuntos de treinamento e teste e, em seguida, treinaremos e avaliaremos o pipeline de modelo supervisionado criado na Etapa 2.

from sklearn.model_selection import train_test_split
from sklearn.metrics import f1_score

## Dividir o conjunto de dados em conjuntos de treinamento e teste
X, y = data.data, data.target
X_train, X_test, y_train, y_test = train_test_split(X, y)

## Treinar e avaliar o pipeline de modelo supervisionado
pipeline.fit(X_train, y_train)
y_pred = pipeline.predict(X_test)
print(
    "Pontuação F1 média no conjunto de teste: %0.3f"
    % f1_score(y_test, y_pred, average="micro")
)

Criar o Pipeline para Autoaprendizagem

Nesta etapa, criaremos um pipeline para aprendizado semi-supervisionado usando Autoaprendizagem (Self-Training). O pipeline será semelhante ao pipeline supervisionado, mas usaremos o SelfTrainingClassifier em vez do SGDClassifier.

from sklearn.semi_supervised import SelfTrainingClassifier

## Criar o pipeline de Autoaprendizagem
st_pipeline = Pipeline(
    [
        ("vect", CountVectorizer(**vectorizer_params)),
        ("tfidf", TfidfTransformer()),
        ("clf", SelfTrainingClassifier(SGDClassifier(**sdg_params), verbose=True)),
    ]
)

Treinar e Avaliar o Modelo de Autoaprendizagem

Nesta etapa, utilizaremos o Autoaprendizagem (Self-Training) em 20% dos dados rotulados. Selecionaremos aleatoriamente 20% dos dados rotulados, treinaremos o modelo com esses dados e, em seguida, usaremos o modelo para prever rótulos para os dados não rotulados restantes.

import numpy as np

## Selecionar 20% dos dados de treinamento
y_mask = np.random.rand(len(y_train)) < 0.2
X_20, y_20 = map(
    list, zip(*((x, y) for x, y, m in zip(X_train, y_train, y_mask) if m))
)

## Definir o subconjunto não mascarado como não rotulado
y_train[~y_mask] = -1

## Treinar e avaliar o pipeline de Autoaprendizagem
st_pipeline.fit(X_train, y_train)
y_pred = st_pipeline.predict(X_test)
print(
    "Pontuação F1 média no conjunto de teste: %0.3f"
    % f1_score(y_test, y_pred, average="micro")
)

Criar o Pipeline para Propagação de Rótulos

Nesta etapa, criaremos um pipeline para aprendizado semi-supervisionado usando a técnica de Propagação de Rótulos (LabelSpreading). O pipeline será semelhante ao pipeline supervisionado, mas usaremos o algoritmo LabelSpreading em vez do SGDClassifier.

from sklearn.semi_supervised import LabelSpreading
from sklearn.preprocessing import FunctionTransformer

## Criar o pipeline de Propagação de Rótulos
ls_pipeline = Pipeline(
    [
        ("vect", CountVectorizer(**vectorizer_params)),
        ("tfidf", TfidfTransformer()),
        ("toarray", FunctionTransformer(lambda x: x.toarray())),
        ("clf", LabelSpreading()),
    ]
)

Treinar e Avaliar o Modelo de Propagação de Rótulos

Nesta etapa, utilizaremos a Propagação de Rótulos (LabelSpreading) em 20% dos dados rotulados. Selecionaremos aleatoriamente 20% dos dados rotulados, treinaremos o modelo com esses dados e, em seguida, usaremos o modelo para prever os rótulos para os dados não rotulados restantes.

## Treinar e avaliar o pipeline de Propagação de Rótulos
ls_pipeline.fit(X_train, y_train)
y_pred = ls_pipeline.predict(X_test)
print(
    "Pontuação F1 média no conjunto de teste: %0.3f"
    % f1_score(y_test, y_pred, average="micro")
)

Resumo

Neste laboratório, aprendemos como realizar classificação semi-supervisionada em um conjunto de dados de texto usando a biblioteca scikit-learn. Utilizamos os algoritmos de Auto-Aprendizagem (Self-Training) e Propagação de Rótulos (LabelSpreading) para treinar e testar nossos modelos. O aprendizado semi-supervisionado pode ser útil quando há uma quantidade limitada de dados rotulados disponíveis, e pode ajudar a melhorar o desempenho de um modelo incorporando dados não rotulados.