Plotagem da Função de Decisão de Conjuntos de Dados Ponderados

Introdução

Neste tutorial, aprenderemos a traçar uma função de decisão de um conjunto de dados ponderado usando o scikit-learn. Também aprenderemos a atribuir diferentes pesos às amostras no conjunto de dados para mostrar como os pesos afetam a função de decisão.

Dicas da Máquina Virtual

Após o arranque da VM, clique no canto superior esquerdo para mudar para a aba Notebook para aceder ao Jupyter Notebook para praticar.

Por vezes, pode ser necessário esperar 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.

Importação de Bibliotecas Necessárias

Começamos importando as bibliotecas necessárias para o nosso projeto.

import numpy as np
import matplotlib.pyplot as plt
from sklearn import linear_model

Criar um Conjunto de Dados Ponderado

Criamos um conjunto de dados ponderado utilizando a biblioteca numpy. Geramos 20 pontos com valores aleatórios e atribuímos um peso maior às últimas 10 amostras.

np.random.seed(0)
X = np.r_[np.random.randn(10, 2) + [1, 1], np.random.randn(10, 2)]
y = [1] * 10 + [-1] * 10
sample_weight = 100 * np.abs(np.random.randn(20))
sample_weight[:10] *= 10

Plotar o Conjunto de Dados Ponderado

Plotamos o conjunto de dados ponderado utilizando a biblioteca matplotlib. O tamanho dos pontos é proporcional ao seu peso.

xx, yy = np.meshgrid(np.linspace(-4, 5, 500), np.linspace(-4, 5, 500))
fig, ax = plt.subplots()
ax.scatter(
    X[:, 0],
    X[:, 1],
    c=y,
    s=sample_weight,
    alpha=0.9,
    cmap=plt.cm.bone,
    edgecolor="black",
)

Ajustar o Modelo Sem Pesos

Ajustamos um modelo sem pesos utilizando o algoritmo SGDClassifier da biblioteca scikit-learn. Em seguida, plotamos a função de decisão do modelo sem pesos.

clf = linear_model.SGDClassifier(alpha=0.01, max_iter=100)
clf.fit(X, y)
Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
no_weights = ax.contour(xx, yy, Z, levels=[0], linestyles=["solid"])

Ajustar o Modelo Ponderado

Ajustamos um modelo ponderado utilizando o mesmo algoritmo do Passo 4, mas desta vez passamos o argumento sample_weight para o método fit. Em seguida, plotamos a função de decisão do modelo ponderado.

clf = linear_model.SGDClassifier(alpha=0.01, max_iter=100)
clf.fit(X, y, sample_weight=sample_weight)
Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
samples_weights = ax.contour(xx, yy, Z, levels=[0], linestyles=["dashed"])

Adicionar Lenda e Exibir o Gráfico

Adicionamos uma legenda ao gráfico para diferenciar os modelos sem pesos e com pesos. Em seguida, exibimos o gráfico.

no_weights_handles, _ = no_weights.legend_elements()
weights_handles, _ = samples_weights.legend_elements()
ax.legend(
    [no_weights_handles[0], weights_handles[0]],
    ["sem pesos", "com pesos"],
    loc="lower left",
)

ax.set(xticks=(), yticks=())
plt.show()

Resumo

Neste tutorial, aprendemos como plotar uma função de decisão de um conjunto de dados ponderado usando o scikit-learn. Também aprendemos como atribuir diferentes pesos às amostras no conjunto de dados para mostrar como os pesos afetam a função de decisão.