Early Stopping para Machine Learning

Introdução

Neste projeto, você aprenderá como implementar a técnica de early stopping (parada antecipada) em modelos de machine learning (aprendizado de máquina). Early stopping é um método poderoso para prevenir overfitting (superajuste) e melhorar o desempenho de seus modelos.

🎯 Tarefas

Neste projeto, você aprenderá:

• Compreender o conceito de early stopping e suas principais etapas
• Implementar a função de early stopping para determinar a época de parada ideal
• Testar a função de early stopping em um conjunto de dados de exemplo

🏆 Conquistas

Após concluir este projeto, você será capaz de:

• Dividir um conjunto de dados em conjuntos de treinamento e validação
• Monitorar o desempenho do modelo no conjunto de validação durante o treinamento
• Definir um critério de parada com base na perda do conjunto de validação
• Usar a função de early stopping para otimizar o processo de treinamento do seu modelo

Entenda o Conceito de Early Stopping e Implemente a Função

Nesta etapa, você aprenderá primeiro sobre o conceito de early stopping e suas principais etapas.

A ideia básica por trás do early stopping é calcular o desempenho do modelo em um conjunto de validação durante o treinamento. Quando o desempenho do modelo no conjunto de validação começa a diminuir, o treinamento é interrompido para evitar overfitting (superajuste). As principais etapas são as seguintes:

1. Dividir o conjunto de dados de treinamento original em um conjunto de treinamento e um conjunto de validação.
2. Treinar o modelo apenas no conjunto de treinamento e calcular o erro do modelo no conjunto de validação ao final de cada época (epoch).
3. Comparar o erro do modelo no conjunto de validação com o histórico de treinamento. Interromper o treinamento quando a comparação atender ao critério de parada (stopping criterion).
4. Usar os parâmetros da última iteração como os parâmetros finais para o modelo.

Existem muitos critérios de parada diferentes, e eles podem ser bastante flexíveis. Um critério comumente usado é monitorar o valor da perda no conjunto de validação. Quando o valor da perda não foi otimizado por n épocas consecutivas (sempre maior que a perda mínima), o treinamento é interrompido.

Agora, você implementará a função early_stop no arquivo early_stop.py.

A função verifica os valores de perda época por época. Se a perda não melhorar (diminuir) por um número de épocas igual a patience (paciência), recomenda-se interromper o treinamento.

Aqui está o código para a função early_stop:

def early_stop(loss: List[float], patience: int) -> Tuple[int, float]:
    """
    Determina a época em que o treinamento deve ser interrompido com base nos valores de perda fornecidos e na paciência.

    A função verifica os valores de perda época por época. Se a perda não melhorar (diminuir) por um
    número de épocas igual a `patience`, recomenda-se interromper o treinamento.

    Parâmetros:
    - loss (List[float]): Uma lista de valores de perda, normalmente na ordem em que foram registrados durante o treinamento.
    - patience (int): O número de épocas sem melhora na perda após as quais o treinamento deve ser interrompido.

    Retorna:
    - Tuple[int, float]: Uma tupla contendo dois valores:
        1. O número da época em que o treinamento deve ser interrompido (indexado em 1).
        2. O valor mínimo de perda registrado até aquele ponto.
    """

    min_loss = np.Inf
    max_patience = 0
    stop_epoch = 0
    for epoch, current_loss in enumerate(loss):
        if current_loss < min_loss:
            min_loss = current_loss
            stop_epoch = epoch
            max_patience = 0
        else:
            max_patience += 1
        if max_patience == patience:
            break
    stop_epoch += 1
    return stop_epoch, min_loss

Na função early_stop, você implementa a lógica para determinar a época em que o treinamento deve ser interrompido com base nos valores de perda fornecidos e no parâmetro patience.

A função deve retornar uma tupla contendo dois valores:

1. O número da época em que o treinamento deve ser interrompido (indexado em 1).
2. O valor mínimo de perda registrado até aquele ponto.

Teste a Função de Early Stopping

Nesta etapa, você testará a função early_stop executando o arquivo early_stop.py.

Adicione o seguinte código no arquivo early_stop.py:

if __name__ == "__main__":
    loss = [
        1.11,
        1.01,
        0.99,
        0.89,
        0.77,
        0.69,
        0.57,
        0.44,
        0.51,
        0.43,
        0.55,
        0.61,
        0.77,
        0.89,
        0.78,
    ]
    patience = 3
    stop_epoch, min_loss = early_stop(loss, patience)
    print(f"{stop_epoch=}, {min_loss=}")

Em seguida, execute o script a partir do terminal:

python early_stop.py

A saída deve ser:

stop_epoch = 10, loss = 0.43

Isso significa que o treinamento deve ser interrompido na época 10, e o valor mínimo de perda registrado até aquele ponto é 0.43.

Parabéns! Você implementou com sucesso a função de early stopping. Agora você pode usar esta função em seus projetos de machine learning para evitar overfitting e melhorar o desempenho de seus modelos.

Resumo

Parabéns! Você concluiu este projeto. Você pode praticar mais laboratórios no LabEx para aprimorar suas habilidades.