Scikit-Learn MLPClassifier: Estratégias de Aprendizagem Estocástica

Introdução

Este laboratório guiará você pelo processo de utilização do classificador MLPClassifier do Scikit-learn para comparar o desempenho de diferentes estratégias de aprendizagem estocástica, incluindo SGD e Adam. O MLPClassifier é um classificador de rede neural que utiliza retropropagação para otimizar os pesos da rede. O objetivo deste laboratório é mostrar como diferentes estratégias de aprendizagem estocástica podem afetar as curvas de perda de treinamento do MLPClassifier. Usaremos vários conjuntos de dados pequenos para este exemplo, embora a tendência geral mostrada nesses exemplos pareça se estender a conjuntos de dados maiores.

Dicas da Máquina Virtual

Após o término da inicialização da máquina virtual, clique no canto superior esquerdo para mudar para a aba Notebook para acessar o Jupyter Notebook para praticar.

Às vezes, pode ser necessário aguardar alguns segundos para que o Jupyter Notebook termine de carregar. A validação de operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se você enfrentar problemas durante o aprendizado, sinta-se à vontade para perguntar ao Labby. Forneça feedback após a sessão e resolveremos prontamente o problema para você.

Importando bibliotecas necessárias

Primeiro, precisamos importar as bibliotecas necessárias, incluindo MLPClassifier, MinMaxScaler, datasets e matplotlib.pyplot. Também importaremos ConvergenceWarning para ignorar avisos de convergência durante o treinamento.

import warnings

import matplotlib.pyplot as plt

from sklearn.neural_network import MLPClassifier
from sklearn.preprocessing import MinMaxScaler
from sklearn import datasets
from sklearn.exceptions import ConvergenceWarning

Definindo diferentes estratégias de aprendizagem

Em seguida, precisamos definir as diferentes estratégias de aprendizagem que desejamos comparar. Definiremos vários cronogramas diferentes de taxa de aprendizagem e parâmetros de momento, incluindo taxa de aprendizagem constante, constante com momento, constante com momento de Nesterov, taxa de aprendizagem com escala inversa, com escala inversa com momento, com escala inversa com momento de Nesterov e adam. Também definiremos rótulos e plot_args para usar em nosso gráfico posteriormente.

## diferentes cronogramas de taxa de aprendizagem e parâmetros de momento
params = [
    {
        "solver": "sgd",
        "learning_rate": "constant",
        "momentum": 0,
        "learning_rate_init": 0.2,
    },
    {
        "solver": "sgd",
        "learning_rate": "constant",
        "momentum": 0.9,
        "nesterovs_momentum": False,
        "learning_rate_init": 0.2,
    },
    {
        "solver": "sgd",
        "learning_rate": "constant",
        "momentum": 0.9,
        "nesterovs_momentum": True,
        "learning_rate_init": 0.2,
    },
    {
        "solver": "sgd",
        "learning_rate": "invscaling",
        "momentum": 0,
        "learning_rate_init": 0.2,
    },
    {
        "solver": "sgd",
        "learning_rate": "invscaling",
        "momentum": 0.9,
        "nesterovs_momentum": True,
        "learning_rate_init": 0.2,
    },
    {
        "solver": "sgd",
        "learning_rate": "invscaling",
        "momentum": 0.9,
        "nesterovs_momentum": False,
        "learning_rate_init": 0.2,
    },
    {"solver": "adam", "learning_rate_init": 0.01},
]

labels = [
    "taxa de aprendizagem constante",
    "constante com momento",
    "constante com momento de Nesterov",
    "taxa de aprendizagem com escala inversa",
    "escala inversa com momento",
    "escala inversa com momento de Nesterov",
    "adam",
]

plot_args = [
    {"c": "red", "linestyle": "-"},
    {"c": "green", "linestyle": "-"},
    {"c": "blue", "linestyle": "-"},
    {"c": "red", "linestyle": "--"},
    {"c": "green", "linestyle": "--"},
    {"c": "blue", "linestyle": "--"},
    {"c": "black", "linestyle": "-"},
]

Definir uma função para plotar as curvas de aprendizagem

Em seguida, precisamos definir uma função que plotará as curvas de aprendizagem para cada estratégia de aprendizagem em cada conjunto de dados. A função recebe o conjunto de dados (X, y), um eixo para plotar e um nome para o conjunto de dados. Usaremos MinMaxScaler para escalar os dados e MLPClassifier para treinar a rede neural. Treinaremos a rede usando cada estratégia de aprendizagem, ignorando avisos de convergência, e plotaremos as curvas de aprendizagem para cada estratégia no mesmo gráfico.

def plot_on_dataset(X, y, ax, name):
    ## para cada conjunto de dados, plota o aprendizado para cada estratégia de aprendizagem
    print("\naprendendo no conjunto de dados %s" % name)
    ax.set_title(name)

    X = MinMaxScaler().fit_transform(X)
    mlps = []
    if name == "digits":
        ## digits é maior, mas converge razoavelmente rápido
        max_iter = 15
    else:
        max_iter = 400

    for label, param in zip(labels, params):
        print("treinamento: %s" % label)
        mlp = MLPClassifier(random_state=0, max_iter=max_iter, **param)

        ## algumas combinações de parâmetros não convergirão, como pode ser visto nos
        ## gráficos, portanto, são ignoradas aqui
        with warnings.catch_warnings():
            warnings.filterwarnings(
                "ignore", category=ConvergenceWarning, module="sklearn"
            )
            mlp.fit(X, y)

        mlps.append(mlp)
        print("Pontuação do conjunto de treinamento: %f" % mlp.score(X, y))
        print("Perda do conjunto de treinamento: %f" % mlp.loss_)
    for mlp, label, args in zip(mlps, labels, plot_args):
        ax.plot(mlp.loss_curve_, label=label, **args)

Carregar ou gerar conjuntos de dados pequenos

Agora, precisamos carregar ou gerar os pequenos conjuntos de dados que usaremos neste exemplo. Usaremos o conjunto de dados iris, o conjunto de dados digits e dois conjuntos de dados gerados usando as funções make_circles e make_moons.

iris = datasets.load_iris()
X_digits, y_digits = datasets.load_digits(return_X_y=True)
data_sets = [
    (iris.data, iris.target),
    (X_digits, y_digits),
    datasets.make_circles(noise=0.2, factor=0.5, random_state=1),
    datasets.make_moons(noise=0.3, random_state=0),
]

Plotar as curvas de aprendizagem para cada conjunto de dados

Finalmente, podemos plotar as curvas de aprendizagem para cada conjunto de dados usando a função plot_on_dataset. Criaremos um gráfico 2x2 e plotaremos cada conjunto de dados em um eixo separado.

fig, axes = plt.subplots(2, 2, figsize=(15, 10))

for ax, data, name in zip(
    axes.ravel(), data_sets, ["iris", "digits", "circles", "moons"]
):
    plot_on_dataset(*data, ax=ax, name=name)

fig.legend(ax.get_lines(), labels, ncol=3, loc="upper center")
plt.show()

Resumo

Neste laboratório, utilizamos o classificador MLPClassifier do Scikit-learn para comparar o desempenho de diferentes estratégias de aprendizagem estocástica, incluindo SGD e Adam, em vários conjuntos de dados pequenos. Definimos diferentes escalas de taxa de aprendizagem e parâmetros de momento, e, em seguida, treinamos o MLPClassifier usando cada estratégia. Plotamos as curvas de aprendizagem para cada estratégia em cada conjunto de dados e observamos como diferentes estratégias podem afetar as curvas de perda de treinamento. Demonstramos a importância de escolher a estratégia de aprendizagem correta para o conjunto de dados e a tarefa em questão.